glm transition - deprecations implicit conversions, remove implicit conversions from the core.

libs/openFrameworks/3d/ofNode.cpp

@@ -132,9 +132,9 @@ void ofNode::setParent(ofNode& parent, bool bMaintainGlobalTransform) {
 		clearParent(bMaintainGlobalTransform);
 	}
 	if(bMaintainGlobalTransform) {
-		auto postParentPosition = position - parent.getGlobalPosition();
+		auto postParentPosition = position.get() - parent.getGlobalPosition();
 		auto postParentOrientation = orientation.get() * glm::inverse(parent.getGlobalOrientation());
-		auto postParentScale = scale / parent.getGlobalScale();
+		auto postParentScale = scale.get() / parent.getGlobalScale();
 		parent.addListener(*this);
 		setOrientation(postParentOrientation);
 		setPosition(postParentPosition);
@@ -597,7 +597,7 @@ void ofNode::orbitDeg(float longitude, float latitude, float radius, const glm::
 	p = q * p;							   // rotate p on unit sphere based on quaternion
 	p = p * radius;						   // scale p by radius from its position on unit sphere
 
-	setGlobalPosition(centerPoint + p);
+	setGlobalPosition(centerPoint + p.xyz());
 	setOrientation(q);
 
 	onOrientationChanged();
@@ -620,7 +620,7 @@ void ofNode::orbitRad(float longitude, float latitude, float radius, const glm::
 	p = q * p;							   // rotate p on unit sphere based on quaternion
 	p = p * radius;						   // scale p by radius from its position on unit sphere
 
-	setGlobalPosition(centerPoint + p);
+	setGlobalPosition(centerPoint + p.xyz());
 	setOrientation(q);
 
 	onOrientationChanged();

libs/openFrameworks/app/ofAppGLFWWindow.cpp

@@ -756,7 +756,7 @@ void ofAppGLFWWindow::setFullscreen(bool fullscreen){
         GLFWmonitor** monitors = glfwGetMonitors(&monitorCount);
 
 		int currentMonitor = getCurrentMonitor();
-		ofVec3f screenSize = getScreenSize();
+		auto screenSize = getScreenSize();
 
 		if( orientation == OF_ORIENTATION_90_LEFT || orientation == OF_ORIENTATION_90_RIGHT ){
 			std::swap(screenSize.x, screenSize.y);
@@ -811,8 +811,7 @@ void ofAppGLFWWindow::setFullscreen(bool fullscreen){
 
 		// make sure to save current pos if not specified in settings
 		if( settings.isPositionSet() ) {
-			ofVec3f pos = getWindowPosition();
-			settings.setPosition(ofVec2f(pos.x, pos.y));
+			settings.setPosition(getWindowPosition());
 		}
 
         //make sure the window is getting the mouse/key events

libs/openFrameworks/graphics/ofGraphics.cpp

@@ -1138,14 +1138,14 @@ void ofVertices( const vector <glm::vec2> & polyPoints ){
 //----------------------------------------------------------
 void ofVertices( const vector <ofVec3f> & polyPoints ){
 	for( const auto & p: polyPoints ){
-		ofGetCurrentRenderer()->getPath().lineTo(p);
+		ofGetCurrentRenderer()->getPath().lineTo(glm::vec3(p.x, p.y, p.z));
 	}
 }
 
 //----------------------------------------------------------
 void ofVertices( const vector <ofVec2f> & polyPoints ){
 	for( const auto & p: polyPoints ){
-		ofGetCurrentRenderer()->getPath().lineTo(p);
+		ofGetCurrentRenderer()->getPath().lineTo(glm::vec3(p.x, p.y, 0.0));
 	}
 }
 
@@ -1176,14 +1176,14 @@ void ofCurveVertices( const vector <glm::vec2> & curvePoints){
 //----------------------------------------------------------
 void ofCurveVertices( const vector <ofVec3f> & curvePoints){
 	for( const auto & p: curvePoints ){
-		ofGetCurrentRenderer()->getPath().curveTo(p);
+		ofGetCurrentRenderer()->getPath().curveTo(glm::vec3(p.x, p.y, p.z));
 	}
 }
 
 //----------------------------------------------------------
 void ofCurveVertices( const vector <ofVec2f> & curvePoints){
 	for( const auto & p: curvePoints ){
-		ofGetCurrentRenderer()->getPath().curveTo(p);
+		ofGetCurrentRenderer()->getPath().curveTo(glm::vec3(p.x, p.y, 0.0));
 	}
 }
 

libs/openFrameworks/math/ofMatrix3x3.h

@@ -42,11 +42,11 @@ class ofMatrix3x3 {
 				float _g=0.0, float _h=0.0, float _i=0.0 );
 
 
-	ofMatrix3x3( const glm::mat3 & mat) {
+	OF_DEPRECATED_MSG("Use glm::mat3.", ofMatrix3x3( const glm::mat3 & mat)) {
 		*this = reinterpret_cast<const ofMatrix3x3&>(mat);
 	}
 
-	operator glm::mat3(){
+	OF_DEPRECATED_MSG("Use glm::mat3.", operator glm::mat3()) {
 		return *reinterpret_cast<glm::mat3*>(this);
 	}
 

libs/openFrameworks/math/ofMatrix4x4.h

@@ -70,11 +70,11 @@ class ofMatrix4x4 {
 		makeIdentityMatrix();
 	}
 
-	ofMatrix4x4( const glm::mat4 & mat) {
+	OF_DEPRECATED_MSG("Use glm::mat4.", ofMatrix4x4( const glm::mat4 & mat)) {
 		*this = reinterpret_cast<const ofMatrix4x4&>(mat);
 	}
 
-	operator glm::mat4(){
+	OF_DEPRECATED_MSG("Use glm::mat4.", operator glm::mat4()) {
 		return *reinterpret_cast<glm::mat4*>(this);
 	}
 

libs/openFrameworks/math/ofQuaternion.h

@@ -43,9 +43,9 @@ class ofQuaternion {
 
     // rotation order is axis3,axis2,axis1
     inline ofQuaternion(float angle1, const ofVec3f& axis1, float angle2, const ofVec3f& axis2, float angle3, const ofVec3f& axis3);
-    
-	inline ofQuaternion(const glm::quat & q);
-	inline operator glm::quat() const;
+
+	OF_DEPRECATED_MSG("Use glm::vec4.", inline ofQuaternion(const glm::quat & q));
+	OF_DEPRECATED_MSG("Use glm::vec4.", inline operator glm::quat() const);
 
     /// \}
 

libs/openFrameworks/math/ofVec2f.h

@@ -126,11 +126,10 @@ class ofVec2f {
 
 	/// \}
 
-	ofVec2f(const glm::vec2 & v);
-	ofVec2f(const glm::vec3 & v);
-	ofVec2f(const glm::vec4 & v);
-
-	operator glm::vec2() const;
+	OF_DEPRECATED_MSG("Use glm::vec2.", ofVec2f(const glm::vec2 & v));
+	OF_DEPRECATED_MSG("Use glm::vec2.", ofVec2f(const glm::vec3 & v));
+	OF_DEPRECATED_MSG("Use glm::vec2.", ofVec2f(const glm::vec4 & v));
+	OF_DEPRECATED_MSG("Use glm::vec2.", operator glm::vec2() const);
 
 	//---------------------
 	/// \name Access components

libs/openFrameworks/math/ofVec3f.h

@@ -125,10 +125,10 @@ class ofVec3f {
 	/// ~~~~
     ofVec3f( const ofVec4f& vec );
 
-	ofVec3f( const glm::vec2 & vec );
-	ofVec3f( const glm::vec3 & vec );
-	ofVec3f( const glm::vec4 & vec );
-	operator glm::vec3() const;
+	OF_DEPRECATED_MSG("Use glm::vec3.", ofVec3f( const glm::vec2 & vec ));
+	OF_DEPRECATED_MSG("Use glm::vec3.", ofVec3f( const glm::vec3 & vec ));
+	OF_DEPRECATED_MSG("Use glm::vec3.", ofVec3f( const glm::vec4 & vec ));
+	OF_DEPRECATED_MSG("Use glm::vec3.", operator glm::vec3() const);
 
 	/// \}
 

libs/openFrameworks/math/ofVec4f.h

@@ -24,10 +24,10 @@ class ofVec4f {
 	ofVec4f( float _x, float _y, float _z, float _w );
 	ofVec4f( const ofVec2f& vec);
 	ofVec4f( const ofVec3f& vec);
-	ofVec4f( const glm::vec2& vec);
-	ofVec4f( const glm::vec3& vec);
-	ofVec4f( const glm::vec4& vec);
-	operator glm::vec4() const;
+	OF_DEPRECATED_MSG("Use glm::vec4.", ofVec4f( const glm::vec2& vec));
+	OF_DEPRECATED_MSG("Use glm::vec4.", ofVec4f( const glm::vec3& vec));
+	OF_DEPRECATED_MSG("Use glm::vec4.", ofVec4f( const glm::vec4& vec));
+	OF_DEPRECATED_MSG("Use glm::vec4.", operator glm::vec4() const);
 
     /// \}
 

libs/openFrameworks/math/ofVectorMath.h

@@ -243,88 +243,88 @@ namespace glm {
 
 //--------------------------------------------------------------
 inline glm::vec3 operator+(const glm::vec3 & v1, const ofVec3f & v2){
-	return v1 + glm::vec3(v2);
+	return v1 + glm::vec3(v2.x, v2.y, v2.z);
 }
 
 //--------------------------------------------------------------
 inline glm::vec3 operator-(const glm::vec3 & v1, const ofVec3f & v2){
-	return v1 - glm::vec3(v2);
+	return v1 - glm::vec3(v2.x, v2.y, v2.z);
 }
 
 //--------------------------------------------------------------
 inline glm::vec3 operator*(const glm::vec3 & v1, const ofVec3f & v2){
-	return v1 * glm::vec3(v2);
+	return v1 * glm::vec3(v2.x, v2.y, v2.z);
 }
 
 //--------------------------------------------------------------
 inline glm::vec3 operator/(const glm::vec3 & v1, const ofVec3f & v2){
-	return v1 / glm::vec3(v2);
+	return v1 / glm::vec3(v2.x, v2.y, v2.z);
 }
 
 //--------------------------------------------------------------
 inline glm::vec3 & operator+=(glm::vec3 & v1, const ofVec3f & v2){
-	v1 += glm::vec3(v2);
+	v1 += glm::vec3(v2.x, v2.y, v2.z);
 	return v1;
 }
 
 //--------------------------------------------------------------
 inline glm::vec3 & operator-=(glm::vec3 & v1, const ofVec3f & v2){
-	v1 -= glm::vec3(v2);
+	v1 -= glm::vec3(v2.x, v2.y, v2.z);
 	return v1;
 }
 
 //--------------------------------------------------------------
 inline glm::vec3 & operator*=(glm::vec3 & v1, const ofVec3f & v2){
-	v1 *= glm::vec3(v2);
+	v1 *= glm::vec3(v2.x, v2.y, v2.z);
 	return v1;
 }
 
 //--------------------------------------------------------------
 inline glm::vec3 & operator/=(glm::vec3 & v1, const ofVec3f & v2){
-	v1 /= glm::vec3(v2);
+	v1 /= glm::vec3(v2.x, v2.y, v2.z);
 	return v1;
 }
 
 //--------------------------------------------------------------
 inline glm::vec2 operator+(const glm::vec2 & v1, const ofVec2f & v2){
-	return v1 + glm::vec2(v2);
+	return v1 + glm::vec2(v2.x, v2.y);
 }
 
 //--------------------------------------------------------------
 inline glm::vec2 operator-(const glm::vec2 & v1, const ofVec2f & v2){
-	return v1 - glm::vec2(v2);
+	return v1 - glm::vec2(v2.x, v2.y);
 }
 
 //--------------------------------------------------------------
 inline glm::vec2 operator*(const glm::vec2 & v1, const ofVec2f & v2){
-	return v1 * glm::vec2(v2);
+	return v1 * glm::vec2(v2.x, v2.y);
 }
 
 //--------------------------------------------------------------
 inline glm::vec2 operator/(const glm::vec2 & v1, const ofVec2f & v2){
-	return v1 / glm::vec2(v2);
+	return v1 / glm::vec2(v2.x, v2.y);
 }
 
 //--------------------------------------------------------------
 inline glm::vec2 & operator+=(glm::vec2 & v1, const ofVec2f & v2){
-	v1 += glm::vec2(v2);
+	v1 += glm::vec2(v2.x, v2.y);
 	return v1;
 }
 
 //--------------------------------------------------------------
 inline glm::vec2 & operator-=(glm::vec2 & v1, const ofVec2f & v2){
-	v1 -= glm::vec2(v2);
+	v1 -= glm::vec2(v2.x, v2.y);
 	return v1;
 }
 
 //--------------------------------------------------------------
 inline glm::vec2 & operator*=(glm::vec2 & v1, const ofVec2f & v2){
-	v1 *= glm::vec2(v2);
+	v1 *= glm::vec2(v2.x, v2.y);
 	return v1;
 }
 
 //--------------------------------------------------------------
 inline glm::vec2 & operator/=(glm::vec2 & v1, const ofVec2f & v2){
-	v1 /= glm::vec2(v2);
+	v1 /= glm::vec2(v2.x, v2.y);
 	return v1;
 }