Added KRCamera argument to getShaderValue calls, enabling viewport specific shader reflection

Eliminated more direct setPushConstant calls

kraken/KRModelView.cpp

@@ -37,7 +37,7 @@
 
 using namespace hydra;
 
-KRModelView::KRModelView(KRViewport* viewport, const hydra::Matrix4& matModel, KRDirectionalLight* directionalLight)
+KRModelView::KRModelView(const KRViewport* viewport, const hydra::Matrix4& matModel, KRDirectionalLight* directionalLight)
   : m_viewport(viewport)
   , m_matModel(matModel)
   , m_directionalLight(directionalLight)
@@ -53,7 +53,7 @@ KRModelView::~KRModelView()
 
 }
 
-bool KRModelView::getShaderValue(ShaderValue value, Vector3* output) const
+bool KRModelView::getShaderValue(const KRCamera* camera, ShaderValue value, Vector3* output) const
 {
   if (m_directionalLight) {
     switch (value) {
@@ -95,7 +95,7 @@ bool KRModelView::getShaderValue(ShaderValue value, Vector3* output) const
       return false;
   }
 }
-bool KRModelView::getShaderValue(ShaderValue value, Matrix4* output) const
+bool KRModelView::getShaderValue(const KRCamera* camera, ShaderValue value, Matrix4* output) const
 {
   if (m_directionalLight) {
     switch (value) {

kraken/KRModelView.h

@@ -44,14 +44,14 @@ class KRModelView
   : public KRReflectedObject
 {
 public:
-  KRModelView(KRViewport* viewport, const hydra::Matrix4& matModel, KRDirectionalLight* directionalLight);
+  KRModelView(const KRViewport* viewport, const hydra::Matrix4& matModel, KRDirectionalLight* directionalLight);
   ~KRModelView();
 
-  bool getShaderValue(ShaderValue value, hydra::Vector3* output) const final;
-  bool getShaderValue(ShaderValue value, hydra::Matrix4* output) const final;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector3* output) const final;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Matrix4* output) const final;
 
 private:
-  KRViewport* m_viewport;
+  const KRViewport* m_viewport;
   hydra::Matrix4 m_matModel;
   KRDirectionalLight* m_directionalLight;
 

kraken/KRPipeline.cpp

@@ -569,7 +569,7 @@ bool KRPipeline::setImageBindings(const std::vector<const KRReflectedObject*> ob
   return success;
 }
 
-bool KRPipeline::setPushConstants(const std::vector<const KRReflectedObject*> objects)
+bool KRPipeline::setPushConstants(const KRCamera* camera, const std::vector<const KRReflectedObject*> objects)
 {
   bool success = true;
   for (StageInfo& stageInfo : m_stages) {
@@ -580,7 +580,7 @@ bool KRPipeline::setPushConstants(const std::vector<const KRReflectedObject*> ob
         void* constant = (pushConstants.buffer + pushConstants.offset[static_cast<size_t>(i)]);
         bool found = false;
         for (const KRReflectedObject* object : objects) {
-          if (object->getShaderValue(static_cast<ShaderValue>(i), pushConstants.type[static_cast<size_t>(i)], constant)) {
+          if (object->getShaderValue(camera, static_cast<ShaderValue>(i), pushConstants.type[static_cast<size_t>(i)], constant)) {
             found = true;
             break;
           }
@@ -678,7 +678,7 @@ void KRPipeline::updateDescriptorBinding()
 
 bool KRPipeline::updatePushConstants(KRNode::RenderInfo& ri, const Matrix4& matModel)
 {
-  if (!setPushConstants(ri.reflectedObjects)) {
+  if (!setPushConstants(ri.camera, ri.reflectedObjects)) {
     return false;
   }
   setPushConstant(ShaderValue::absolute_time, getContext().getAbsoluteTime());

kraken/KRPipeline.h

@@ -222,7 +222,7 @@ public:
   static const size_t kPushConstantCount = static_cast<size_t>(ShaderValue::NUM_SHADER_VALUES);
 
   bool setImageBindings(const std::vector<const KRReflectedObject*> objects);
-  bool setPushConstants(const std::vector<const KRReflectedObject*> objects);
+  bool setPushConstants(const KRCamera* camera, const std::vector<const KRReflectedObject*> objects);
   bool hasPushConstant(ShaderValue location) const;
   void setPushConstant(ShaderValue location, float value);
   void setPushConstant(ShaderValue location, int value);

kraken/KRRenderSettings.cpp

@@ -183,11 +183,12 @@ void KRRenderSettings::setViewportSize(const Vector2& size)
   m_viewportSize = size;
 }
 
-float KRRenderSettings::getPerspectiveNearZ()
+float KRRenderSettings::getPerspectiveNearZ() const
 {
   return perspective_nearz;
 }
-float KRRenderSettings::getPerspectiveFarZ()
+
+float KRRenderSettings::getPerspectiveFarZ() const
 {
   return perspective_farz;
 }
@@ -225,7 +226,7 @@ void KRRenderSettings::setEnableRealtimeOcclusion(bool enable)
   m_enable_realtime_occlusion = enable;
 }
 
-bool KRRenderSettings::getShaderValue(ShaderValue value, float* output) const
+bool KRRenderSettings::getShaderValue(const KRCamera* camera, ShaderValue value, float* output) const
 {
   switch (value) {
   case ShaderValue::fog_near:
@@ -251,7 +252,7 @@ bool KRRenderSettings::getShaderValue(ShaderValue value, float* output) const
   }
 }
 
-bool KRRenderSettings::getShaderValue(ShaderValue value, Vector3* output) const
+bool KRRenderSettings::getShaderValue(const KRCamera* camera, ShaderValue value, Vector3* output) const
 {
   switch (value) {
   case ShaderValue::fog_color:

kraken/KRRenderSettings.h

@@ -48,8 +48,8 @@ public:
   const hydra::Vector2& getViewportSize();
   void setViewportSize(const hydra::Vector2& size);
 
-  float getPerspectiveNearZ();
-  float getPerspectiveFarZ();
+  float getPerspectiveNearZ() const;
+  float getPerspectiveFarZ() const;
   void setPerspectiveNear(float v);
   void setPerpsectiveFarZ(float v);
 
@@ -137,6 +137,6 @@ private:
   float m_lodBias;
   bool m_enable_realtime_occlusion;
 
-  bool getShaderValue(ShaderValue value, float* output) const final;
-  bool getShaderValue(ShaderValue value, hydra::Vector3* output) const final;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, float* output) const final;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector3* output) const final;
 };

kraken/KRShaderReflection.cpp

@@ -219,92 +219,92 @@ const char* getShaderValueName(int index)
   return SHADER_VALUE_NAMES[index];
 }
 
-bool KRReflectedObject::getShaderValue(ShaderValue value, ShaderValueType type, void* output) const
+bool KRReflectedObject::getShaderValue(const KRCamera* camera, ShaderValue value, ShaderValueType type, void* output) const
 {
   switch (type) {
   case ShaderValueType::type_bool:
-    return getShaderValue(value, static_cast<bool*>(output));
+    return getShaderValue(camera, value, static_cast<bool*>(output));
   case ShaderValueType::type_int32:
-    return getShaderValue(value, static_cast<int32_t*>(output));
+    return getShaderValue(camera, value, static_cast<int32_t*>(output));
   case ShaderValueType::type_int64:
-    return getShaderValue(value, static_cast<int64_t*>(output));
+    return getShaderValue(camera, value, static_cast<int64_t*>(output));
   case ShaderValueType::type_float32:
-    return getShaderValue(value, static_cast<float*>(output));
+    return getShaderValue(camera, value, static_cast<float*>(output));
   case ShaderValueType::type_float64:
-    return getShaderValue(value, static_cast<double*>(output));
+    return getShaderValue(camera, value, static_cast<double*>(output));
   case ShaderValueType::type_vector2:
-    return getShaderValue(value, static_cast<Vector2*>(output));
+    return getShaderValue(camera, value, static_cast<Vector2*>(output));
   case ShaderValueType::type_vector3:
-    return getShaderValue(value, static_cast<Vector3*>(output));
+    return getShaderValue(camera, value, static_cast<Vector3*>(output));
   case ShaderValueType::type_vector4:
-    return getShaderValue(value, static_cast<Vector4*>(output));
+    return getShaderValue(camera, value, static_cast<Vector4*>(output));
   case ShaderValueType::type_matrix2:
-    return getShaderValue(value, static_cast<Matrix2*>(output));
+    return getShaderValue(camera, value, static_cast<Matrix2*>(output));
   case ShaderValueType::type_matrix2x3:
-    return getShaderValue(value, static_cast<Matrix2x3*>(output));
+    return getShaderValue(camera, value, static_cast<Matrix2x3*>(output));
   case ShaderValueType::type_matrix4:
-    return getShaderValue(value, static_cast<Matrix4*>(output));
+    return getShaderValue(camera, value, static_cast<Matrix4*>(output));
   default:
     return false;
   }
 }
 
-bool KRReflectedObject::getShaderValue(ShaderValue value, bool* output) const
+bool KRReflectedObject::getShaderValue(const KRCamera* camera, ShaderValue value, bool* output) const
 {
   return false;
 }
 
-bool KRReflectedObject::getShaderValue(ShaderValue value, int32_t* output) const
+bool KRReflectedObject::getShaderValue(const KRCamera* camera, ShaderValue value, int32_t* output) const
 {
   return false;
 }
 
-bool KRReflectedObject::getShaderValue(ShaderValue value, int64_t* output) const
+bool KRReflectedObject::getShaderValue(const KRCamera* camera, ShaderValue value, int64_t* output) const
 {
   return false;
 }
 
-bool KRReflectedObject::getShaderValue(ShaderValue value, float* output) const
+bool KRReflectedObject::getShaderValue(const KRCamera* camera, ShaderValue value, float* output) const
 {
   return false;
 }
 
-bool KRReflectedObject::getShaderValue(ShaderValue value, double* output) const
+bool KRReflectedObject::getShaderValue(const KRCamera* camera, ShaderValue value, double* output) const
 {
   return false;
 }
 
-bool KRReflectedObject::getShaderValue(ShaderValue value, hydra::Vector2* output) const
+bool KRReflectedObject::getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector2* output) const
 {
   return false;
 }
 
-bool KRReflectedObject::getShaderValue(ShaderValue value, hydra::Vector3* output) const
+bool KRReflectedObject::getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector3* output) const
 {
   return false;
 }
 
-bool KRReflectedObject::getShaderValue(ShaderValue value, hydra::Vector4* output) const
+bool KRReflectedObject::getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector4* output) const
 {
   return false;
 }
 
-bool KRReflectedObject::getShaderValue(ShaderValue value, hydra::Matrix2* output) const
+bool KRReflectedObject::getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Matrix2* output) const
 {
   return false;
 }
 
-bool KRReflectedObject::getShaderValue(ShaderValue value, hydra::Matrix2x3* output) const
+bool KRReflectedObject::getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Matrix2x3* output) const
 {
   return false;
 }
 
-bool KRReflectedObject::getShaderValue(ShaderValue value, hydra::Matrix4* output) const
+bool KRReflectedObject::getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Matrix4* output) const
 {
   return false;
 }
 
