More GLM initialization fixes

apps/OpenSpace/main.cpp

@@ -989,7 +989,7 @@ void setSgctDelegateFunctions() {
     sgctDelegate.viewportPixelCoordinates = []() {
         sgct::SGCTWindow* window = sgct::Engine::instance()->getCurrentWindowPtr();
         if (!window || !window->getCurrentViewport()) {
-            return glm::ivec4(0, 0, 0, 0);
+            return glm::ivec4(0);
         }
         else {
             const int* data = sgct::Engine::instance()->getCurrentViewportPixelCoords();

include/openspace/properties/numericalproperty.inl

@@ -23,6 +23,7 @@
  ****************************************************************************************/
 
 #include <ghoul/lua/ghoul_lua.h>
+#include <glm/ext/matrix_common.hpp>
 
 namespace openspace::properties {
 

modules/atmosphere/rendering/atmospheredeferredcaster.h

@@ -189,7 +189,7 @@ private:
 
     // Eclipse Shadows
     std::vector<ShadowConfiguration> _shadowConfArray;
-    bool _hardShadowsEnabled = false
+    bool _hardShadowsEnabled = false;
 
     // Atmosphere Debugging
     float _calculationTextureScale = 1.f;

modules/atmosphere/rendering/renderableatmosphere.cpp

@@ -412,7 +412,7 @@ RenderableAtmosphere::RenderableAtmosphere(const ghoul::Dictionary& dictionary)
 
         if (success) {
             // Not using right now.
-            glm::vec3 rayleighWavelengths;
+            glm::vec3 rayleighWavelengths = glm::vec3(0.f);
             rayleighDictionary.getValue(
                 "Coefficients.Wavelengths",
                 rayleighWavelengths

modules/base/dashboard/dashboarditemdistance.cpp

@@ -385,7 +385,7 @@ std::pair<glm::dvec3, std::string> DashboardItemDistance::positionAndLabel(
             return { mainComp.node->worldPosition(), mainComp.node->guiName() };
         case Type::NodeSurface:
         {
-            glm::dvec3 otherPos;
+            glm::dvec3 otherPos = glm::dvec3(0.0);
             if (otherComp.type == Type::NodeSurface) {
                 // We are only interested in the direction, and we want to prevent
                 // infinite recursion

modules/base/rendering/renderableboxgrid.cpp

@@ -265,14 +265,14 @@ void RenderableBoxGrid::update(const UpdateData&) {
         //  0 -> 1 -> 2 -> 3 -> 0 -> 4 -> 5 -> 6 -> 7 -> 4 -> 5(d) -> 1 -> 2(d) -> 6
         //  -> 7(d) -> 3
 
-        const glm::vec3 v0 = { llf.x, llf.y, llf.z };
-        const glm::vec3 v1 = { urb.x, llf.y, llf.z };
-        const glm::vec3 v2 = { urb.x, urb.y, llf.z };
-        const glm::vec3 v3 = { llf.x, urb.y, llf.z };
-        const glm::vec3 v4 = { llf.x, llf.y, urb.z };
-        const glm::vec3 v5 = { urb.x, llf.y, urb.z };
-        const glm::vec3 v6 = { urb.x, urb.y, urb.z };
-        const glm::vec3 v7 = { llf.x, urb.y, urb.z };
+        const glm::vec3 v0 = glm::vec3(llf.x, llf.y, llf.z);
+        const glm::vec3 v1 = glm::vec3(urb.x, llf.y, llf.z);
+        const glm::vec3 v2 = glm::vec3(urb.x, urb.y, llf.z);
+        const glm::vec3 v3 = glm::vec3(llf.x, urb.y, llf.z);
+        const glm::vec3 v4 = glm::vec3(llf.x, llf.y, urb.z);
+        const glm::vec3 v5 = glm::vec3(urb.x, llf.y, urb.z);
+        const glm::vec3 v6 = glm::vec3(urb.x, urb.y, urb.z);
+        const glm::vec3 v7 = glm::vec3(llf.x, urb.y, urb.z);
 
         // First add the bounds
         _varray.push_back({ v0.x, v0.y, v0.z });

modules/base/rendering/renderablenodeline.cpp

@@ -123,7 +123,7 @@ documentation::Documentation RenderableNodeLine::Documentation() {
 
 RenderableNodeLine::RenderableNodeLine(const ghoul::Dictionary& dictionary)
     : Renderable(dictionary)
-    , _lineColor(LineColorInfo, glm::vec3(1.f, 1.f, 1.f), glm::vec3(0.f), glm::vec3(1.f))
+    , _lineColor(LineColorInfo, glm::vec3(1.f), glm::vec3(0.f), glm::vec3(1.f))
     , _lineWidth(LineWidthInfo, 2.f, 1.f, 20.f)
     , _start(StartNodeInfo, Root)
     , _end(EndNodeInfo, Root)

modules/base/rendering/renderablenodeline.h

@@ -76,8 +76,8 @@ private:
     GLuint _vBufferId = 0;
     std::vector<float> _vertexArray;
 
-    glm::dvec3 _startPos;
-    glm::dvec3 _endPos;
+    glm::dvec3 _startPos = glm::dvec3(0.0);
+    glm::dvec3 _endPos = glm::dvec3(0.0);
 
     properties::StringProperty _start;
     properties::StringProperty _end;

modules/debugging/rendering/renderabledebugplane.cpp

@@ -208,7 +208,7 @@ void RenderableDebugPlane::deinitializeGL() {
 }
 
 void RenderableDebugPlane::render(const RenderData& data, RendererTasks&) {
-    glm::mat4 transform = glm::mat4(1.0);
+    glm::mat4 transform = glm::mat4(1.f);
     if (_billboard) {
         transform = glm::inverse(glm::mat4(data.camera.viewRotationMatrix()));
     }

modules/digitaluniverse/rendering/renderablebillboardscloud.cpp

@@ -1474,7 +1474,7 @@ bool RenderableBillboardsCloud::readLabelFile() {
 
         std::stringstream str(line);
 
-        glm::vec3 position;
+        glm::vec3 position = glm::vec3(0.f);
         for (int j = 0; j < 3; ++j) {
             str >> position[j];
         }

modules/digitaluniverse/rendering/renderabledumeshes.cpp

@@ -861,7 +861,7 @@ bool RenderableDUMeshes::readLabelFile() {
 
         std::stringstream str(line);
 
-        glm::vec3 position;
+        glm::vec3 position = glm::vec3(0.f);
         for (int j = 0; j < 3; ++j) {
             str >> position[j];
         }

modules/digitaluniverse/rendering/renderableplanescloud.cpp

@@ -1118,7 +1118,7 @@ bool RenderablePlanesCloud::readLabelFile() {
 
         std::stringstream str(line);
 
-        glm::vec3 position;
+        glm::vec3 position = glm::vec3(0.f);
         for (int j = 0; j < 3; ++j) {
             str >> position[j];
         }

modules/fieldlines/rendering/renderablefieldlines.cpp

@@ -372,7 +372,7 @@ void RenderableFieldlines::loadSeedPointsFromTable() {
     ghoul::Dictionary seedpointsDictionary;
     _seedPointsInfo.getValue(KeySeedPointsTable, seedpointsDictionary);
     for (const std::string& index : seedpointsDictionary.keys()) {
-        glm::vec3 seedPos;
+        glm::vec3 seedPos = glm::vec3(0.f);
         _fieldlineInfo.getValue(std::string(KeySeedPointsTable) + "." + index, seedPos);
         _seedPoints.push_back(seedPos);
     }

modules/galaxy/rendering/galaxyraycaster.h

@@ -78,7 +78,7 @@ private:
     glm::dmat4 modelViewTransform(const RenderData& data);
 
     BoxGeometry _boundingBox;
-    float _stepSize = 0.f
+    float _stepSize = 0.f;
     glm::mat4 _modelTransform = glm::mat4(1.f);
     glm::vec3 _aspect = glm::vec3(0.f);
     double _time = 0.0;

modules/galaxy/rendering/renderablegalaxy.cpp

@@ -265,14 +265,14 @@ RenderableGalaxy::RenderableGalaxy(const ghoul::Dictionary& dictionary)
     else {
         LERROR("No volume filename specified.");
     }
-    glm::vec3 volumeDimensions;
+    glm::vec3 volumeDimensions = glm::vec3(0.f);
     if (volumeDictionary.getValue("Dimensions", volumeDimensions)) {
         _volumeDimensions = static_cast<glm::ivec3>(volumeDimensions);
     }
     else {
         LERROR("No volume dimensions specified.");
     }
-    glm::vec3 volumeSize;
+    glm::vec3 volumeSize = glm::vec3(0.f);
     if (volumeDictionary.getValue("Size", volumeSize)) {
         _volumeSize = volumeSize;
     }
@@ -539,12 +539,12 @@ void RenderableGalaxy::update(const UpdateData& data) {
     //glm::mat4 transform = glm::translate(, static_cast<glm::vec3>(_translation));
     const glm::vec3 eulerRotation = static_cast<glm::vec3>(_rotation);
     glm::mat4 transform = glm::rotate(
-        glm::mat4(1.0),
+        glm::mat4(1.f),
         eulerRotation.x,
-        glm::vec3(1, 0, 0)
+        glm::vec3(1.f, 0.f, 0.f)
     );
-    transform = glm::rotate(transform, eulerRotation.y, glm::vec3(0, 1, 0));
-    transform = glm::rotate(transform, eulerRotation.z,  glm::vec3(0, 0, 1));
+    transform = glm::rotate(transform, eulerRotation.y, glm::vec3(0.f, 1.f, 0.f));
+    transform = glm::rotate(transform, eulerRotation.z,  glm::vec3(0.f, 0.f, 1.f));
 
     glm::mat4 volumeTransform = glm::scale(transform, _volumeSize);
     _pointTransform = transform;

modules/galaxy/rendering/renderablegalaxy.h

@@ -93,7 +93,7 @@ private:
     std::unique_ptr<ghoul::opengl::Texture> _texture;
     glm::mat4 _pointTransform = glm::mat4(1.f);
     glm::vec3 _aspect = glm::vec3(0.f);
-    float _opacityCoefficient = 0.f
+    float _opacityCoefficient = 0.f;
 
     std::unique_ptr<ghoul::opengl::ProgramObject> _pointsProgram;
     std::unique_ptr<ghoul::opengl::ProgramObject> _billboardsProgram;

modules/globebrowsing/src/ellipsoid.cpp

@@ -62,7 +62,7 @@ glm::dvec3 Ellipsoid::geodeticSurfaceProjection(const glm::dvec3& p) const {
     double alpha = (1.0 - beta) * (glm::length(p) / n);
 
     const glm::dvec3 p2 = p * p;
-    glm::dvec3 d;
+    glm::dvec3 d = glm::dvec3(0.0);
     double s = 0.0;
     double dSdA = 1.0;
 

modules/globebrowsing/src/renderableglobe.cpp

@@ -64,13 +64,13 @@ namespace {
 
     // Shadow structure
     struct ShadowRenderingStruct {
-        double xu;
-        double xp;
-        double rs;
-        double rc;
-        glm::dvec3 sourceCasterVec;
-        glm::dvec3 casterPositionVec;
-        bool isShadowing;
+        double xu = 0.0;
+        double xp = 0.0;
+        double rs = 0.0;
+        double rc = 0.0;
+        glm::dvec3 sourceCasterVec = glm::dvec3(0.0);
+        glm::dvec3 casterPositionVec = glm::dvec3(0.0);
+        bool isShadowing = false;
     };
 
     constexpr const char* KeyRadii = "Radii";

modules/globebrowsing/src/ringscomponent.h

@@ -104,7 +104,7 @@ private:
     GLuint _vertexPositionBuffer = 0;
     bool _planeIsDirty = false;
 
-    glm::vec3 _sunPosition;
+    glm::vec3 _sunPosition = glm::vec3(0.f);
 };
 
 } // namespace openspace

modules/globebrowsing/src/shadowcomponent.h

@@ -130,13 +130,13 @@ private:
     GLfloat _colorClearValue[4];
     GLfloat _depthClearValue;
 
-    glm::vec3 _sunPosition;
+    glm::vec3 _sunPosition = glm::vec3(0.f);
 
     glm::dmat4 _shadowMatrix = glm::dmat4(1.0);
 
     glm::dvec3 _cameraPos = glm::dvec3(0.0);
-    glm::dvec3 _cameraFocus;
-    glm::dquat _cameraRotation;
+    glm::dvec3 _cameraFocus = glm::dvec3(0.0);
+    glm::dquat _cameraRotation = glm::dquat(1.0, 0.0, 0.0, 0.0);
 
     std::stringstream _serializedCamera;
 

modules/imgui/src/gui.cpp

@@ -338,7 +338,7 @@ void GUI::initializeGL() {
 
     {
         unsigned char* texData;
-        glm::ivec2 texSize;
+        glm::ivec2 texSize = glm::ivec2(0);
         for (int i = 0; i < nWindows; ++i) {
             //_contexts[i] = ImGui::CreateContext();
             ImGui::SetCurrentContext(_contexts[i]);

modules/iswa/rendering/iswacygnet.cpp

@@ -70,15 +70,15 @@ IswaCygnet::IswaCygnet(const ghoul::Dictionary& dictionary)
     dictionary.getValue("Id", renderableId);
     float updateTime;
     dictionary.getValue("UpdateTime", updateTime);
-    glm::vec4 spatialScale;
+    glm::vec4 spatialScale = glm::vec4(0.f);
     dictionary.getValue("SpatialScale", spatialScale);
-    glm::vec3 min;
+    glm::vec3 min = glm::vec3(0.f);
     dictionary.getValue("GridMin", min);
-    glm::vec3 max;
+    glm::vec3 max = glm::vec3(0.f);
     dictionary.getValue("GridMax", max);
     dictionary.getValue("Frame",_data.frame);
     dictionary.getValue("CoordinateType", _data.coordinateType);
-    float xOffset;
+    float xOffset = 0.f;
     dictionary.getValue("XOffset", xOffset);
 
     dictionary.getValue("Group", _data.groupName);
@@ -148,7 +148,7 @@ void IswaCygnet::render(const RenderData& data, RendererTasks&) {
         return;
     }
 
-    glm::mat4 transform = glm::mat4(1.0);
+    glm::mat4 transform = glm::mat4(1.f);
     for (int i = 0; i < 3; i++){
         for (int j = 0; j < 3; j++){
             transform[i][j] = static_cast<float>(_stateMatrix[i][j]);

modules/iswa/rendering/kameleonplane.h

@@ -89,7 +89,7 @@ private:
     std::string _var;
     float _scale = 0.f;
 
-    glm::vec3 _origOffset;
+    glm::vec3 _origOffset = glm::vec3(0.f);
 
     /**
      * _fieldlineState maps the checkbox value of each fieldline seedpoint file to a tuple

modules/iswa/util/iswamanager.cpp

@@ -416,7 +416,7 @@ std::string IswaManager::parseKWToLuaTable(const CdfInfo& info, const std::strin
 
         std::array<std::string, 3> gridUnits = kw.gridUnits();
 
-        glm::vec4 spatialScale;
+        glm::vec4 spatialScale = glm::vec4(0.f);
         std::string coordinateType;
         if (gridUnits[0] == "R" && gridUnits[1] == "R" && gridUnits[2] == "R") {
             spatialScale.x = 6.371f;

modules/multiresvolume/rendering/renderablemultiresvolume.cpp

@@ -719,7 +719,7 @@ void RenderableMultiresVolume::update(const UpdateData& data) {
 
     if (_raycaster) {
         glm::mat4 transform = glm::translate(
-            glm::mat4(1.0),
+            glm::mat4(1.f),
             static_cast<glm::vec3>(_translation) *
                 std::pow(10.f, static_cast<float>(_scalingExponent))
         );

modules/space/rendering/renderablesatellites.h

@@ -88,7 +88,7 @@ private:
         float z = 0.f;
         float time = 0.f;
         double epoch = 0.0;
-        dobule period = 0.0;
+        double period = 0.0;
     };
 
     KeplerTranslation _keplerTranslator;

modules/spacecraftinstruments/dashboard/dashboarditeminstruments.cpp

@@ -310,12 +310,12 @@ void DashboardItemInstruments::render(glm::vec2& penPosition) {
 }
 
 glm::vec2 DashboardItemInstruments::size() const {
-    glm::vec2 size = { 0.f, 0.f };
+    glm::vec2 size = glm::vec2(0.f);
     //return ghoul::fontrendering::FontRenderer::defaultRenderer().boundingBox(
     double currentTime = global::timeManager.time().j2000Seconds();
 
     if (!ImageSequencer::ref().isReady()) {
-        return { 0.f, 0.f };
+        return glm::vec2(0.f);
     }
     ImageSequencer& sequencer = ImageSequencer::ref();
 

modules/spacecraftinstruments/rendering/renderableplaneprojection.cpp

@@ -230,6 +230,7 @@ void RenderablePlaneProjection::updatePlane(const Image& img, double currentTime
     // The apparent position, CN+S, makes image align best with target
 
     glm::dvec3 projection[4];
+    std::fill(std::begin(projection), std::end(projection), glm::dvec3(0.0));
     for (size_t j = 0; j < bounds.size(); ++j) {
         bounds[j] = SpiceManager::ref().frameTransformationMatrix(
             frame,

modules/touch/include/directinputsolver.h

@@ -44,9 +44,9 @@ public:
     // Stores the selected node, the cursor ID as well as the surface coordinates the
     // cursor touched
     struct SelectedBody {
-        size_t id;
-        SceneGraphNode* node;
-        glm::dvec3 coordinates;
+        size_t id = 0;
+        SceneGraphNode* node = nullptr;
+        glm::dvec3 coordinates = glm::dvec3(0.0);
     };
 
     DirectInputSolver();

modules/touch/src/touchinteraction.cpp

@@ -404,10 +404,10 @@ void TouchInteraction::updateStateFromInput(const std::vector<TouchInputHolder>&
     if (!isGuiMode(pos, numFingers)) {
         bool isTransitionBetweenModes = (_wasPrevModeDirectTouch != _directTouchMode);
         if (isTransitionBetweenModes) {
-            _vel.orbit = glm::dvec2(0.0, 0.0);
+            _vel.orbit = glm::dvec2(0.0);
             _vel.zoom = 0.0;
             _vel.roll = 0.0;
-            _vel.pan = glm::dvec2(0.0, 0.0);
+            _vel.pan = glm::dvec2(0.0);
             resetAfterInput();
         }
 
@@ -468,10 +468,10 @@ bool TouchInteraction::isGuiMode(glm::dvec2 screenPosition, size_t numFingers) {
 
 void TouchInteraction::directControl(const std::vector<TouchInputHolder>& list) {
     // Reset old velocities upon new interaction
-    _vel.orbit = glm::dvec2(0.0, 0.0);
+    _vel.orbit = glm::dvec2(0.0);
     _vel.zoom = 0.0;
     _vel.roll = 0.0;
-    _vel.pan = glm::dvec2(0.0, 0.0);
+    _vel.pan = glm::dvec2(0.0);
 #ifdef TOUCH_DEBUG_PROPERTIES
     LINFO("DirectControl");
 #endif
@@ -498,17 +498,17 @@ void TouchInteraction::directControl(const std::vector<TouchInputHolder>& list)
 
         // Reset velocities after setting new camera state
         _lastVel = _vel;
-        _vel.orbit = glm::dvec2(0.0, 0.0);
+        _vel.orbit = glm::dvec2(0.0);
         _vel.zoom = 0.0;
         _vel.roll = 0.0;
-        _vel.pan = glm::dvec2(0.0, 0.0);
+        _vel.pan = glm::dvec2(0.0);
     }
     else {
         // prevents touch to infinitely be active (due to windows bridge case where event
         // doesnt get consumed sometimes when LMA fails to converge)
         Touch touch;
         touch.active = true;
-        touch.pos = glm::dvec2(0.0, 0.0);
+        touch.pos = glm::dvec2(0.0);
         touch.action = 1;
         global::moduleEngine.module<ImGUIModule>()->touchInput = touch;
         resetAfterInput();
@@ -1224,10 +1224,10 @@ void TouchInteraction::resetAfterInput() {
     _guiON = module.gui.isEnabled();
 
     // Reset variables
-    _lastVel.orbit = glm::dvec2(0.0, 0.0);
+    _lastVel.orbit = glm::dvec2(0.0);
     _lastVel.zoom = 0.0;
     _lastVel.roll = 0.0;
-    _lastVel.pan = glm::dvec2(0.0, 0.0);
+    _lastVel.pan = glm::dvec2(0.0);
     _selected.clear();
     _pickingSelected = nullptr;
 }

modules/toyvolume/rendering/renderabletoyvolume.cpp

@@ -180,9 +180,9 @@ bool RenderableToyVolume::isReady() const {
 void RenderableToyVolume::update(const UpdateData& data) {
     if (_raycaster) {
         glm::mat4 transform = glm::translate(
-            glm::mat4(1.0),
+            glm::mat4(1.f),
             static_cast<glm::vec3>(_translation) *
-                std::pow(10.0f, static_cast<float>(_scalingExponent))
+                std::pow(10.f, static_cast<float>(_scalingExponent))
         );
         glm::vec3 eulerRotation = static_cast<glm::vec3>(_rotation);
         transform = glm::rotate(transform, eulerRotation.x, glm::vec3(1.f, 0.f, 0.f));

src/interaction/navigationhandler.cpp

@@ -360,7 +360,7 @@ NavigationHandler::NavigationState NavigationHandler::navigationState(
     }
 
     const glm::dquat invNeutralRotation = glm::quat_cast(glm::lookAt(
-        glm::dvec3(0.0, 0.0, 0.0),
+        glm::dvec3(0.0),
         aim->worldPosition() - _camera->positionVec3(),
         glm::normalize(_camera->lookUpVectorWorldSpace())
     ));

src/interaction/orbitalnavigator.cpp

@@ -834,7 +834,7 @@ OrbitalNavigator::CameraRotationDecomposition
 
     // To avoid problem with lookup in up direction we adjust is with the view direction
     const glm::dmat4 lookAtMat = glm::lookAt(
-        glm::dvec3(0.0, 0.0, 0.0),
+        glm::dvec3(0.0),
         -directionFromSurfaceToCamera,
         normalize(cameraViewDirection + cameraUp)
     );
@@ -858,7 +858,7 @@ OrbitalNavigator::CameraRotationDecomposition
 
     // To avoid problem with lookup in up direction we adjust is with the view direction
     const glm::dmat4 lookAtMat = glm::lookAt(
-        glm::dvec3(0.0, 0.0, 0.0),
+        glm::dvec3(0.0),
         reference - cameraPose.position,
         normalize(cameraViewDirection + cameraUp)
     );
@@ -1040,7 +1040,7 @@ glm::dquat OrbitalNavigator::interpolateLocalRotation(double deltaTime,
             localCameraRotation * Camera::UpDirectionCameraSpace;
 
         const glm::dmat4 lookAtMat = glm::lookAt(
-            glm::dvec3(0.0, 0.0, 0.0),
+            glm::dvec3(0.0),
             Camera::ViewDirectionCameraSpace,
             normalize(localUp)
         );

src/properties/matrix/mat2property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::mat2x2 fromLuaConversion(lua_State* state, bool& success) {
-    glm::mat2x2 result;
+    glm::mat2x2 result = glm::mat2x2(1.f);
     lua_pushnil(state);
     int number = 1;
     for (glm::length_t i = 0; i < ghoul::glm_cols<glm::mat2x2>::value; ++i) {
@@ -41,11 +41,11 @@ glm::mat2x2 fromLuaConversion(lua_State* state, bool& success) {
             int hasNext = lua_next(state, -2);
             if (hasNext != 1) {
                 success = false;
-                return glm::mat2x2(0.f);
+                return glm::mat2x2(1.f);
             }
             if (lua_isnumber(state, -1) != 1) {
                 success = false;
-                return glm::mat2x2(0.f);
+                return glm::mat2x2(1.f);
             } else {
                 result[i][j] = static_cast<glm::mat2x2::value_type>(
                     lua_tonumber(state, -1)
@@ -124,7 +124,7 @@ using nl = std::numeric_limits<float>;
 REGISTER_NUMERICALPROPERTY_SOURCE(
     Mat2Property,
     glm::mat2x2,
-    glm::mat2x2(0.f),
+    glm::mat2x2(1.f),
     glm::mat2x2(
         nl::lowest(), nl::lowest(),
         nl::lowest(), nl::lowest()

src/properties/matrix/mat2x3property.cpp

@@ -35,7 +35,7 @@ using std::numeric_limits;
 namespace {
 
 glm::mat2x3 fromLuaConversion(lua_State* state, bool& success) {
-    glm::mat2x3 result;
+    glm::mat2x3 result = glm::mat2x3(1.f);
     lua_pushnil(state);
     int number = 1;
     for (glm::length_t i = 0; i < ghoul::glm_cols<glm::mat2x3>::value; ++i) {
@@ -43,11 +43,11 @@ glm::mat2x3 fromLuaConversion(lua_State* state, bool& success) {
             int hasNext = lua_next(state, -2);
             if (hasNext != 1) {
                 success = false;
-                return glm::mat2x3(0.f);
+                return glm::mat2x3(1.f);
             }
             if (lua_isnumber(state, -1) != 1) {
                 success = false;
-                return glm::mat2x3(0.f);
+                return glm::mat2x3(1.f);
             }
             else {
                 result[i][j]
@@ -126,7 +126,7 @@ using nl = std::numeric_limits<float>;
 REGISTER_NUMERICALPROPERTY_SOURCE(
     Mat2x3Property,
     glm::mat2x3,
-    glm::mat2x3(0.f),
+    glm::mat2x3(1.f),
     glm::mat2x3(
         nl::lowest(), nl::lowest(),
         nl::lowest(), nl::lowest(),

src/properties/matrix/mat2x4property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::mat2x4 fromLuaConversion(lua_State* state, bool& success) {
-    glm::mat2x4 result;
+    glm::mat2x4 result = glm::mat2x4(1.f);
     lua_pushnil(state);
     int number = 1;
     for (glm::length_t i = 0; i < ghoul::glm_cols<glm::mat2x4>::value; ++i) {
@@ -41,11 +41,11 @@ glm::mat2x4 fromLuaConversion(lua_State* state, bool& success) {
             int hasNext = lua_next(state, -2);
             if (hasNext != 1) {
                 success = false;
-                return glm::mat2x4(0.f);
+                return glm::mat2x4(1.f);
             }
             if (lua_isnumber(state, -1) != 1) {
                 success = false;
-                return glm::mat2x4(0.f);
+                return glm::mat2x4(1.f);
             }
             else {
                 result[i][j]
@@ -124,7 +124,7 @@ using nl = std::numeric_limits<float>;
 REGISTER_NUMERICALPROPERTY_SOURCE(
     Mat2x4Property,
     glm::mat2x4,
-    glm::mat2x4(0.f),
+    glm::mat2x4(1.f),
     glm::mat2x4(
         nl::lowest(), nl::lowest(),
         nl::lowest(), nl::lowest(),

src/properties/matrix/mat3property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::mat3x3 fromLuaConversion(lua_State* state, bool& success) {
-    glm::mat3x3 result;
+    glm::mat3x3 result = glm::mat3x3(1.f);
     lua_pushnil(state);
     int number = 1;
     for (glm::length_t i = 0; i < ghoul::glm_cols<glm::mat3x3>::value; ++i) {
@@ -41,11 +41,11 @@ glm::mat3x3 fromLuaConversion(lua_State* state, bool& success) {
             int hasNext = lua_next(state, -2);
             if (hasNext != 1) {
                 success = false;
-                return glm::mat3x3(0.f);
+                return glm::mat3x3(1.f);
             }
             if (lua_isnumber(state, -1) != 1) {
                 success = false;
-                return glm::mat3x3(0.f);
+                return glm::mat3x3(1.f);
             } else {
                 result[i][j]
                         = static_cast<glm::mat3x3::value_type>(lua_tonumber(state, -1));
@@ -123,7 +123,7 @@ using nl = std::numeric_limits<float>;
 REGISTER_NUMERICALPROPERTY_SOURCE(
     Mat3Property,
     glm::mat3x3,
-    glm::mat3x3(0.f),
+    glm::mat3x3(1.f),
     glm::mat3x3(
         nl::lowest(), nl::lowest(), nl::lowest(),
         nl::lowest(), nl::lowest(), nl::lowest(),

src/properties/matrix/mat3x2property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::mat3x2 fromLuaConversion(lua_State* state, bool& success) {
-    glm::mat3x2 result;
+    glm::mat3x2 result = glm::mat3x2(1.f);
     lua_pushnil(state);
     int number = 1;
     for (glm::length_t i = 0; i < ghoul::glm_cols<glm::mat3x2>::value; ++i) {
@@ -123,7 +123,7 @@ using nl = std::numeric_limits<float>;
 REGISTER_NUMERICALPROPERTY_SOURCE(
     Mat3x2Property,
     glm::mat3x2,
-    glm::mat3x2(0.f),
+    glm::mat3x2(1.f),
     glm::mat3x2(
         nl::lowest(), nl::lowest(), nl::lowest(),
         nl::lowest(), nl::lowest(), nl::lowest()

src/properties/matrix/mat3x4property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::mat3x4 fromLuaConversion(lua_State* state, bool& success) {
-    glm::mat3x4 result;
+    glm::mat3x4 result = glm::mat3x4(1.f);
     lua_pushnil(state);
     int number = 1;
     for (glm::length_t i = 0; i < ghoul::glm_cols<glm::mat3x4>::value; ++i) {
@@ -41,11 +41,11 @@ glm::mat3x4 fromLuaConversion(lua_State* state, bool& success) {
             int hasNext = lua_next(state, -2);
             if (hasNext != 1) {
                 success = false;
-                return glm::mat3x4(0.f);
+                return glm::mat3x4(1.f);
             }
             if (lua_isnumber(state, -1) != 1) {
                 success = false;
-                return glm::mat3x4(0.f);
+                return glm::mat3x4(1.f);
             } else {
                 result[i][j]
                         = static_cast<glm::mat3x4::value_type>(lua_tonumber(state, -1));
@@ -123,7 +123,7 @@ using nl = std::numeric_limits<float>;
 REGISTER_NUMERICALPROPERTY_SOURCE(
     Mat3x4Property,
     glm::mat3x4,
-    glm::mat3x4(0.f),
+    glm::mat3x4(1.f),
     glm::mat3x4(
         nl::lowest(), nl::lowest(), nl::lowest(),
         nl::lowest(), nl::lowest(), nl::lowest(),

src/properties/matrix/mat4property.cpp

@@ -35,7 +35,7 @@ using std::numeric_limits;
 namespace {
 
 glm::mat4x4 fromLuaConversion(lua_State* state, bool& success) {
-    glm::mat4x4 result;
+    glm::mat4x4 result = glm::mat4x4(1.f);
     lua_pushnil(state);
     int number = 1;
     for (glm::length_t i = 0; i < ghoul::glm_cols<glm::mat4x4>::value; ++i) {
@@ -43,11 +43,11 @@ glm::mat4x4 fromLuaConversion(lua_State* state, bool& success) {
             int hasNext = lua_next(state, -2);
             if (hasNext != 1) {
                 success = false;
-                return glm::mat4x4(0.f);
+                return glm::mat4x4(1.f);
             }
             if (lua_isnumber(state, -1) != 1) {
                 success = false;
-                return glm::mat4x4(0.f);
+                return glm::mat4x4(1.f);
             } else {
                 result[i][j]
                         = static_cast<glm::mat4x4::value_type>(lua_tonumber(state, -1));
@@ -125,7 +125,7 @@ using nl = std::numeric_limits<float>;
 REGISTER_NUMERICALPROPERTY_SOURCE(
     Mat4Property,
     glm::mat4x4,
-    glm::mat4x4(0.f),
+    glm::mat4x4(1.f),
     glm::mat4x4(
         nl::lowest(), nl::lowest(), nl::lowest(), nl::lowest(),
         nl::lowest(), nl::lowest(), nl::lowest(), nl::lowest(),

src/properties/matrix/mat4x2property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::mat4x2 fromLuaConversion(lua_State* state, bool& success) {
-    glm::mat4x2 result;
+    glm::mat4x2 result = glm::mat4x2(1.f);
     lua_pushnil(state);
     int number = 1;
     for (glm::length_t i = 0; i < ghoul::glm_cols<glm::mat4x2>::value; ++i) {
@@ -41,11 +41,11 @@ glm::mat4x2 fromLuaConversion(lua_State* state, bool& success) {
             int hasNext = lua_next(state, -2);
             if (hasNext != 1) {
                 success = false;
-                return glm::mat4x2(0.f);
+                return glm::mat4x2(1.f);
             }
             if (lua_isnumber(state, -1) != 1) {
                 success = false;
-                return glm::mat4x2(0.f);
+                return glm::mat4x2(1.f);
             } else {
                 result[i][j]
                         = static_cast<glm::mat4x2::value_type>(lua_tonumber(state, -1));
@@ -123,7 +123,7 @@ using nl = std::numeric_limits<float>;
 REGISTER_NUMERICALPROPERTY_SOURCE(
     Mat4x2Property,
     glm::mat4x2,
-    glm::mat4x2(0.f),
+    glm::mat4x2(1.f),
     glm::mat4x2(
         nl::lowest(), nl::lowest(), nl::lowest(), nl::lowest(),
         nl::lowest(), nl::lowest(), nl::lowest(), nl::lowest()

src/properties/matrix/mat4x3property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::mat4x3 fromLuaConversion(lua_State* state, bool& success) {
-    glm::mat4x3 result;
+    glm::mat4x3 result = glm::mat4x3(1.f);
     lua_pushnil(state);
     int number = 1;
     for (glm::length_t i = 0; i < ghoul::glm_cols<glm::mat4x3>::value; ++i) {
@@ -41,11 +41,11 @@ glm::mat4x3 fromLuaConversion(lua_State* state, bool& success) {
             int hasNext = lua_next(state, -2);
             if (hasNext != 1) {
                 success = false;
-                return glm::mat4x3(0.f);
+                return glm::mat4x3(1.f);
             }
             if (lua_isnumber(state, -1) != 1) {
                 success = false;
-                return glm::mat4x3(0.f);
+                return glm::mat4x3(1.f);
             } else {
                 result[i][j]
                         = static_cast<glm::mat4x3::value_type>(lua_tonumber(state, -1));
@@ -123,7 +123,7 @@ using nl = std::numeric_limits<float>;
 REGISTER_NUMERICALPROPERTY_SOURCE(
     Mat4x3Property,
     glm::mat4x3,
-    glm::mat4x3(0.f),
+    glm::mat4x3(1.f),
     glm::mat4x3(
         nl::lowest(), nl::lowest(), nl::lowest(), nl::lowest(),
         nl::lowest(), nl::lowest(), nl::lowest(), nl::lowest(),

src/properties/vector/bvec2property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::bvec2 fromLuaConversion(lua_State* state, bool& success) {
-    glm::bvec2 result;
+    glm::bvec2 result = glm::bvec2(false);
     lua_pushnil(state);
     for (glm::length_t i = 0; i < ghoul::glm_components<glm::bvec2>::value; ++i) {
         int hasNext = lua_next(state, -2);

src/properties/vector/bvec3property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::bvec3 fromLuaConversion(lua_State* state, bool& success) {
-    glm::bvec3 result;
+    glm::bvec3 result = glm::bvec3(false);
     lua_pushnil(state);
     for (glm::length_t i = 0; i < ghoul::glm_components<glm::bvec3>::value; ++i) {
         int hasNext = lua_next(state, -2);

src/properties/vector/bvec4property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::bvec4 fromLuaConversion(lua_State* state, bool& success) {
-    glm::bvec4 result;
+    glm::bvec4 result = glm::bvec4(false);
     lua_pushnil(state);
     for (glm::length_t i = 0; i < ghoul::glm_components<glm::bvec4>::value; ++i) {
         int hasNext = lua_next(state, -2);

src/properties/vector/dvec2property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::dvec2 fromLuaConversion(lua_State* state, bool& success) {
-    glm::dvec2 result;
+    glm::dvec2 result = glm::dvec2(0.0);
     lua_pushnil(state);
     for (glm::length_t i = 0; i < ghoul::glm_components<glm::dvec2>::value; ++i) {
         int hasNext = lua_next(state, -2);

src/properties/vector/dvec3property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::dvec3 fromLuaConversion(lua_State* state, bool& success) {
-    glm::dvec3 result;
+    glm::dvec3 result = glm::dvec3(0.0);
     lua_pushnil(state);
     for (glm::length_t i = 0; i < ghoul::glm_components<glm::dvec3>::value; ++i) {
         int hasNext = lua_next(state, -2);

src/properties/vector/dvec4property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::dvec4 fromLuaConversion(lua_State* state, bool& success) {
-    glm::dvec4 result;
+    glm::dvec4 result = glm::dvec4(0.0);
     lua_pushnil(state);
     for (glm::length_t i = 0; i < ghoul::glm_components<glm::dvec4>::value; ++i) {
         int hasNext = lua_next(state, -2);

src/properties/vector/ivec2property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::ivec2 fromLuaConversion(lua_State* state, bool& success) {
-    glm::ivec2 result;
+    glm::ivec2 result = glm::ivec2(0);
     lua_pushnil(state);
     for (glm::length_t i = 0; i < ghoul::glm_components<glm::ivec2>::value; ++i) {
         int hasNext = lua_next(state, -2);

src/properties/vector/ivec3property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::ivec3 fromLuaConversion(lua_State* state, bool& success) {
-    glm::ivec3 result;
+    glm::ivec3 result = glm::ivec3(0);
     lua_pushnil(state);
     for (glm::length_t i = 0; i < ghoul::glm_components<glm::ivec3>::value; ++i) {
         int hasNext = lua_next(state, -2);

src/properties/vector/ivec4property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::ivec4 fromLuaConversion(lua_State* state, bool& success) {
-    glm::ivec4 result;
+    glm::ivec4 result = glm::ivec4(0);
     lua_pushnil(state);
     for (glm::length_t i = 0; i < ghoul::glm_components<glm::ivec4>::value; ++i) {
         int hasNext = lua_next(state, -2);

src/properties/vector/uvec2property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::uvec2 fromLuaConversion(lua_State* state, bool& success) {
-    glm::uvec2 result;
+    glm::uvec2 result = glm::uvec2(0);
     lua_pushnil(state);
     for (glm::length_t i = 0; i < ghoul::glm_components<glm::uvec2>::value; ++i) {
         int hasNext = lua_next(state, -2);

src/properties/vector/uvec3property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::uvec3 fromLuaConversion(lua_State* state, bool& success) {
-    glm::uvec3 result;
+    glm::uvec3 result = glm::uvec3(0);
     lua_pushnil(state);
     for (glm::length_t i = 0; i < ghoul::glm_components<glm::uvec3>::value; ++i) {
         int hasNext = lua_next(state, -2);

src/properties/vector/uvec4property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::uvec4 fromLuaConversion(lua_State* state, bool& success) {
-    glm::uvec4 result;
+    glm::uvec4 result = glm::uvec4(0);
     lua_pushnil(state);
     for (glm::length_t i = 0; i < ghoul::glm_components<glm::uvec4>::value; ++i) {
         int hasNext = lua_next(state, -2);

src/properties/vector/vec2property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::vec2 fromLuaConversion(lua_State* state, bool& success) {
-    glm::vec2 result;
+    glm::vec2 result = glm::vec2(0.f);
     lua_pushnil(state);
     for (glm::length_t i = 0; i < ghoul::glm_components<glm::vec2>::value; ++i) {
         int hasNext = lua_next(state, -2);

src/properties/vector/vec3property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::vec3 fromLuaConversion(lua_State* state, bool& success) {
-    glm::vec3 result;
+    glm::vec3 result = glm::vec3(0.f);
     lua_pushnil(state);
     for (glm::length_t i = 0; i < ghoul::glm_components<glm::vec3>::value; ++i) {
         int hasNext = lua_next(state, -2);

src/properties/vector/vec4property.cpp

@@ -33,7 +33,7 @@
 namespace {
 
 glm::vec4 fromLuaConversion(lua_State* state, bool& success) {
-    glm::vec4 result;
+    glm::vec4 result = glm::vec4(0.f);
     lua_pushnil(state);
     for (glm::length_t i = 0; i < ghoul::glm_components<glm::vec4>::value; ++i) {
         int hasNext = lua_next(state, -2);

src/util/blockplaneintersectiongeometry.cpp

@@ -79,6 +79,7 @@ void BlockPlaneIntersectionGeometry::updateVertices() {
 
     const glm::vec3 halfSize = _size * 0.5f;
     glm::vec3 intersections[12];
+    std::fill(std::begin(intersections), std::end(intersections), glm::vec3(0.f));
     int nIntersections = 0;
 
     for (int i = 0; i < 12; i++) {

src/util/spicemanager.cpp

@@ -525,7 +525,7 @@ glm::dvec3 SpiceManager::targetPosition(const std::string& target,
         }
     }
     else if (targetHasCoverage && observerHasCoverage) {
-        glm::dvec3 position;
+        glm::dvec3 position = glm::dvec3(0.0);
         spkpos_c(
             target.c_str(),
             ephemerisTime,