Moved push constant bindings to reflection interface for viewports

kraken/KRModelView.cpp

@@ -42,6 +42,8 @@ KRModelView::KRModelView(KRViewport* viewport, const hydra::Matrix4& matModel)
 {
   m_matModelInverse = matModel;
   m_matModelInverse.invert();
+
+  m_matModelView = matModel * viewport->getViewMatrix();
 }
 
 KRModelView::~KRModelView()
@@ -60,8 +62,76 @@ bool KRModelView::getShaderValue(ShaderValue value, void* buffer, size_t size) c
         memcpy(buffer, &cameraPosObject, sizeof(Vector3));
         return true;
       }
+      case ShaderValue::view_space_model_origin:
+      {
+        // Origin point of model space is the light source position.  No perspective, so no w divide required
+        Vector3 viewSpaceModelOrigin = Matrix4::Dot(m_matModelView, Vector3::Zero());
+        memcpy(buffer, &viewSpaceModelOrigin, sizeof(Vector3));
+        return true;
+      }
     }
   }
+
+  if (size == sizeof(Matrix4)) {
+    switch (value) {
+      case ShaderValue::model_matrix:
+      {
+        memcpy(buffer, &m_matModel, sizeof(Matrix4));
+        return true;
+      }
+      case ShaderValue::model_view:
+      {
+        memcpy(buffer, &m_matModelView, sizeof(Matrix4));
+        return true;
+      }
+      case ShaderValue::model_view_inverse_transpose:
+      {
+        Matrix4 matModelViewInverseTranspose = m_matModelView;
+        matModelViewInverseTranspose.transpose();
+        matModelViewInverseTranspose.invert();
+        memcpy(buffer, &matModelViewInverseTranspose, sizeof(Matrix4));
+        return true;
+      }
+      case ShaderValue::model_inverse_transpose:
+      {
+        Matrix4 matModelInverseTranspose = m_matModel;
+        matModelInverseTranspose.transpose();
+        matModelInverseTranspose.invert();
+        memcpy(buffer, &matModelInverseTranspose, sizeof(Matrix4));
+        return true;
+      }
+      case ShaderValue::invmvp_no_translate:
+      {
+        Matrix4 matInvMVPNoTranslate = m_matModelView;
+        // Remove the translation
+        matInvMVPNoTranslate.getPointer()[3] = 0;
+        matInvMVPNoTranslate.getPointer()[7] = 0;
+        matInvMVPNoTranslate.getPointer()[11] = 0;
+        matInvMVPNoTranslate.getPointer()[12] = 0;
+        matInvMVPNoTranslate.getPointer()[13] = 0;
+        matInvMVPNoTranslate.getPointer()[14] = 0;
+        matInvMVPNoTranslate.getPointer()[15] = 1.0;
+        matInvMVPNoTranslate = matInvMVPNoTranslate * m_viewport->getProjectionMatrix();
+        matInvMVPNoTranslate.invert();
+        memcpy(buffer, &matInvMVPNoTranslate, sizeof(Matrix4));
+        return true;
+      }
+      case ShaderValue::mvp:
+      {
+        Matrix4 mvpMatrix = m_matModel * m_viewport->getViewProjectionMatrix();
+        memcpy(buffer, &mvpMatrix, sizeof(Matrix4));
+        return true;
+      }
+      case ShaderValue::invmvp:
+      {
+        Matrix4 mvpMatrix = m_matModel * m_viewport->getViewProjectionMatrix();
+        Matrix4 invMVP = Matrix4::Invert(mvpMatrix);
+        memcpy(buffer, &invMVP, sizeof(Matrix4));
+        return true;
+      }
+    }
+  }
+
   return false;
 }
 

kraken/KRModelView.h

@@ -54,4 +54,5 @@ private:
 
   // Derived values
   hydra::Matrix4 m_matModelInverse;
+  hydra::Matrix4 m_matModelView;
 };

kraken/KRPipeline.cpp