-bool KRReflectedObject::getShaderValue(ShaderValue value, KRResourceBinding* output) const
+bool KRReflectedObject::getShaderValue(const KRCamera* camera, ShaderValue value, KRResourceBinding* output) const
 {
   return false;
 }

kraken/KRShaderReflection.h

@@ -39,6 +39,7 @@
 class KRResourceBinding;
 class KRSampler;
 class KRTextureBinding;
+class KRCamera;
 
 enum class ShaderValueType : uint8_t
 {
@@ -223,19 +224,19 @@ const char* getShaderValueName(int index);
 class KRReflectedObject
 {
 public:
-  bool getShaderValue(ShaderValue value, ShaderValueType type, void* output) const;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, ShaderValueType type, void* output) const;
   virtual bool getImageBinding(const std::string& name, const KRTextureBinding** binding, KRSampler** sample) const;
 protected:
-  virtual bool getShaderValue(ShaderValue value, bool* output) const;
-  virtual bool getShaderValue(ShaderValue value, int32_t* output) const;
-  virtual bool getShaderValue(ShaderValue value, int64_t* output) const;
-  virtual bool getShaderValue(ShaderValue value, float* output) const;
-  virtual bool getShaderValue(ShaderValue value, double* output) const;
-  virtual bool getShaderValue(ShaderValue value, hydra::Vector2* output) const;
-  virtual bool getShaderValue(ShaderValue value, hydra::Vector3* output) const;
-  virtual bool getShaderValue(ShaderValue value, hydra::Vector4* output) const;
-  virtual bool getShaderValue(ShaderValue value, hydra::Matrix2* output) const;
-  virtual bool getShaderValue(ShaderValue value, hydra::Matrix2x3* output) const;
-  virtual bool getShaderValue(ShaderValue value, hydra::Matrix4* output) const;
-  virtual bool getShaderValue(ShaderValue value, KRResourceBinding* output) const;
+  virtual bool getShaderValue(const KRCamera* camera, ShaderValue value, bool* output) const;
+  virtual bool getShaderValue(const KRCamera* camera, ShaderValue value, int32_t* output) const;
+  virtual bool getShaderValue(const KRCamera* camera, ShaderValue value, int64_t* output) const;
+  virtual bool getShaderValue(const KRCamera* camera, ShaderValue value, float* output) const;
+  virtual bool getShaderValue(const KRCamera* camera, ShaderValue value, double* output) const;
+  virtual bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector2* output) const;
+  virtual bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector3* output) const;
+  virtual bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector4* output) const;
+  virtual bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Matrix2* output) const;
+  virtual bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Matrix2x3* output) const;
+  virtual bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Matrix4* output) const;
+  virtual bool getShaderValue(const KRCamera* camera, ShaderValue value, KRResourceBinding* output) const;
 };

