Merge branch 'master' into matlab-warnings

Author: dcwhite

Superbuild/GLMExternal.cmake

@@ -30,13 +30,12 @@ SET_PROPERTY(DIRECTORY PROPERTY "EP_BASE" ${ep_base})
 # git checkout -q will silence message about detached head (harmless).
 ExternalProject_Add(GLM_external
   GIT_REPOSITORY "https://github.com/g-truc/glm.git"
-  GIT_TAG "0.9.4.6"
+  GIT_TAG "0.9.9.8"
   CONFIGURE_COMMAND ""
   BUILD_COMMAND ""
   INSTALL_COMMAND ""
   CMAKE_CACHE_ARGS
     -DCMAKE_VERBOSE_MAKEFILE:BOOL=${CMAKE_VERBOSE_MAKEFILE}
-	-DGLM_SWIZZLE:BOOL=ON
 	-DGLM_FORCE_CXX03:BOOL=ON
 	-DGLM_FORCE_RADIANS:BOOL=ON
 )

src/Externals/spire/CMakeLists.txt

@@ -44,7 +44,7 @@ SET(BUILD_SHARED_LIBS OFF)
 
 SET(SCI_SPIRE_LIBRARY ${SPIRE_LIBRARY_NAME} CACHE INTERNAL "spire library name." FORCE)
 
-ADD_DEFINITIONS(-DGLM_SWIZZLE -DGLM_FORCE_CXX03 -DGLM_FORCE_RADIANS)
+ADD_DEFINITIONS(-DGLM_FORCE_CXX03 -DGLM_FORCE_RADIANS)
 
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 

src/Externals/spire/arc-ball/ArcBall.cpp

@@ -27,12 +27,12 @@
 
 
 #include "ArcBall.hpp"
