ofVectorMath -> glm, work in progress

addons/ofxAndroid/src/ofAppAndroidWindow.cpp

@@ -150,8 +150,8 @@ void ofAppAndroidWindow::draw(){
 
 }
 
-ofPoint	ofAppAndroidWindow::getWindowSize(){
-	return ofPoint(sWindowWidth,sWindowHeight);
+glm::vec2 ofAppAndroidWindow::getWindowSize(){
+	return glm::vec2(sWindowWidth,sWindowHeight);
 }
 
 int	ofAppAndroidWindow::getWidth(){

addons/ofxAndroid/src/ofAppAndroidWindow.h

@@ -36,9 +36,9 @@ class ofAppAndroidWindow: public ofAppBaseGLESWindow {
 	void	setWindowPosition(int x, int y) {}
 	void	setWindowShape(int w, int h) {}
 
-	ofPoint	getWindowPosition() {return ofPoint(); }
-	ofPoint	getWindowSize();
-	ofPoint	getScreenSize(){return getWindowSize(); }
+	glm::vec2	getWindowPosition() {return glm::vec2(); }
+	glm::vec2	getWindowSize();
+	glm::vec2	getScreenSize(){return getWindowSize(); }
 
 	int		getWidth();
 	int		getHeight();

addons/ofxAssimpModelLoader/src/ofxAssimpModelLoader.cpp

@@ -324,7 +324,7 @@ void ofxAssimpModelLoader::loadGLResources(){
         	meshHelper.vbo.setNormalData(&mesh->mNormals[0].x,mesh->mNumVertices,usage,sizeof(aiVector3D));
         }
         if (meshHelper.cachedMesh.hasTexCoords()){			
-        	meshHelper.vbo.setTexCoordData(meshHelper.cachedMesh.getTexCoordsPointer()[0].getPtr(),mesh->mNumVertices,GL_STATIC_DRAW,sizeof(ofVec2f));
+			meshHelper.vbo.setTexCoordData(&meshHelper.cachedMesh.getTexCoords()[0].x, mesh->mNumVertices,GL_STATIC_DRAW,sizeof(ofVec2f));
         }
 
         meshHelper.indices.resize(mesh->mNumFaces * 3);

addons/ofxAssimpModelLoader/src/ofxAssimpUtils.h

@@ -13,71 +13,66 @@
 #include <assimp/postprocess.h>
 
 //--------------------------------------------------------------
-static inline ofFloatColor aiColorToOfColor(const aiColor4D& c){
+inline ofFloatColor aiColorToOfColor(const aiColor4D& c){
 	return ofFloatColor(c.r,c.g,c.b,c.a);
 }
 
 //--------------------------------------------------------------
-static inline ofFloatColor aiColorToOfColor(const aiColor3D& c){
+inline ofFloatColor aiColorToOfColor(const aiColor3D& c){
 	return ofFloatColor(c.r,c.g,c.b,1);
 }
 
 //--------------------------------------------------------------
-static inline ofVec3f aiVecToOfVec(const aiVector3D& v){
-	return ofVec3f(v.x,v.y,v.z);
+inline ofDefaultVec3 aiVecToOfVec(const aiVector3D& v){
+	return ofDefaultVec3(v.x,v.y,v.z);
 }
 
-static inline vector<ofVec3f> aiVecVecToOfVecVec(const vector<aiVector3D>& v){
-	vector<ofVec3f> ofv(v.size());
-	if(sizeof(aiVector3D)==sizeof(ofVec3f)){
-		memcpy(&ofv[0],&v[0],v.size()*sizeof(ofVec3f));
-	}else{
-		for(int i=0;i<(int)v.size();i++){
-			ofv[i]=aiVecToOfVec(v[i]);
-		}
-	}
+//--------------------------------------------------------------
+inline vector<ofDefaultVec3> aiVecVecToOfVecVec(const vector<aiVector3D>& v){
+	vector<ofDefaultVec3> ofv(v.size());
+	memcpy(ofv.data(),v.data(),v.size()*sizeof(ofDefaultVec3));
 	return ofv;
 }
 
 //--------------------------------------------------------------
-static void aiMeshToOfMesh(const aiMesh* aim, ofMesh& ofm, ofxAssimpMeshHelper * helper = NULL){
-    
+inline void aiMeshToOfMesh(const aiMesh* aim, ofMesh& ofm, ofxAssimpMeshHelper * helper = NULL){
+
 	// default to triangle mode
 	ofm.setMode(OF_PRIMITIVE_TRIANGLES);
-    
+
 	// copy vertices
 	for (int i=0; i < (int)aim->mNumVertices;i++){
 		ofm.addVertex(ofVec3f(aim->mVertices[i].x,aim->mVertices[i].y,aim->mVertices[i].z));
 	}
-    
+
 	if(aim->HasNormals()){
 		for (int i=0; i < (int)aim->mNumVertices;i++){
 			ofm.addNormal(ofVec3f(aim->mNormals[i].x,aim->mNormals[i].y,aim->mNormals[i].z));
 		}
 	}
-    
+
 	// aiVector3D * 	mTextureCoords [AI_MAX_NUMBER_OF_TEXTURECOORDS]
 	// just one for now
 	if(aim->GetNumUVChannels()>0){
 		for (int i=0; i < (int)aim->mNumVertices;i++){
 			if(helper && helper->hasTexture()){
-                ofTexture & tex = helper->getTextureRef();
+				ofTexture & tex = helper->getTextureRef();
 				ofVec2f texCoord = tex.getCoordFromPercent(aim->mTextureCoords[0][i].x ,aim->mTextureCoords[0][i].y);
 				ofm.addTexCoord(texCoord);
 			}else{
 				ofm.addTexCoord(ofVec2f(aim->mTextureCoords[0][i].x ,aim->mTextureCoords[0][i].y));
 			}
 		}
 	}
-    
+
 	//aiColor4D * 	mColors [AI_MAX_NUMBER_OF_COLOR_SETS]
 	// just one for now
 	if(aim->GetNumColorChannels()>0){
 		for (int i=0; i < (int)aim->mNumVertices;i++){
 			ofm.addColor(aiColorToOfColor(aim->mColors[0][i]));
 		}
 	}
-    
+
 	for (int i=0; i <(int) aim->mNumFaces;i++){
 		if(aim->mFaces[i].mNumIndices>3){
 			ofLogWarning("ofxAssimpUtils") << "aiMeshToOfMesh(): non triangular face found: model face " << i;
@@ -87,13 +82,3 @@ static void aiMeshToOfMesh(const aiMesh* aim, ofMesh& ofm, ofxAssimpMeshHelper *
 		}
 	}
 }
-
-//--------------------------------------------------------------
-static void aiMatrix4x4ToOfMatrix4x4(const aiMatrix4x4& aim, ofNode& ofm){
-	float m[16] = { aim.a1,aim.a2,aim.a3,aim.a4,
-        aim.b1,aim.b2,aim.b3,aim.b4,
-        aim.c1,aim.c2,aim.c3,aim.c4,
-        aim.d1,aim.d2,aim.d3,aim.d4 };
-
-	ofm.setTransformMatrix(	m);
-}

addons/ofxEmscripten/src/ofxAppEmscriptenWindow.cpp

@@ -59,11 +59,11 @@ void ofxAppEmscriptenWindow::setup(const ofGLESWindowSettings & settings){
 	EGLint contextAttribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE, EGL_NONE };
 	EGLint attribList[] =
 	   {
-		   EGL_RED_SIZE, 8,
-		   EGL_GREEN_SIZE, 8,
-		   EGL_BLUE_SIZE, 8,
-		   EGL_ALPHA_SIZE, 8,
-		   EGL_DEPTH_SIZE, 8,
+		   EGL_RED_SIZE, EGL_DONT_CARE,
+		   EGL_GREEN_SIZE, EGL_DONT_CARE,
+		   EGL_BLUE_SIZE, EGL_DONT_CARE,
+		   EGL_ALPHA_SIZE, EGL_DONT_CARE,
+		   EGL_DEPTH_SIZE, EGL_DONT_CARE,
 		   EGL_STENCIL_SIZE, EGL_DONT_CARE,
 		   EGL_SAMPLE_BUFFERS, EGL_DONT_CARE,
 		   EGL_NONE
@@ -87,6 +87,8 @@ void ofxAppEmscriptenWindow::setup(const ofGLESWindowSettings & settings){
 		ofLogError() << "couldn't get configs";
 		return;
 	}
+
+	ofLogNotice("ofxAppEmscriptenWindow") << "Got " << numConfigs << " display configs";
 
 	// Choose config
 	if ( !eglChooseConfig(display, attribList, &config, 1, &numConfigs) ){
@@ -103,9 +105,9 @@ void ofxAppEmscriptenWindow::setup(const ofGLESWindowSettings & settings){
 
 	// Create a GL context
 	context = eglCreateContext(display, config, EGL_NO_CONTEXT, contextAttribs );
-	if ( context == EGL_NO_CONTEXT )
-	{
-	  return;
+	if ( context == EGL_NO_CONTEXT ){
+		ofLogError() << "couldn't create context";
+	    return;
 	}
 
 	// Make the context current
@@ -258,20 +260,20 @@ void ofxAppEmscriptenWindow::setWindowShape(int w, int h){
 
 
 
-ofPoint	ofxAppEmscriptenWindow::getWindowPosition(){
-	return ofVec2f(0,0);
+glm::vec2 ofxAppEmscriptenWindow::getWindowPosition(){
+	return glm::vec2(0,0);
 }
 
 
-ofPoint	ofxAppEmscriptenWindow::getWindowSize(){
+glm::vec2 ofxAppEmscriptenWindow::getWindowSize(){
 	int width;
 	int height;
 	int isFullscreen;
 	emscripten_get_canvas_size( &width, &height, &isFullscreen );
-	return ofVec2f(width,height);
+	return glm::vec2(width,height);
 }
 
-ofPoint	ofxAppEmscriptenWindow::getScreenSize(){
+glm::vec2 ofxAppEmscriptenWindow::getScreenSize(){
 	return getWindowSize();
 }
 

addons/ofxEmscripten/src/ofxAppEmscriptenWindow.h

@@ -35,9 +35,9 @@ class ofxAppEmscriptenWindow: public ofAppBaseGLESWindow {
 	void	setWindowPosition(int x, int y);
 	void	setWindowShape(int w, int h);
 
-	ofPoint	getWindowPosition();
-	ofPoint	getWindowSize();
-	ofPoint	getScreenSize();
+	glm::vec2	getWindowPosition();
+	glm::vec2	getWindowSize();
+	glm::vec2	getScreenSize();
 
 	void			setOrientation(ofOrientation orientation);
 	ofOrientation	getOrientation();

addons/ofxGui/src/ofxGuiGroup.cpp

@@ -74,13 +74,13 @@ ofxGuiGroup * ofxGuiGroup::setup(const ofParameterGroup & _parameters, const std
 		}else if(type == typeid(ofParameter <bool> ).name()){
 			auto p = _parameters.getBool(i);
 			add(p);
-		}else if(type == typeid(ofParameter <ofVec2f> ).name()){
+		}else if(type == typeid(ofParameter <ofDefaultVec2> ).name()){
 			auto p = _parameters.getVec2f(i);
 			add(p);
-		}else if(type == typeid(ofParameter <ofVec3f> ).name()){
+		}else if(type == typeid(ofParameter <ofDefaultVec3> ).name()){
 			auto p = _parameters.getVec3f(i);
 			add(p);
-		}else if(type == typeid(ofParameter <ofVec4f> ).name()){
+		}else if(type == typeid(ofParameter <ofDefaultVec4> ).name()){
 			auto p = _parameters.getVec4f(i);
 			add(p);
 		}else if(type == typeid(ofParameter <ofColor> ).name()){
@@ -179,6 +179,18 @@ void ofxGuiGroup::add(ofParameter <ofVec4f> & parameter){
 	add(new ofxVecSlider_ <ofVec4f>(parameter, b.width));
 }
 
+void ofxGuiGroup::add(ofParameter <glm::vec2> & parameter){
+	add(new ofxVecSlider_ <glm::vec2>(parameter, b.width));
+}
+
+void ofxGuiGroup::add(ofParameter <glm::vec3> & parameter){
+	add(new ofxVecSlider_ <glm::vec3>(parameter, b.width));
+}
+
+void ofxGuiGroup::add(ofParameter <glm::vec4> & parameter){
+	add(new ofxVecSlider_ <glm::vec4>(parameter, b.width));
+}
+
 void ofxGuiGroup::add(ofParameter <ofColor> & parameter){
 	add(new ofxColorSlider_ <unsigned char>(parameter, b.width));
 }

addons/ofxGui/src/ofxGuiGroup.h

@@ -27,6 +27,9 @@ class ofxGuiGroup : public ofxBaseGui {
 		void add(ofParameter <ofVec2f> & parameter);
 		void add(ofParameter <ofVec3f> & parameter);
 		void add(ofParameter <ofVec4f> & parameter);
+		void add(ofParameter <glm::vec2> & parameter);
+		void add(ofParameter <glm::vec3> & parameter);
+		void add(ofParameter <glm::vec4> & parameter);
 		void add(ofParameter <ofColor> & parameter);
 		void add(ofParameter <ofShortColor> & parameter);
 		void add(ofParameter <ofFloatColor> & parameter);

addons/ofxGui/src/ofxSliderGroup.cpp

@@ -22,7 +22,7 @@ ofxVecSlider_<VecType> * ofxVecSlider_<VecType>::setup(ofParameter<VecType> valu
     VecType min = value.getMin();
     VecType max = value.getMax();
 
-    for (int i=0; i<VecType::DIM; i++) {
+	for (int i=0; i<dim(); i++) {
     	ofParameter<float> p(names[i], val[i], min[i], max[i]);
         add(new ofxSlider<float>(p, width, height));
         p.addListener(this, & ofxVecSlider_::changeSlider);
@@ -55,11 +55,41 @@ void ofxVecSlider_<VecType>::changeValue(VecType & value){
     if (sliderChanging){
         return;
     }
-    for (int i=0; i<VecType::DIM; i++){
+	for (int i=0; i<dim(); i++){
         parameters[i].template cast<float>() = value[i];
     }
 }
 
+template<>
+size_t ofxVecSlider_<glm::vec2>::dim(){
+	return 2;
+}
+
+template<>
+size_t ofxVecSlider_<glm::vec3>::dim(){
+	return 3;
+}
+
+template<>
+size_t ofxVecSlider_<glm::vec4>::dim(){
+	return 4;
+}
+
+template<>
+size_t ofxVecSlider_<ofVec2f>::dim(){
+	return 2;
+}
+
+template<>
+size_t ofxVecSlider_<ofVec3f>::dim(){
+	return 3;
+}
+
+template<>
+size_t ofxVecSlider_<ofVec4f>::dim(){
+	return 4;
+}
+
 template<class VecType>
 ofAbstractParameter & ofxVecSlider_<VecType>::getParameter(){
 	return value;
@@ -84,6 +114,9 @@ const VecType * ofxVecSlider_<VecType>::operator->(){
 template class ofxVecSlider_<ofVec2f>;
 template class ofxVecSlider_<ofVec3f>;
 template class ofxVecSlider_<ofVec4f>;
+template class ofxVecSlider_<glm::vec2>;
+template class ofxVecSlider_<glm::vec3>;
+template class ofxVecSlider_<glm::vec4>;
 
 
 template<class ColorType>

addons/ofxGui/src/ofxSliderGroup.h

@@ -22,13 +22,14 @@ class ofxVecSlider_ : public ofxGuiGroup {
 protected:
     void changeSlider(const void * parameter, float & value);
     void changeValue(VecType & value);
+	static size_t dim();
     ofParameter<VecType> value;
     bool sliderChanging;
 };
 
-typedef ofxVecSlider_<ofVec3f> ofxVec3Slider;
-typedef ofxVecSlider_<ofVec2f> ofxVec2Slider;
-typedef ofxVecSlider_<ofVec4f> ofxVec4Slider;
+typedef ofxVecSlider_<ofDefaultVec3> ofxVec3Slider;
+typedef ofxVecSlider_<ofDefaultVec2> ofxVec2Slider;
+typedef ofxVecSlider_<ofDefaultVec4> ofxVec4Slider;
 typedef ofxVecSlider_<ofVec3f> ofxPointSlider;
 
 template<typename ColorType>

libs/glm/include/glm/CMakeLists.txt

@@ -0,0 +1,44 @@
+set(NAME glm_dummy)
+
+file(GLOB ROOT_SOURCE *.cpp)
+file(GLOB ROOT_INLINE *.inl)
+file(GLOB ROOT_HEADER *.hpp)
+file(GLOB ROOT_TEXT ../*.txt)
+file(GLOB ROOT_MD ../*.md)
+file(GLOB ROOT_NAT ../util/glm.natvis)
+
+file(GLOB_RECURSE CORE_SOURCE ./detail/*.cpp)
+file(GLOB_RECURSE CORE_INLINE ./detail/*.inl)
+file(GLOB_RECURSE CORE_HEADER ./detail/*.hpp)
+
+file(GLOB_RECURSE GTC_SOURCE ./gtc/*.cpp)
+file(GLOB_RECURSE GTC_INLINE ./gtc/*.inl)
+file(GLOB_RECURSE GTC_HEADER ./gtc/*.hpp)
+
+file(GLOB_RECURSE GTX_SOURCE ./gtx/*.cpp)
+file(GLOB_RECURSE GTX_INLINE ./gtx/*.inl)
+file(GLOB_RECURSE GTX_HEADER ./gtx/*.hpp)
+
+source_group("Text Files" FILES ${ROOT_TEXT} ${ROOT_MD})
+source_group("Core Files" FILES ${CORE_SOURCE})
+source_group("Core Files" FILES ${CORE_INLINE})
+source_group("Core Files" FILES ${CORE_HEADER})
+source_group("GTC Files" FILES ${GTC_SOURCE})
+source_group("GTC Files" FILES ${GTC_INLINE})
+source_group("GTC Files" FILES ${GTC_HEADER})
+source_group("GTX Files" FILES ${GTX_SOURCE})
+source_group("GTX Files" FILES ${GTX_INLINE})
+source_group("GTX Files" FILES ${GTX_HEADER})
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
+
+if(GLM_TEST_ENABLE)
+	add_executable(${NAME} ${ROOT_TEXT} ${ROOT_MD} ${ROOT_NAT}
+		${ROOT_SOURCE}    ${ROOT_INLINE}    ${ROOT_HEADER}
+		${CORE_SOURCE}    ${CORE_INLINE}    ${CORE_HEADER}
+		${GTC_SOURCE}     ${GTC_INLINE}     ${GTC_HEADER}
+		${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER})
+endif(GLM_TEST_ENABLE)
+
+#add_library(glm STATIC glm.cpp)
+#add_library(glm_shared SHARED glm.cpp)