kraken/KRViewport.cpp

@@ -55,7 +55,7 @@ KRViewport::KRViewport(const Vector2& size, const Matrix4& matView, const Matrix
   calculateDerivedValues();
 }
 
-bool KRViewport::getShaderValue(ShaderValue value, Matrix4* output) const
+bool KRViewport::getShaderValue(const KRCamera* camera, ShaderValue value, Matrix4* output) const
 {
   switch (value) {
     case ShaderValue::projection_matrix:
@@ -69,7 +69,7 @@ bool KRViewport::getShaderValue(ShaderValue value, Matrix4* output) const
   }
 }
 
-bool KRViewport::getShaderValue(ShaderValue value, Vector4* output) const
+bool KRViewport::getShaderValue(const KRCamera* camera, ShaderValue value, Vector4* output) const
 {
   switch (value) {
     case ShaderValue::viewport:

kraken/KRViewport.h

@@ -47,8 +47,8 @@ public:
   KRViewport(const hydra::Vector2& size, const hydra::Matrix4& matView, const hydra::Matrix4& matProjection);
   ~KRViewport();
 
-  bool getShaderValue(ShaderValue value, hydra::Vector4* output) const final;
-  bool getShaderValue(ShaderValue value, hydra::Matrix4* output) const final;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector4* output) const final;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Matrix4* output) const final;
 
   const hydra::Vector2& getSize() const;
   const hydra::Matrix4& getViewMatrix() const;