@@ -604,7 +604,7 @@ void KRPipeline::updatePushConstants(KRNode::RenderInfo& ri, const Matrix4& matM
 {
   KRModelView modelView(ri.viewport, matModel);
 
-  std::vector<const KRReflectedObject*> objects = { &modelView };
+  std::vector<const KRReflectedObject*> objects = { &modelView, ri.viewport };
   setPushConstants(objects);
 
   setPushConstant(ShaderValue::absolute_time, getContext().getAbsoluteTime());
@@ -668,75 +668,6 @@ void KRPipeline::updatePushConstants(KRNode::RenderInfo& ri, const Matrix4& matM
     //light_spot_count = spot_lights.size();
   }
 
-  if (hasPushConstant(ShaderValue::mvp) || hasPushConstant(ShaderValue::invmvp)) {
-    // Bind our modelmatrix variable to be a uniform called mvpmatrix in our shaderprogram
-    Matrix4 mvpMatrix = matModel * ri.viewport->getViewProjectionMatrix();
-    setPushConstant(ShaderValue::mvp, mvpMatrix);
-
-    if (hasPushConstant(ShaderValue::invmvp)) {
-      setPushConstant(ShaderValue::invmvp, Matrix4::Invert(mvpMatrix));
-    }
-  }
-
-  if (hasPushConstant(ShaderValue::view_space_model_origin) || hasPushConstant(ShaderValue::model_view_inverse_transpose) || hasPushConstant(ShaderValue::model_view)) {
-    Matrix4 matModelView = matModel * ri.viewport->getViewMatrix();
-    setPushConstant(ShaderValue::model_view, matModelView);
-
-
-    if (hasPushConstant(ShaderValue::view_space_model_origin)) {
-      Vector3 view_space_model_origin = Matrix4::Dot(matModelView, Vector3::Zero()); // Origin point of model space is the light source position.  No perspective, so no w divide required
-      setPushConstant(ShaderValue::view_space_model_origin, view_space_model_origin);
-    }
-
-    if (hasPushConstant(ShaderValue::model_view_inverse_transpose)) {
-      Matrix4 matModelViewInverseTranspose = matModelView;
-      matModelViewInverseTranspose.transpose();
-      matModelViewInverseTranspose.invert();
-      setPushConstant(ShaderValue::model_view_inverse_transpose, matModelViewInverseTranspose);
-    }
-  }
-
-  if (hasPushConstant(ShaderValue::model_inverse_transpose)) {
-    Matrix4 matModelInverseTranspose = matModel;
-    matModelInverseTranspose.transpose();
-    matModelInverseTranspose.invert();
-    setPushConstant(ShaderValue::model_inverse_transpose, matModelInverseTranspose);
-  }
-
-  if (hasPushConstant(ShaderValue::invp)) {
-    setPushConstant(ShaderValue::invp, ri.viewport->getInverseProjectionMatrix());
-  }
-
-  if (hasPushConstant(ShaderValue::invmvp_no_translate)) {
-    Matrix4 matInvMVPNoTranslate = matModel * ri.viewport->getViewMatrix();;
-    // Remove the translation
-    matInvMVPNoTranslate.getPointer()[3] = 0;
-    matInvMVPNoTranslate.getPointer()[7] = 0;
-    matInvMVPNoTranslate.getPointer()[11] = 0;
-    matInvMVPNoTranslate.getPointer()[12] = 0;
-    matInvMVPNoTranslate.getPointer()[13] = 0;
-    matInvMVPNoTranslate.getPointer()[14] = 0;
-    matInvMVPNoTranslate.getPointer()[15] = 1.0;
-    matInvMVPNoTranslate = matInvMVPNoTranslate * ri.viewport->getProjectionMatrix();
-    matInvMVPNoTranslate.invert();
-    setPushConstant(ShaderValue::invmvp_no_translate, matInvMVPNoTranslate);
-  }
-
-  setPushConstant(ShaderValue::model_matrix, matModel);
-  if (hasPushConstant(ShaderValue::projection_matrix)) {
-    setPushConstant(ShaderValue::projection_matrix, ri.viewport->getProjectionMatrix());
-  }
-
-  if (hasPushConstant(ShaderValue::viewport)) {
-    setPushConstant(ShaderValue::viewport, Vector4::Create(
-      (float)0.0,
-      (float)0.0,
-      (float)ri.viewport->getSize().x,
-      (float)ri.viewport->getSize().y
-    )
-    );
-  }
-
   // Fog parameters
   setPushConstant(ShaderValue::fog_near, ri.camera->settings.fog_near);
   setPushConstant(ShaderValue::fog_far, ri.camera->settings.fog_far);

kraken/KRViewport.cpp

@@ -57,6 +57,37 @@ KRViewport::KRViewport(const Vector2& size, const Matrix4& matView, const Matrix
 
 bool KRViewport::getShaderValue(ShaderValue value, void* buffer, size_t size) const
 {
+  if (size == sizeof(Matrix4)) {
+    switch (value) {
+      case ShaderValue::projection_matrix:
+      {
+        memcpy(buffer, &m_matProjection, sizeof(Matrix4));
+        return true;
+      }
+      case ShaderValue::invp:
+      {
+        memcpy(buffer, &m_matInverseProjection, sizeof(Matrix4));
+        return true;
+      }
+    }
+  }
+
+  if (size == sizeof(Vector4)) {
+    switch (value) {
+      case ShaderValue::viewport:
+      {
+        Vector4 viewport = Vector4::Create(
+          0.0f,
+          0.0f,
+          getSize().x,
+          getSize().y
+        );
+        memcpy(buffer, &viewport, sizeof(Vector4));
+        return true;
+      }
+    }
+  }
+
   return false;
 }