-#include <iostream>
+#include <glm/gtx/vec_swizzle.hpp>
 
 namespace spire {
 
 //------------------------------------------------------------------------------
-  ArcBall::ArcBall(const glm::vec3& center, glm::float_t radius, bool inverted, const glm::mat4& screenToTCS) :
+  ArcBall::ArcBall(const glm::vec3& center, float radius, bool inverted, const glm::mat4& screenToTCS) :
     mScreenToTCS(screenToTCS),
     mCenter(center),
     mRadius(radius),
@@ -51,13 +51,9 @@ namespace spire {
 //------------------------------------------------------------------------------
 glm::vec3 ArcBall::mouseOnSphere(const glm::vec3& tscMouse)
 {
-  glm::vec3 ballMouse;
+  glm::vec3 ballMouse(xy(tscMouse - mCenter) / mRadius, 0.0);
 
-  // (m - C) / R
-  ballMouse.x = (tscMouse.x - mCenter.x) / mRadius;
-  ballMouse.y = (tscMouse.y - mCenter.y) / mRadius;
-
-  glm::float_t mag_sq = glm::dot(ballMouse, ballMouse);
+  float mag_sq = glm::dot(ballMouse, ballMouse);
   if (mag_sq > 1.0)
   {
     // Since we are outside of the sphere, map to the visible boundary of the sphere.
@@ -79,26 +75,24 @@ glm::vec3 ArcBall::mouseOnSphere(const glm::vec3& tscMouse)
 void ArcBall::beginDrag(const glm::vec2& msc)
 {
   mQDown       = mQNow;
-  mVSphereDown = mouseOnSphere((mScreenToTCS * glm::vec4(msc, 0.0f, 1.0)).xyz());
+  mVSphereDown = mouseOnSphere(xyz(mScreenToTCS * glm::vec4(msc, 0.0f, 1.0f)));
 }
 
 //------------------------------------------------------------------------------
 void ArcBall::drag(const glm::vec2& msc)
 {
-  glm::vec3 mVSphereNow = mouseOnSphere((mScreenToTCS * glm::vec4(msc, 0.0, 1.0)).xyz());
+  glm::vec3 mVSphereNow = mouseOnSphere(xyz(mScreenToTCS * glm::vec4(msc, 0.0f, 1.0f)));
 
   // Construct a quaternion from two points on the unit sphere.
   glm::quat mQDrag = quatFromUnitSphere(mVSphereDown, mVSphereNow);
   mQNow = mQDrag * mQDown;
-  if(glm::dot(mVSphereDown, mVSphereNow) < 0.0)
-    beginDrag(msc);
 }
 
 //------------------------------------------------------------------------------
 void ArcBall::setLocationOnSphere(glm::vec3 location, glm::vec3 up)
 {
   glm::mat4 mMatNow = glm::lookAt(location, glm::vec3(0.0f), up);
-  mQNow   = glm::quat_cast(mMatNow);
+  mQNow = glm::quat_cast(mMatNow);
 }
 
 //------------------------------------------------------------------------------
@@ -107,7 +101,7 @@ glm::quat ArcBall::quatFromUnitSphere(const glm::vec3& from, const glm::vec3& to
   //TODO: check if cross is 0 before normalize. Crashes on Windows
   auto c = glm::cross(from, to);
   if (c == glm::vec3(0, 0, 0))
-    return {};
+    return glm::quat(1.0, 0.0, 0.0, 0.0);
 
   glm::vec3 axis = glm::normalize(c);
 

src/Externals/spire/arc-ball/ArcBall.hpp

@@ -63,8 +63,8 @@ class SCISHARE ArcBall
   ///                       default is 0.75.
   /// \param screenToTCS    Transformation from screen coordinates
   ///                       to TCS. \p center and \p radius are given in TCS.
-  ArcBall(const glm::vec3& center, glm::float_t radius, bool inverted = false,
-          const glm::mat4& screenToTCS = glm::mat4());
+  ArcBall(const glm::vec3& center, float radius, bool inverted = false,
+          const glm::mat4& screenToTCS = glm::mat4(1.0f));
 
   /// Initiate an arc ball drag given the mouse click in screen coordinates.
   /// \param mouseScreenCoords  Mouse screen coordinates.
@@ -100,7 +100,7 @@ class SCISHARE ArcBall
   /// Transform from screen coordinates to the target coordinate system.
   glm::mat4     mScreenToTCS;
   glm::vec3     mCenter;        ///< Center of the arcball in target coordinate system.
-  glm::float_t  mRadius;        ///< Radius of the arcball in target coordinate system.
+  float  mRadius;        ///< Radius of the arcball in target coordinate system.
   bool  invertHemisphere;
 
   glm::vec3     mVSphereDown;   ///< vDown mapped to the sphere of 'mRadius' centered at 'mCenter' in TCS.

src/Externals/spire/arc-look-at/ArcLookAt.cpp

@@ -31,6 +31,8 @@
 
 #include "ArcLookAt.hpp"
 #include <arc-ball/ArcBall.hpp>
+#include <glm/gtx/vec_swizzle.hpp>
+#include <glm/gtx/transform.hpp>
 
 namespace spire {
 
@@ -73,9 +75,9 @@ void ArcLookAt::doRotation(const glm::vec2& ssPos)
 }
 
 //------------------------------------------------------------------------------
-void ArcLookAt::doZoom(glm::float_t camZoom, int zoomSpeed)
+void ArcLookAt::doZoom(float camZoom, int zoomSpeed)
 {
-  glm::float_t prevDistance = mCamDistance;
+  float prevDistance = mCamDistance;
   zoomSpeed = zoomSpeed > 1 ? zoomSpeed : 2;
   camZoom /= zoomSpeed;
   camZoom *= prevDistance;
@@ -90,11 +92,11 @@ void ArcLookAt::doZoom(const glm::vec2& ssPos)
   // Use distance delta from center of screen to control zoom.
   // Will need a new variable to control this.
   glm::vec2 delta = ssPos - mReferenceScreenPos;
-  glm::float_t xScale = 4.0f;
-  glm::float_t yScale = 4.0f;
+  float xScale = 4.0f;
+  float yScale = 4.0f;
 
-	glm::float_t prevDistance = mCamDistance;
-	glm::float_t camZoom = mCamDistance + (delta.x) * xScale + (-delta.y) * yScale;
+	float prevDistance = mCamDistance;
+	float camZoom = mCamDistance + (delta.x) * xScale + (-delta.y) * yScale;
 	mCamDistance = camZoom;
 	if (mCamDistance <= 0)
 		mCamDistance = prevDistance;
@@ -103,11 +105,8 @@ void ArcLookAt::doZoom(const glm::vec2& ssPos)
 //------------------------------------------------------------------------------
 glm::mat4 ArcLookAt::getWorldViewTransform() const
 {
-  glm::mat4 finalTrafo;
-  finalTrafo[3].xyz() = -mCamLookAt;
-  finalTrafo          = mArcBall->getTransformation() * finalTrafo;
-  finalTrafo[3][2]   += -mCamDistance;
-
+  auto finalTrafo = mArcBall->getTransformation() * glm::translate(glm::mat4(1.0f), -mCamLookAt);
+  finalTrafo[3][2] -= mCamDistance;
   return finalTrafo;
 }
 

src/Externals/spire/arc-look-at/ArcLookAt.hpp

@@ -77,7 +77,7 @@ class SCISHARE ArcLookAt
 
   /// Dollys the camera towards(negative) / away(positive) from the look at
   /// point. With vairiable zoomspeed.
-  void doZoom(glm::float_t camZoom, int zoomSpeed = 65);
+  void doZoom(float camZoom, int zoomSpeed = 65);
 
   /// Uses a custom function to determine camera zoom. Downwards and to the
   /// right increases size, upwards or to the left decreases size
@@ -94,8 +94,8 @@ class SCISHARE ArcLookAt
   void setView(const glm::vec3& view, const glm::vec3& up);
 
   /// Retrieves the camera's distance away from the look at point.
-  glm::float_t getDistance() const {return mCamDistance;}
-  void setDistance(const glm::float_t f) {mCamDistance = f;}
+  float getDistance() const {return mCamDistance;}
+  void setDistance(const float f) {mCamDistance = f;}
 
   /// Retrieves the current lookat point.
   glm::vec3 getLookAt() const {return mCamLookAt;}
@@ -115,7 +115,7 @@ class SCISHARE ArcLookAt
   std::unique_ptr<spire::ArcBall>  mArcBall;
 
   glm::vec3                 mCamLookAt   {0.0f};     ///< Current lookat position.
-  glm::float_t              mCamDistance {3.0f};   ///< Distance from look-at.
+  float                     mCamDistance {3.0f};   ///< Distance from look-at.
 
   // The following are reference variables set when doReferenceDown is called.
   glm::vec2                 mReferenceScreenPos;

src/Externals/spire/es-general/comp/StaticCamera.hpp

@@ -43,9 +43,9 @@ namespace gen {
 // care anything about the camera itself.
 struct StaticCameraData
 {
-  glm::mat4 view;
-  glm::mat4 projection;
-  glm::mat4 viewProjection;
+  glm::mat4 view {1.0f};
+  glm::mat4 projection {1.0f};
+  glm::mat4 viewProjection {1.0f};
 
   // Misc variables. fovy only applies to perspective matrices.
   float fovy;

src/Externals/spire/es-general/comp/Transform.hpp

@@ -39,7 +39,7 @@ namespace gen {
 struct Transform
 {
   // -- Data --
-  glm::mat4 transform;
+  glm::mat4 transform {1.0f};
 
   // -- Functions --
   void setPosition(const glm::vec3& pos)

src/Externals/spire/es-render/comp/CommonUniforms.cpp

@@ -33,6 +33,7 @@
 #include <gl-shaders/GLShader.hpp>
 
 #include <es-general/util/Math.hpp>
+#include <glm/gtx/vec_swizzle.hpp>
 
 #include "CommonUniforms.hpp"
 
@@ -130,7 +131,7 @@ void CommonUniforms::applyCommonUniforms(const glm::mat4& objectToWorld,
       case U_CAM_VIEW_VEC:
         {
           glm::mat4 view = cam.getInverseView();
-          glm::vec3 viewVec = view[2].xyz();
+          glm::vec3 viewVec = xyz(view[2]);
           vec = -viewVec; // Our projection matrix looks down negative Z.
           GL(glUniform3f(uniformLocation[i], vec.x, vec.y, vec.z));
           break;
@@ -145,7 +146,7 @@ void CommonUniforms::applyCommonUniforms(const glm::mat4& objectToWorld,
       case U_CAM_UP:
         {
           glm::mat4 view = cam.getInverseView();
-          vec = view[1].xyz();
+          vec = xyz(view[1]);
           GL(glUniform3f(uniformLocation[i], vec.x, vec.y, vec.z));
           break;
         }

src/Externals/spire/glm-aabb/AABB.cpp

@@ -36,7 +36,7 @@ AABB::AABB()
   setNull();
 }
 
-AABB::AABB(const glm::vec3& center, glm::float_t radius)
+AABB::AABB(const glm::vec3& center, float radius)
 {
   setNull();
   extend(center, radius);
@@ -59,7 +59,7 @@ AABB::~AABB()
 {
 }
 
-void AABB::extend(glm::float_t val)
+void AABB::extend(float val)
 {
   if (!isNull())
   {
@@ -82,7 +82,7 @@ void AABB::extend(const glm::vec3& p)
   }
 }
 
-void AABB::extend(const glm::vec3& p, glm::float_t radius)
+void AABB::extend(const glm::vec3& p, float radius)
 {
   glm::vec3 r(radius);
   if (!isNull())
@@ -106,13 +106,13 @@ void AABB::extend(const AABB& aabb)
   }
 }
 
-void AABB::extendDisk(const glm::vec3& c, const glm::vec3& n, glm::float_t r)
+void AABB::extendDisk(const glm::vec3& c, const glm::vec3& n, float r)
 {
   if (glm::length(n) < 1.e-12) { extend(c); return; }
   glm::vec3 norm = glm::normalize(n);
-  glm::float_t x = sqrt(1 - norm.x) * r;
-  glm::float_t y = sqrt(1 - norm.y) * r;
-  glm::float_t z = sqrt(1 - norm.z) * r;
+  float x = sqrt(1 - norm.x) * r;
+  float y = sqrt(1 - norm.y) * r;
+  float z = sqrt(1 - norm.z) * r;
   extend(c + glm::vec3(x,y,z));
   extend(c - glm::vec3(x,y,z));
 }
@@ -125,12 +125,12 @@ glm::vec3 AABB::getDiagonal() const
     return glm::vec3(0);
 }
 
-glm::float_t AABB::getLongestEdge() const
+float AABB::getLongestEdge() const
 {
   return glm::compMax(getDiagonal());
 }
 
-glm::float_t AABB::getShortestEdge() const
+float AABB::getShortestEdge() const
 {
   return glm::compMin(getDiagonal());
 }
@@ -140,7 +140,7 @@ glm::vec3 AABB::getCenter() const
   if (!isNull())
   {
     glm::vec3 d = getDiagonal();
-    return mMin + (d * glm::float_t(0.5));
+    return mMin + (0.5f * d);
   }
   else
   {
@@ -210,11 +210,11 @@ AABB::INTERSECTION_TYPE AABB::intersect(const AABB& b) const
 }
 
 
-bool AABB::isSimilarTo(const AABB& b, glm::float_t diff) const
+bool AABB::isSimilarTo(const AABB& b, float diff) const
 {
   if (isNull() || b.isNull()) return false;
 
-  glm::vec3 acceptable_diff=( (getDiagonal()+b.getDiagonal()) / glm::float_t(2.0))*diff;
+  glm::vec3 acceptable_diff = ((getDiagonal()+b.getDiagonal()) * 0.5f) * diff;
   glm::vec3 min_diff(mMin-b.mMin);
   min_diff = glm::vec3(fabs(min_diff.x),fabs(min_diff.y),fabs(min_diff.z));
   if (min_diff.x > acceptable_diff.x) return false;