kraken/nodes/KRCamera.cpp

@@ -823,11 +823,16 @@ std::string KRCamera::getDebugText()
 }
 
 
-KRViewport* KRCamera::getViewport()
+const KRViewport* KRCamera::getViewport() const
 {
   return &m_viewport;
 }
 
+const KRRenderSettings* KRCamera::getSettings() const
+{
+  return &settings;
+}
+
 void KRCamera::setFadeColor(const Vector4& fade_color)
 {
   m_fade_color = fade_color;
@@ -838,14 +843,14 @@ Vector4 KRCamera::getFadeColor()
   return m_fade_color;
 }
 
-bool KRCamera::getShaderValue(ShaderValue value, hydra::Vector4* output) const
+bool KRCamera::getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector4* output) const
 {
   switch (value)     {
   case ShaderValue::fade_color:
     *output = m_fade_color;
     return true;
   default:
-    return KRNode::getShaderValue(value, output);
+    return KRNode::getShaderValue(camera, value, output);
   }
 }
 

kraken/nodes/KRCamera.h

@@ -66,9 +66,9 @@ public:
   bool alwaysStreamResources() override;
 
   KRRenderSettings settings;
+  const KRRenderSettings* getSettings() const;
 
-  KRViewport* getViewport();
-
+  const KRViewport* getViewport() const;
 
   virtual std::string getElementName() override;
   virtual tinyxml2::XMLElement* saveXML(tinyxml2::XMLNode* parent) override;
@@ -85,7 +85,7 @@ public:
   const std::string getSkyBox() const;
 
 protected:
-  bool getShaderValue(ShaderValue value, hydra::Vector4* output) const override;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector4* output) const override;
   bool getImageBinding(const std::string& name, const KRTextureBinding** binding, KRSampler** sample) const override;
 
 private:

kraken/nodes/KRLight.cpp

@@ -171,6 +171,31 @@ void KRLight::getResourceBindings(std::list<KRResourceBinding*>& bindings)
   bindings.push_back(&m_flareTexture.val);
 }
 
