WIP adding shader reflection to KRMaterial.

KRNode::RenderInfo now maintains a stack of reflected objects.
WIP adding shader reflection to KRNode.

kraken/KRPipeline.cpp

@@ -634,12 +634,15 @@ void KRPipeline::updatePushConstants(KRNode::RenderInfo& ri, const Matrix4& matM
 {
   KRModelView modelView(ri.viewport, matModel);
 
-  std::vector<const KRReflectedObject*> objects = {
-    &modelView,
-    ri.viewport,
-    &ri.camera->settings
-  };
-  setPushConstants(objects);
+  ri.reflectedObjects.push_back(&modelView);
+  ri.reflectedObjects.push_back(ri.viewport);
+  ri.reflectedObjects.push_back(&ri.camera->settings);
+
+  setPushConstants(ri.reflectedObjects);
+
+  ri.reflectedObjects.pop_back();
+  ri.reflectedObjects.pop_back();
+  ri.reflectedObjects.pop_back();
 
   setPushConstant(ShaderValue::absolute_time, getContext().getAbsoluteTime());
 

kraken/nodes/KRNode.h

@@ -35,6 +35,7 @@
 #include "KRViewport.h"
 #include "KROctreeNode.h"
 #include "KRBehavior.h"
+#include "KRShaderReflection.h"
 
 using namespace kraken;
 
@@ -62,7 +63,9 @@ class XMLNode;
 class XMLAttribute;
 }
 
-class KRNode : public KRContextObject
+class KRNode
+  : public KRContextObject
+  , public KRReflectedObject
 {
 public:
 
@@ -94,6 +97,8 @@ public:
     KRViewport* viewport;
     KRRenderPass* renderPass;
     KRPipeline* pipeline;
+
+    std::vector<const KRReflectedObject*> reflectedObjects;
   };
 
   static void InitNodeInfo(KrNodeInfo* nodeInfo);

kraken/resources/material/KRMaterial.cpp

@@ -412,7 +412,6 @@ void KRMaterial::bind(KRNode::RenderInfo& ri, ModelFormat modelFormat, __uint32_
     }
   }
 
-
   pShader->setPushConstant(ShaderValue::material_ambient, m_ambientColor + ri.camera->settings.ambient_intensity);
 
   if (ri.renderPass->getType() == RenderPassType::RENDER_PASS_FORWARD_OPAQUE) {
@@ -429,19 +428,6 @@ void KRMaterial::bind(KRNode::RenderInfo& ri, ModelFormat modelFormat, __uint32_
     pShader->setPushConstant(ShaderValue::material_specular, m_specularColor);
   }
 
-  pShader->setPushConstant(ShaderValue::material_shininess, m_ns);
-  pShader->setPushConstant(ShaderValue::material_reflection, m_reflectionColor);
-  pShader->setPushConstant(ShaderValue::diffusetexture_scale, m_diffuseMapScale);
-  pShader->setPushConstant(ShaderValue::speculartexture_scale, m_specularMapScale);
-  pShader->setPushConstant(ShaderValue::reflectiontexture_scale, m_reflectionMapScale);
-  pShader->setPushConstant(ShaderValue::normaltexture_scale, m_normalMapScale);
-  pShader->setPushConstant(ShaderValue::diffusetexture_offset, m_diffuseMapOffset);
-  pShader->setPushConstant(ShaderValue::speculartexture_offset, m_specularMapOffset);
-  pShader->setPushConstant(ShaderValue::reflectiontexture_offset, m_reflectionMapOffset);
-  pShader->setPushConstant(ShaderValue::normaltexture_offset, m_normalMapOffset);
-
-  pShader->setPushConstant(ShaderValue::material_alpha, m_tr);
-
   if (bDiffuseMap) {
     m_pDiffuseMap->resetPoolExpiry(lod_coverage, KRTexture::TEXTURE_USAGE_DIFFUSE_MAP);
     pShader->setImageBinding("diffuseTexture", m_pDiffuseMap, getContext().getSamplerManager()->DEFAULT_WRAPPING_SAMPLER);
@@ -467,7 +453,9 @@ void KRMaterial::bind(KRNode::RenderInfo& ri, ModelFormat modelFormat, __uint32_
     pShader->setImageBinding("reflectionTexture", m_pReflectionMap, getContext().getSamplerManager()->DEFAULT_CLAMPED_SAMPLER);
   }
 
+  ri.reflectedObjects.push_back(this);
   pShader->bind(ri, matModel);
+  ri.reflectedObjects.pop_back();
 }
 
 const std::string& KRMaterial::getName() const
@@ -475,3 +463,57 @@ const std::string& KRMaterial::getName() const
   return m_name;
 }
 
+
+bool KRMaterial::getShaderValue(ShaderValue value, float* output) const
+{
+  switch (value) {
+  case ShaderValue::material_alpha:
+    *output = m_tr;
+    return true;
+  case ShaderValue::material_shininess:
+    *output = m_ns;
+    return true;
+  }
+  return false;
+}
+
+bool KRMaterial::getShaderValue(ShaderValue value, hydra::Vector2* output) const
+{
+  switch (value) {
+  case ShaderValue::diffusetexture_scale:
+    *output = m_diffuseMapScale;
+    return true;
+  case ShaderValue::speculartexture_scale:
+    *output = m_specularMapScale;
+    return true;
+  case ShaderValue::reflectiontexture_scale:
+    *output = m_reflectionMapScale;
+    return true;
+  case ShaderValue::normaltexture_scale:
+    *output = m_normalMapScale;
+    return true;
+  case ShaderValue::diffusetexture_offset:
+    *output = m_diffuseMapOffset;
+    return true;
+  case ShaderValue::speculartexture_offset:
+    *output = m_specularMapOffset;
+    return true;
+  case ShaderValue::reflectiontexture_offset:
+    *output = m_reflectionMapOffset;
+    return true;
+  case ShaderValue::normaltexture_offset:
+    *output = m_normalMapOffset;
+    return true;
+  }
+  return false;
+}
+
+bool KRMaterial::getShaderValue(ShaderValue value, hydra::Vector3* output) const
+{
+  switch (value) {
+  case ShaderValue::material_reflection:
+    *output = m_reflectionColor;
+    return true;
+  }
+  return false;
+}

kraken/resources/material/KRMaterial.h

@@ -42,6 +42,7 @@
 #include "resources/KRResource.h"
 #include "resources/scene/KRScene.h"
 #include "nodes/KRBone.h"
+#include "KRShaderReflection.h"
 
 enum class CullMode : __uint32_t;
 enum class ModelFormat : __uint8_t;
@@ -50,7 +51,9 @@ class KRTextureManager;
 class KRContext;
 class KRSurface;
 
-class KRMaterial : public KRResource
+class KRMaterial
+  : public KRResource
+  , public KRReflectedObject
 {
 public:
   typedef enum
@@ -137,4 +140,9 @@ private:
   alpha_mode_type m_alpha_mode;
 
   void getTextures();
+
+private:
+  bool getShaderValue(ShaderValue value, float* output) const final;
+  bool getShaderValue(ShaderValue value, hydra::Vector2* output) const final;
+  bool getShaderValue(ShaderValue value, hydra::Vector3* output) const final;
 };