+Matrix4 KRLight::getParticleModelMatrix(const KRViewport& viewport) const
+{
+  Matrix4 particleModelMatrix;
+  particleModelMatrix.scale(KRLIGHT_PARTICLE_RANGE);  // Scale the box symetrically to ensure that we don't have an uneven distribution of particles for different angles of the view frustrum
+  particleModelMatrix.translate(viewport.getCameraPosition());
+
+  return particleModelMatrix;
+}
+
+int KRLight::getParticleCount() const
+{
+  int particle_count = (int)(m_dust_particle_density * pow(KRLIGHT_PARTICLE_RANGE, 3));
+  if (particle_count > KRMeshManager::KRENGINE_MAX_RANDOM_PARTICLES) {
+    particle_count = KRMeshManager::KRENGINE_MAX_RANDOM_PARTICLES;
+  }
+
+  return particle_count;
+}
+
+int KRLight::getSliceCount(const KRCamera* camera) const
+{
+  int slice_count = (int)(camera->getSettings()->volumetric_environment_quality * 495.0) + 5;
+  return slice_count;
+}
+
 void KRLight::render(RenderInfo& ri)
 {
   KRNode::render(ri);
@@ -187,17 +212,6 @@ void KRLight::render(RenderInfo& ri)
 
       if (ri.viewport->visible(getBounds()) || true) { // FINDME, HACK need to remove "|| true"?
         
-        float particle_range = 600.0f;
-        
-        int particle_count = (int)(m_dust_particle_density * pow(particle_range, 3));
-        if (particle_count > KRMeshManager::KRENGINE_MAX_RANDOM_PARTICLES) {
-          particle_count = KRMeshManager::KRENGINE_MAX_RANDOM_PARTICLES;
-        }
-        
-        Matrix4 particleModelMatrix;
-        particleModelMatrix.scale(particle_range);  // Scale the box symetrically to ensure that we don't have an uneven distribution of particles for different angles of the view frustrum
-        particleModelMatrix.translate(ri.viewport->getCameraPosition());
-        
         std::vector<KRDirectionalLight*> this_directional_light;
         std::vector<KRSpotLight*> this_spot_light;
         std::vector<KRPointLight*> this_point_light;
@@ -227,15 +241,9 @@ void KRLight::render(RenderInfo& ri)
         info.vertexAttributes = (1 << KRMesh::KRENGINE_ATTRIB_VERTEX) | (1 << KRMesh::KRENGINE_ATTRIB_TEXUVA);
         info.modelFormat = ModelFormat::KRENGINE_MODEL_FORMAT_TRIANGLES;
         KRPipeline* pParticleShader = m_pContext->getPipelineManager()->getPipeline(*ri.surface, info);
-        if (pParticleShader) {
-          pParticleShader->setPushConstant(ShaderValue::dust_particle_color, m_color.val * ri.camera->settings.dust_particle_intensity * m_dust_particle_intensity * m_intensity);
-          pParticleShader->setPushConstant(ShaderValue::particle_origin, Matrix4::DotWDiv(Matrix4::Invert(particleModelMatrix), Vector3::Zero()));
-          if (pParticleShader->bind(ri, particleModelMatrix)) { // TODO: Pass light index to shader
-
-            m_pContext->getMeshManager()->bindVBO(ri.commandBuffer, &m_pContext->getMeshManager()->KRENGINE_VBO_DATA_RANDOM_PARTICLES, 1.0f);
-
-            vkCmdDraw(ri.commandBuffer, particle_count * 3, 1, 0, 0);
-          }
+        if (pParticleShader && pParticleShader->bind(ri, getParticleModelMatrix(*ri.viewport))) { // TODO: Pass light index to shader
+          m_pContext->getMeshManager()->bindVBO(ri.commandBuffer, &m_pContext->getMeshManager()->KRENGINE_VBO_DATA_RANDOM_PARTICLES, 1.0f);
+          vkCmdDraw(ri.commandBuffer, getParticleCount() *3, 1, 0, 0);
         }
       }
     }
@@ -261,12 +269,6 @@ void KRLight::render(RenderInfo& ri)
       this_point_light.push_back(point_light);
     }
 
-    int slice_count = (int)(ri.camera->settings.volumetric_environment_quality * 495.0) + 5;
-
-    float slice_near = -ri.camera->settings.getPerspectiveNearZ();
-    float slice_far = -ri.camera->settings.volumetric_environment_max_distance;
-    float slice_spacing = (slice_far - slice_near) / slice_count;
-
     PipelineInfo info{};
     info.shader_name = &shader_name;
     info.pCamera = ri.camera;
@@ -281,11 +283,9 @@ void KRLight::render(RenderInfo& ri)
 
     KRPipeline* pFogShader = m_pContext->getPipelineManager()->getPipeline(*ri.surface, info);
     if (pFogShader) {
-      pFogShader->setPushConstant(ShaderValue::slice_depth_scale, Vector2::Create(slice_near, slice_spacing));
-      pFogShader->setPushConstant(ShaderValue::light_color, (m_color.val * ri.camera->settings.volumetric_environment_intensity * m_intensity * -slice_spacing / 10.0f));
       if (pFogShader->bind(ri, Matrix4())) { // TODO: Pass indexes of lights to shader
         m_pContext->getMeshManager()->bindVBO(ri.commandBuffer, &m_pContext->getMeshManager()->KRENGINE_VBO_DATA_VOLUMETRIC_LIGHTING, 1.0f);
-        vkCmdDraw(ri.commandBuffer, slice_count * 6, 1, 0, 0);
+        vkCmdDraw(ri.commandBuffer, getSliceCount(ri.camera) * 6, 1, 0, 0);
       }
     }
 
@@ -447,7 +447,7 @@ int KRLight::configureShadowBufferViewports(const KRViewport& viewport)
 
 void KRLight::renderShadowBuffers(RenderInfo& ri)
 {
-  KRViewport* prevViewport = ri.viewport;
+  const KRViewport* prevViewport = ri.viewport;
   for (int iShadow = 0; iShadow < m_cShadowBuffers; iShadow++) {
     if (!shadowValid[iShadow]) {
       shadowValid[iShadow] = true;
@@ -515,7 +515,7 @@ KRViewport* KRLight::getShadowViewports()
   return m_shadowViewports;
 }
 
-bool KRLight::getShaderValue(ShaderValue value, float* output) const
+bool KRLight::getShaderValue(const KRCamera* camera, ShaderValue value, float* output) const
 {
   switch (value) {
   case ShaderValue::light_intensity:
@@ -534,11 +534,34 @@ bool KRLight::getShaderValue(ShaderValue value, float* output) const
     *output = m_dust_particle_size;
     return true;
   default:
-    return KRNode::getShaderValue(value, output);
+    return KRNode::getShaderValue(camera, value, output);
   }
 }
 
-bool KRLight::getShaderValue(ShaderValue value, hydra::Vector3* output) const
+bool KRLight::getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector2* output) const
+{
+  if (camera) {
+    switch (value) {
+    case ShaderValue::slice_depth_scale:
+    {
+      int slice_count = getSliceCount(camera);
+
+      float slice_near = -camera->getSettings()->getPerspectiveNearZ();
+      float slice_far = -camera->getSettings()->volumetric_environment_max_distance;
+      float slice_spacing = (slice_far - slice_near) / slice_count;
+      *output = Vector2::Create(slice_near, slice_spacing);
+      return true;
+    }
+    break;
+    default:
+      break;
+    }
+  }
+
+  return KRNode::getShaderValue(camera, value, output);
+}
+
+bool KRLight::getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector3* output) const
 {
   switch (value) {
   case ShaderValue::light_position:
@@ -547,12 +570,17 @@ bool KRLight::getShaderValue(ShaderValue value, hydra::Vector3* output) const
   case ShaderValue::light_color:
     *output = m_color;
     return true;
+  case ShaderValue::particle_origin:
+    *output = Matrix4::DotWDiv(Matrix4::Invert(getParticleModelMatrix(*camera->getViewport())), Vector3::Zero());
+    return true;
+  case ShaderValue::dust_particle_color:
+    *output = m_color.val * m_dust_particle_intensity * m_intensity * camera->settings.dust_particle_intensity;
+    return true;
   default:
-    return KRNode::getShaderValue(value, output);
+    return KRNode::getShaderValue(camera, value, output);
   }
 }
 
-
 bool KRLight::getImageBinding(const std::string& name, const KRTextureBinding** binding, KRSampler** sample) const
 {
   if (name == "flareTexture") {

kraken/nodes/KRLight.h

@@ -36,6 +36,7 @@
 #include "resources/texture/KRTextureBinding.h"
 
 static const float KRLIGHT_MIN_INFLUENCE = 0.15f; // 0.05f
+static const float KRLIGHT_PARTICLE_RANGE = 600.0f;
 
 // KRENGINE_MAX_SHADOW_BUFFERS must be at least 6 to allow omni-directional lights to render cube maps
 
@@ -76,8 +77,9 @@ public:
 protected:
   KRLight(KRScene& scene, std::string name);
 
-  bool getShaderValue(ShaderValue value, float* output) const override;
-  bool getShaderValue(ShaderValue value, hydra::Vector3* output) const override;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, float* output) const override;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector2* output) const override;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector3* output) const override;
   bool getImageBinding(const std::string& name, const KRTextureBinding** binding, KRSampler** sample) const final;
 
   // Properties
@@ -107,4 +109,9 @@ protected:
 
   virtual int configureShadowBufferViewports(const KRViewport& viewport);
   void renderShadowBuffers(RenderInfo& ri);
+
+private:
+  hydra::Matrix4 getParticleModelMatrix(const KRViewport& viewport) const;
+  int getParticleCount() const;
+  int getSliceCount(const KRCamera* camera) const;
 };

kraken/nodes/KRModel.cpp

@@ -354,25 +354,25 @@ AABB KRModel::getBounds()
 }
 
 
-bool KRModel::getShaderValue(ShaderValue value, hydra::Vector3* output) const
+bool KRModel::getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector3* output) const
 {
   switch (value) {
   case ShaderValue::rim_color:
     *output = m_rim_color;
     return true;
   default:
-    return KRNode::getShaderValue(value, output);
+    return KRNode::getShaderValue(camera, value, output);
   }
 }
 
-bool KRModel::getShaderValue(ShaderValue value, float* output) const
+bool KRModel::getShaderValue(const KRCamera* camera, ShaderValue value, float* output) const
 {
   switch (value) {
   case ShaderValue::rim_power:
     *output = m_rim_power;
     return true;
   default:
-    return KRNode::getShaderValue(value, output);
+    return KRNode::getShaderValue(camera, value, output);
   }
 }
 

kraken/nodes/KRModel.h

@@ -96,6 +96,6 @@ private:
   
 
 private:
-  bool getShaderValue(ShaderValue value, hydra::Vector3* output) const override;
-  bool getShaderValue(ShaderValue value, float* output) const override;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector3* output) const override;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, float* output) const override;
 };

kraken/nodes/KRNode.h

@@ -116,7 +116,7 @@ public:
     std::vector<KRPointLight*> point_lights;
     std::vector<KRDirectionalLight*> directional_lights;
     std::vector<KRSpotLight*> spot_lights;
-    KRViewport* viewport;
+    const KRViewport* viewport;
     KRRenderPass* renderPass;
     KRPipeline* pipeline;
 

kraken/nodes/KRParticleSystemNewtonian.cpp

@@ -111,14 +111,14 @@ void KRParticleSystemNewtonian::render(RenderInfo& ri)
   }
 }
 
-bool KRParticleSystemNewtonian::getShaderValue(ShaderValue value, float* output) const
+bool KRParticleSystemNewtonian::getShaderValue(const KRCamera* camera, ShaderValue value, float* output) const
 {
   switch (value) {
   case ShaderValue::dust_particle_size:
     *output = 1.0f;
     return true;
   default:
-    return KRParticleSystem::getShaderValue(value, output);
+    return KRParticleSystem::getShaderValue(camera, value, output);
   }
   
 }

kraken/nodes/KRParticleSystemNewtonian.h

@@ -52,7 +52,7 @@ public:
   virtual void physicsUpdate(float deltaTime) override;
   virtual bool hasPhysics() override;
 protected:
-  bool getShaderValue(ShaderValue value, float* output) const override;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, float* output) const override;
 private:
   float m_particlesAbsoluteTime;
 };

kraken/nodes/KRPointLight.cpp

@@ -137,14 +137,14 @@ void KRPointLight::render(RenderInfo& ri)
   ri.reflectedObjects.pop_back();
 }
 
-bool KRPointLight::getShaderValue(ShaderValue value, float* output) const
+bool KRPointLight::getShaderValue(const KRCamera* camera, ShaderValue value, float* output) const
 {
-  return KRLight::getShaderValue(value, output);
+  return KRLight::getShaderValue(camera, value, output);
 }
 
-bool KRPointLight::getShaderValue(ShaderValue value, hydra::Vector3* output) const
+bool KRPointLight::getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector3* output) const
 {
-  return KRLight::getShaderValue(value, output);
+  return KRLight::getShaderValue(camera, value, output);
 }
 
 void KRPointLight::generateMesh()

kraken/nodes/KRPointLight.h

@@ -46,8 +46,8 @@ public:
   virtual void render(RenderInfo& ri) override;
 
 protected:
-  bool getShaderValue(ShaderValue value, float* output) const override;
-  bool getShaderValue(ShaderValue value, hydra::Vector3* output) const override;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, float* output) const override;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector3* output) const override;
 
 private:
   void generateMesh();

kraken/nodes/KRSprite.cpp

@@ -145,11 +145,11 @@ void KRSprite::render(RenderInfo& ri)
   ri.reflectedObjects.pop_back();
 }
 
-bool KRSprite::getShaderValue(ShaderValue value, float* output) const
+bool KRSprite::getShaderValue(const KRCamera* camera, ShaderValue value, float* output) const
 {
   switch (value) {
     default:
-      return KRNode::getShaderValue(value, output);
+      return KRNode::getShaderValue(camera, value, output);
   }
 }
 

kraken/nodes/KRSprite.h

@@ -59,7 +59,7 @@ public:
 
 protected:
 
-  bool getShaderValue(ShaderValue value, float* output) const override;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, float* output) const override;
   bool getImageBinding(const std::string& name, const KRTextureBinding** binding, KRSampler** sample) const final;
 
   KRNODE_PROPERTY(KRTextureBinding, m_spriteTexture, KRTexture::TEXTURE_USAGE_SPRITE, "sprite_texture");

kraken/resources/material/KRMaterial.cpp

@@ -834,7 +834,7 @@ bool KRMaterial::bind(KRNode::RenderInfo& ri, ModelFormat modelFormat, __uint32_
   return success;
 }
 
-bool KRMaterial::getShaderValue(ShaderValue value, float* output) const
+bool KRMaterial::getShaderValue(const KRCamera* camera, ShaderValue value, float* output) const
 {
   switch (value) {
     case ShaderValue::material_baseColor_map_rotation:
@@ -933,7 +933,7 @@ bool KRMaterial::getShaderValue(ShaderValue value, float* output) const
   return false;
 }
 
-bool KRMaterial::getShaderValue(ShaderValue value, hydra::Vector2* output) const
+bool KRMaterial::getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector2* output) const
 {
   switch (value) {
     case ShaderValue::material_baseColor_map_scale:
@@ -1020,7 +1020,7 @@ bool KRMaterial::getShaderValue(ShaderValue value, hydra::Vector2* output) const
   return false;
 }
 
-bool KRMaterial::getShaderValue(ShaderValue value, hydra::Vector3* output) const
+bool KRMaterial::getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector3* output) const
 {
   switch (value) {
     case ShaderValue::material_emissive_factor:
@@ -1038,7 +1038,7 @@ bool KRMaterial::getShaderValue(ShaderValue value, hydra::Vector3* output) const
   return false;
 }
 
-bool KRMaterial::getShaderValue(ShaderValue value, hydra::Vector4* output) const
+bool KRMaterial::getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector4* output) const
 {
   switch (value) {
     case ShaderValue::material_baseColor_factor:
@@ -1049,7 +1049,7 @@ bool KRMaterial::getShaderValue(ShaderValue value, hydra::Vector4* output) const
   }
 }
 
-bool KRMaterial::getShaderValue(ShaderValue value, KRResourceBinding* output) const
+bool KRMaterial::getShaderValue(const KRCamera* camera, ShaderValue value, KRResourceBinding* output) const
 {
   switch (value) {
     case ShaderValue::material_baseColor_map_texture:
@@ -1096,7 +1096,7 @@ bool KRMaterial::getShaderValue(ShaderValue value, KRResourceBinding* output) co
   }
 }
 
-bool KRMaterial::getShaderValue(ShaderValue value, int64_t* output) const
+bool KRMaterial::getShaderValue(const KRCamera* camera, ShaderValue value, int64_t* output) const
 {
   switch (value) {
     case ShaderValue::material_shadingModel:
@@ -1146,7 +1146,7 @@ bool KRMaterial::getShaderValue(ShaderValue value, int64_t* output) const
   }
 }
 
-bool KRMaterial::getShaderValue(ShaderValue value, bool* output) const
+bool KRMaterial::getShaderValue(const KRCamera* camera, ShaderValue value, bool* output) const
 {
   switch (value) {
     case ShaderValue::material_doubleSided:

kraken/resources/material/KRMaterial.h

@@ -183,12 +183,12 @@ public:
   float m_transmissionFactor = 0.f;
 
 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;
-  bool getShaderValue(ShaderValue value, hydra::Vector4* output) const final;
-  bool getShaderValue(ShaderValue value, KRResourceBinding* output) const final;
-  bool getShaderValue(ShaderValue value, int64_t* output) const final;
-  bool getShaderValue(ShaderValue value, bool* output) const final;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, float* output) const final;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector2* output) const final;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector3* output) const final;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, hydra::Vector4* output) const final;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, KRResourceBinding* output) const final;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, int64_t* output) const final;
+  bool getShaderValue(const KRCamera* camera, ShaderValue value, bool* output) const final;
   bool getImageBinding(const std::string& name, const KRTextureBinding** binding, KRSampler** sample) const final;
 };