Implementation of reflection and skylight probes.

Moves lighting math to the diffuse/specular two-channel logic.
2026-02-13 19:53:48 +00:00 · 2018-09-16 22:15:07 -05:00 · 2018-09-16 22:15:07 -05:00 · b19a4b22c8
commit b19a4b22c8
parent 1f7cf55204
102 changed files with 12346 additions and 1911 deletions
--- a/Engine/source/lighting/probeManager.cpp
+++ b/Engine/source/lighting/probeManager.cpp
@ -0,0 +1,809 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2012 GarageGames, LLC
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+//-----------------------------------------------------------------------------
+
+#include "platform/platform.h"
+#include "lighting/probeManager.h"
+
+#include "console/console.h"
+#include "console/consoleTypes.h"
+#include "core/util/safeDelete.h"
+#include "console/sim.h"
+#include "console/simSet.h"
+#include "scene/sceneManager.h"
+#include "materials/materialManager.h"
+#include "materials/sceneData.h"
+#include "lighting/lightInfo.h"
+#include "lighting/lightingInterfaces.h"
+#include "T3D/gameBase/gameConnection.h"
+#include "gfx/gfxStringEnumTranslate.h"
+#include "console/engineAPI.h"
+#include "renderInstance/renderDeferredMgr.h"
+#include "shaderGen/shaderGenVars.h"
+
+Signal<void(const char*,bool)> ProbeManager::smActivateSignal;
+ProbeManager *ProbeManager::smProbeManager = NULL;
+
+
+//
+//
+ProbeInfo::ProbeInfo()
+   : mTransform(true),
+   mAmbient(0.0f, 0.0f, 0.0f, 1.0f),
+   mPriority(1.0f),
+   mScore(0.0f),
+   mDebugRender(false),
+   mCubemap(NULL),
+   mIrradianceCubemap(NULL),
+   mBRDFTexture(NULL),
+   mRadius(1.0f),
+   mIntensity(1.0f)
+{
+   for (U32 i = 0; i < 5; ++i)
+   {
+      mSHConstants[i] = 0;
+   }
+}
+
+ProbeInfo::~ProbeInfo()
+{
+   SAFE_DELETE(mCubemap);
+}
+
+void ProbeInfo::set(const ProbeInfo *probeInfo)
+{
+   mTransform = probeInfo->mTransform;
+   mAmbient = probeInfo->mAmbient;
+   mCubemap = probeInfo->mCubemap;
+   mIrradianceCubemap = probeInfo->mIrradianceCubemap;
+   mBRDFTexture = probeInfo->mBRDFTexture;
+   mRadius = probeInfo->mRadius;
+   mIntensity = probeInfo->mIntensity;
+   mProbeShapeType = probeInfo->mProbeShapeType;
+   numPrims = probeInfo->numPrims;
+   numVerts = probeInfo->numVerts;
+   numIndicesForPoly = probeInfo->numIndicesForPoly;
+   mBounds = probeInfo->mBounds;
+
+   for (U32 i = 0; i < 9; i++)
+   {
+      mSHTerms[i] = probeInfo->mSHTerms[i];
+   }
+
+   for (U32 i = 0; i < 5; i++)
+   {
+      mSHConstants[i] = probeInfo->mSHConstants[i];
+   }
+}
+
+void ProbeInfo::getWorldToLightProj(MatrixF *outMatrix) const
+{
+   *outMatrix = getTransform();
+   outMatrix->inverse();
+}
+
+
+void ProbeInfoList::registerProbe(ProbeInfo *light)
+{
+   if (!light)
+      return;
+   // just add the light, we'll try to scan for dupes later...
+   push_back(light);
+}
+
+void ProbeInfoList::unregisterProbe(ProbeInfo *light)
+{
+   // remove all of them...
+   ProbeInfoList &list = *this;
+   for (U32 i = 0; i<list.size(); i++)
+   {
+      if (list[i] != light)
+         continue;
+
+      // this moves last to i, which allows
+      // the search to continue forward...
+      list.erase_fast(i);
+      // want to check this location again...
+      i--;
+   }
+}
+
+ProbeShaderConstants::ProbeShaderConstants()
+   : mInit(false),
+   mShader(NULL),
+   mProbeParamsSC(NULL),
+   mProbePositionSC(NULL),
+   mProbeRadiusSC(NULL),
+   mProbeBoxMinSC(NULL),
+   mProbeBoxMaxSC(NULL),
+   mProbeIsSphereSC(NULL),
+   mProbeLocalPosSC(NULL),
+   mProbeCubemapSC(NULL)
+{
+}
+
+ProbeShaderConstants::~ProbeShaderConstants()
+{
+   if (mShader.isValid())
+   {
+      mShader->getReloadSignal().remove(this, &ProbeShaderConstants::_onShaderReload);
+      mShader = NULL;
+   }
+}
+
+void ProbeShaderConstants::init(GFXShader* shader)
+{
+   if (mShader.getPointer() != shader)
+   {
+      if (mShader.isValid())
+         mShader->getReloadSignal().remove(this, &ProbeShaderConstants::_onShaderReload);
+
+      mShader = shader;
+      mShader->getReloadSignal().notify(this, &ProbeShaderConstants::_onShaderReload);
+   }
+
+   mProbeParamsSC = shader->getShaderConstHandle("$probeParams");
+
+   //Reflection Probes
+   mProbePositionSC = shader->getShaderConstHandle(ShaderGenVars::probePosition);
+   mProbeRadiusSC = shader->getShaderConstHandle(ShaderGenVars::probeRadius);
+   mProbeBoxMinSC = shader->getShaderConstHandle(ShaderGenVars::probeBoxMin);
+   mProbeBoxMaxSC = shader->getShaderConstHandle(ShaderGenVars::probeBoxMax);
+   mProbeIsSphereSC = shader->getShaderConstHandle(ShaderGenVars::probeIsSphere);
+   mProbeLocalPosSC = shader->getShaderConstHandle(ShaderGenVars::probeLocalPos);
+   mProbeCubemapSC = shader->getShaderConstHandle(ShaderGenVars::probeCubemap);
+
+   mInit = true;
+}
+
+void ProbeShaderConstants::_onShaderReload()
+{
+   if (mShader.isValid())
+      init(mShader);
+}
+
+ProbeManager::ProbeManager()
+   :  mDefaultProbe( NULL ),
+      mSceneManager( NULL ),
+      mCullPos( Point3F::Zero )
+{ 
+   dMemset( &mSpecialProbes, 0, sizeof(mSpecialProbes) );
+
+   mLastShader = NULL;
+   mLastConstants = NULL;
+}
+
+ProbeManager::~ProbeManager() 
+{
+}
+
+ProbeInfo* ProbeManager::createProbeInfo(ProbeInfo* probe /* = NULL */)
+{
+   ProbeInfo *outProbe = (probe != NULL) ? probe : new ProbeInfo;
+
+   /*ProbeManagerMap &ProbeManagers = _getProbeManagers();
+   ProbeManagerMap::Iterator iter = ProbeManagers.begin();
+   for ( ; iter != ProbeManagers.end(); iter++ )
+   {
+      ProbeManager *lm = iter->value;
+      lm->_addLightInfoEx( outLight );
+   }*/
+
+   return outProbe;
+}
+
+/*void ProbeManager::initLightFields()
+{
+   ProbeManagerMap &ProbeManagers = _getProbeManagers();
+
+   ProbeManagerMap::Iterator iter = ProbeManagers.begin();
+   for ( ; iter != ProbeManagers.end(); iter++ )
+   {
+      ProbeManager *lm = iter->value;
+      lm->_initLightFields();
+   }
+}*/
+
+IMPLEMENT_GLOBAL_CALLBACK( onProbeManagerActivate, void, ( const char *name ), ( name ),
+   "A callback called by the engine when a light manager is activated.\n"
+   "@param name The name of the light manager being activated.\n"
+   "@ingroup Lighting\n" );
+
+void ProbeManager::activate( SceneManager *sceneManager )
+{
+   AssertFatal( sceneManager, "ProbeManager::activate() - Got null scene manager!" );
+   //AssertFatal( mIsActive == false, "ProbeManager::activate() - Already activated!" );
+   AssertFatal(smProbeManager == NULL, "ProbeManager::activate() - A previous ProbeManager is still active!" );
+
+   mSceneManager = sceneManager;
+   smProbeManager = this;
+}
+
+IMPLEMENT_GLOBAL_CALLBACK( onProbeManagerDeactivate, void, ( const char *name ), ( name ),
+   "A callback called by the engine when a light manager is deactivated.\n"
+   "@param name The name of the light manager being deactivated.\n"
+   "@ingroup Lighting\n" );
+
+void ProbeManager::deactivate()
+{
+   //AssertFatal( mIsActive == true, "ProbeManager::deactivate() - Already deactivated!" );
+   AssertFatal( smProbeManager == this, "ProbeManager::activate() - This isn't the active light manager!" );
+
+   //if( Sim::getRootGroup() ) // To protect against shutdown.
+   //   onProbeManagerDeactivate_callback( getName() );
+
+   //mIsActive = false;
+   mSceneManager = NULL;
+   smProbeManager = NULL;
+
+   // Just in case... make sure we're all clear.
+   unregisterAllProbes();
+}
+
+ProbeInfo* ProbeManager::getDefaultLight()
+{
+   // The sun is always our default light when
+   // when its registered.
+   if ( mSpecialProbes[ ProbeManager::SkylightProbeType ] )
+      return mSpecialProbes[ ProbeManager::SkylightProbeType ];
+
+   // Else return a dummy special light.
+   //if ( !mDefaultLight )
+   //   mDefaultLight = createLightInfo();
+   return NULL;
+}
+
+ProbeInfo* ProbeManager::getSpecialProbe( ProbeManager::SpecialProbeTypesEnum type, bool useDefault )
+{
+   //if ( mSpecialLights[type] )
+   //   return mSpecialLights[type];
+
+   if ( useDefault )
+      return getDefaultLight();
+
+   return NULL;
+}
+
+void ProbeManager::setSpecialProbe( ProbeManager::SpecialProbeTypesEnum type, ProbeInfo *probe )
+{
+   if (probe && type == SkylightProbeType )
+   {
+      // The sun must be specially positioned and ranged
+      // so that it can be processed like a point light 
+      // in the stock light shader used by Basic Lighting.
+      
+      probe->setPosition( mCullPos - (probe->getDirection() * 10000.0f ) );
+      probe->mRadius = 2000000.0f;
+   }
+
+   mSpecialProbes[type] = probe;
+   registerProbe(probe, NULL );
+}
+
+void ProbeManager::registerProbes( const Frustum *frustum, bool staticLighting )
+{
+   PROFILE_SCOPE( ProbeManager_RegisterProbes );
+
+   // TODO: We need to work this out...
+   //
+   // 1. Why do we register and unregister lights on every 
+   //    render when they don't often change... shouldn't we
+   //    just register once and keep them?
+   // 
+   // 2. If we do culling of lights should this happen as part
+   //    of registration or somewhere else?
+   //
+
+   // Grab the lights to process.
+   Vector<SceneObject*> activeLights;
+   const U32 lightMask = LightObjectType;
+   
+   if ( staticLighting || !frustum )
+   {
+      // We're processing static lighting or want all the lights
+      // in the container registerd...  so no culling.
+      getSceneManager()->getContainer()->findObjectList( lightMask, &activeLights );
+   }
+   else
+   {
+      // Cull the lights using the frustum.
+      getSceneManager()->getContainer()->findObjectList( *frustum, lightMask, &activeLights );
+      /* supress light culling filter until we can sort out why that's misbehaving with dynamic cube mapping
+      for (U32 i = 0; i < activeLights.size(); ++i)
+      {
+         if (!getSceneManager()->mRenderedObjectsList.contains(activeLights[i]))
+         {
+            activeLights.erase(i);
+            --i;
+         }
+      }
+      */
+      // Store the culling position for sun placement
+      // later... see setSpecialLight.
+      mCullPos = frustum->getPosition();
+
+      // HACK: Make sure the control object always gets 
+      // processed as lights mounted to it don't change
+      // the shape bounds and can often get culled.
+
+      GameConnection *conn = GameConnection::getConnectionToServer();
+      if ( conn->getControlObject() )
+      {
+         GameBase *conObject = conn->getControlObject();
+         activeLights.push_back_unique( conObject );
+      }
+   }
+
+   // Let the lights register themselves.
+   /*for ( U32 i = 0; i < activeLights.size(); i++ )
+   {
+      ISceneLight *lightInterface = dynamic_cast<ISceneLight*>( activeLights[i] );
+      if ( lightInterface )
+         lightInterface->submitLights( this, staticLighting );
+   }*/
+}
+
+void ProbeManager::registerSkylight(ProbeInfo *probe, SimObject *obj)
+{
+   mSkylight = probe;
+
+   if (String("Advanced Lighting").equal(LIGHTMGR->getName(), String::NoCase))
+   {
+      SceneRenderState* state = mSceneManager->getCurrentRenderState();
+
+      RenderPassManager *renderPass = state->getRenderPass();
+
+      // Allocate an MeshRenderInst so that we can submit it to the RenderPassManager
+      ProbeRenderInst *probeInst = renderPass->allocInst<ProbeRenderInst>();
+
+      probeInst->set(probe);
+
+      probeInst->type = RenderPassManager::RIT_Probes;
+
+      // Submit our RenderInst to the RenderPassManager
+      state->getRenderPass()->addInst(probeInst);
+   }
+}
+
+void ProbeManager::registerProbe(ProbeInfo *probe, SimObject *obj )
+{
+  // AssertFatal( !mRegisteredProbes.contains(probe),
+      //"ProbeManager::registerGlobalLight - This light is already registered!" );
+
+   if (!mRegisteredProbes.contains(probe))
+      mRegisteredProbes.push_back(probe);
+
+   if (String("Advanced Lighting").equal(LIGHTMGR->getName(), String::NoCase))
+   {
+      SceneRenderState* state = mSceneManager->getCurrentRenderState();
+
+      RenderPassManager *renderPass = state->getRenderPass();
+
+      // Allocate an MeshRenderInst so that we can submit it to the RenderPassManager
+      ProbeRenderInst *probeInst = renderPass->allocInst<ProbeRenderInst>();
+
+      probeInst->set(probe);
+
+      probeInst->type = RenderPassManager::RIT_Probes;
+
+      // Submit our RenderInst to the RenderPassManager
+      state->getRenderPass()->addInst(probeInst);
+   }
+}
+
+void ProbeManager::unregisterProbe(ProbeInfo *probe )
+{
+   mRegisteredProbes.unregisterProbe(probe);
+
+   // If this is the sun... clear the special light too.
+   if (probe == mSpecialProbes[SkylightProbeType] )
+      dMemset(mSpecialProbes, 0, sizeof(mSpecialProbes) );
+}
+
+void ProbeManager::unregisterAllProbes()
+{
+   //dMemset(mSpecialProbes, 0, sizeof(mSpecialProbes) );
+   mRegisteredProbes.clear();
+
+   mSkylight = nullptr;
+}
+
+void ProbeManager::getAllUnsortedProbes( Vector<ProbeInfo*> *list ) const
+{
+   list->merge( mRegisteredProbes );
+}
+
+ProbeShaderConstants* ProbeManager::getProbeShaderConstants(GFXShaderConstBuffer* buffer)
+{
+   if (!buffer)
+      return NULL;
+
+   PROFILE_SCOPE(ProbeManager_GetProbeShaderConstants);
+
+   GFXShader* shader = buffer->getShader();
+
+   // Check to see if this is the same shader, we'll get hit repeatedly by
+   // the same one due to the render bin loops.
+   if (mLastShader.getPointer() != shader)
+   {
+      ProbeConstantMap::Iterator iter = mConstantLookup.find(shader);
+      if (iter != mConstantLookup.end())
+      {
+         mLastConstants = iter->value;
+      }
+      else
+      {
+         ProbeShaderConstants* psc = new ProbeShaderConstants();
+         mConstantLookup[shader] = psc;
+
+         mLastConstants = psc;
+      }
+
+      // Set our new shader
+      mLastShader = shader;
+   }
+
+   mLastConstants = new ProbeShaderConstants();
+
+   // Make sure that our current lighting constants are initialized
+   if (!mLastConstants->mInit)
+      mLastConstants->init(shader);
+
+   return mLastConstants;
+}
+
+void ProbeManager::_update4ProbeConsts(   const SceneData &sgData,
+                                          MatrixSet &matSet,
+                                          GFXShaderConstHandle *probePositionSC,
+                                          GFXShaderConstHandle *probeRadiusSC,
+                                          GFXShaderConstHandle *probeBoxMinSC,
+                                          GFXShaderConstHandle *probeBoxMaxSC,
+                                          GFXShaderConstHandle *probeCubemapSC,
+                                          GFXShaderConstHandle *probeIsSphereSC,
+                                          GFXShaderConstHandle *probeLocalPosSC,
+                                          GFXShaderConstBuffer *shaderConsts )
+{
+   PROFILE_SCOPE( ProbeManager_Update4ProbeConsts );
+
+   // Skip over gathering lights if we don't have to!
+   if (probePositionSC->isValid() ||
+      probeRadiusSC->isValid() ||
+      probeBoxMinSC->isValid() ||
+      probeBoxMaxSC->isValid() ||
+      probeCubemapSC->isValid()  && (!mRegisteredProbes.empty() || mSkylight))
+   {
+      PROFILE_SCOPE(ProbeManager_Update4ProbeConsts_setProbes);
+
+      static AlignedArray<Point3F> probePositions(4, sizeof(Point3F));
+      static AlignedArray<F32> probeRadius(4, sizeof(F32));
+      static AlignedArray<Point3F> probeBoxMins(4, sizeof(Point3F));
+      static AlignedArray<Point3F> probeBoxMaxs(4, sizeof(Point3F));
+      static AlignedArray<Point3F> probeLocalPositions(4, sizeof(Point3F));
+      static AlignedArray<F32> probeIsSphere(4, sizeof(F32));
+      //static AlignedArray<CubemapData> probeCubemap(4, sizeof(CubemapData));
+      F32 range;
+
+      // Need to clear the buffers so that we don't leak
+      // lights from previous passes or have NaNs.
+      dMemset(probePositions.getBuffer(), 0, probePositions.getBufferSize());
+      dMemset(probeRadius.getBuffer(), 0, probeRadius.getBufferSize());
+      dMemset(probeBoxMins.getBuffer(), 0, probeBoxMins.getBufferSize());
+      dMemset(probeBoxMaxs.getBuffer(), 0, probeBoxMaxs.getBufferSize());
+      dMemset(probeLocalPositions.getBuffer(), 0, probeLocalPositions.getBufferSize());
+      dMemset(probeIsSphere.getBuffer(), 0, probeRadius.getBufferSize());
+      //dMemset(probeCubemap.getBuffer(), 0, probeCubemap.getBufferSize());
+
+      matSet.restoreSceneViewProjection();
+
+      const MatrixF &worldToCameraXfm = matSet.getWorldToCamera();
+
+      // Gather the data for the first 4 probes.
+      const ProbeInfo *probe;
+      for (U32 i = 0; i < 4; i++)
+      {
+         if (i >= mRegisteredProbes.size())
+            break;
+
+         if (i == 0 && mSkylight)
+         {
+            //quickly try and see if we have a skylight, and set that to always be probe 0
+            probe = mSkylight;
+         }
+         else
+         {
+            probe = mRegisteredProbes[i];
+         }
+
+         if (!probe)
+            continue;
+
+         // The light positions and spot directions are 
+         // in SoA order to make optimal use of the GPU.
+         const Point3F &probePos = probe->getPosition();
+         probePositions[i].x = probePos.x;
+         probePositions[i].y = probePos.y;
+         probePositions[i].z = probePos.z;
+
+         probeRadius[i] = probe->mRadius;
+
+         const Point3F &minExt = probe->mBounds.minExtents;
+         probeBoxMins[i].x = minExt.x;
+         probeBoxMins[i].y = minExt.y;
+         probeBoxMins[i].z = minExt.z;
+
+         const Point3F &maxExt = probe->mBounds.maxExtents;
+         probeBoxMaxs[i].x = maxExt.x;
+         probeBoxMaxs[i].y = maxExt.y;
+         probeBoxMaxs[i].z = maxExt.z;
+
+         probeIsSphere[i] = probe->mProbeShapeType == ProbeInfo::Sphere ? 1.0 : 0.0;
+
+         Point3F localProbePos;
+         worldToCameraXfm.mulP(probe->getPosition(), &localProbePos);
+
+         probeLocalPositions[i].x = localProbePos.x;
+         probeLocalPositions[i].y = localProbePos.y;
+         probeLocalPositions[i].z = localProbePos.z;
+
+         if (probe->mCubemap && !probe->mCubemap->isNull())
+         {
+            S32 samplerReg = probeCubemapSC->getSamplerRegister();
+
+            if(samplerReg != -1)
+               GFX->setCubeTexture(samplerReg + i, probe->mCubemap->getPointer());
+         }
+      }
+
+      shaderConsts->setSafe(probePositionSC, probePositions);
+      shaderConsts->setSafe(probeRadiusSC, probeRadius);
+      shaderConsts->setSafe(probeBoxMinSC, probeBoxMins);
+      shaderConsts->setSafe(probeBoxMaxSC, probeBoxMaxs);
+      shaderConsts->setSafe(probeLocalPosSC, probeLocalPositions);
+      shaderConsts->setSafe(probeIsSphereSC, probeIsSphere);
+
+      //
+      
+      //shaderConsts->setSafe(lightSpotAngleSC, lightSpotAngle);
+      //shaderConsts->setSafe(lightSpotFalloffSC, lightSpotFalloff);
+   }
+   else
+   {
+      /*if (probe->mCubemap && !probe->mCubemap->isNull())
+      {
+         GFX->setCubeTexture(1, probe->mCubemap->getPointer());
+      }*/
+      if (probeCubemapSC->isValid())
+      {
+         for(U32 i=0; i < 4; ++i)
+            GFX->setCubeTexture(probeCubemapSC->getSamplerRegister() + i, NULL);
+      }
+   }
+}
+
+void ProbeManager::setProbeInfo(ProcessedMaterial *pmat,
+   const Material *mat,
+   const SceneData &sgData,
+   const SceneRenderState *state,
+   U32 pass,
+   GFXShaderConstBuffer *shaderConsts)
+{
+   
+   // Skip this if we're rendering from the deferred bin.
+   if ( sgData.binType == SceneData::DeferredBin )
+      return;
+
+  // if (mRegisteredProbes.empty())
+  //    return;
+
+   PROFILE_SCOPE(ProbeManager_setProbeInfo);
+
+   ProbeShaderConstants *psc = getProbeShaderConstants(shaderConsts);
+
+   //ProbeInfo *probe;
+   //probe = mRegisteredProbes[0];
+
+   // NOTE: If you encounter a crash from this point forward
+   // while setting a shader constant its probably because the
+   // mConstantLookup has bad shaders/constants in it.
+   //
+   // This is a known crash bug that can occur if materials/shaders
+   // are reloaded and the light manager is not reset.
+   //
+   // We should look to fix this by clearing the table.
+
+   MatrixSet matSet = state->getRenderPass()->getMatrixSet();
+
+   // Update the forward shading light constants.
+   _update4ProbeConsts( sgData,
+      matSet,
+      psc->mProbePositionSC,
+      psc->mProbeRadiusSC,
+      psc->mProbeBoxMinSC,
+      psc->mProbeBoxMaxSC,
+      psc->mProbeCubemapSC,
+      psc->mProbeIsSphereSC,
+      psc->mProbeLocalPosSC,
+      shaderConsts );
+
+   // Static
+   /*if (lsm && light->getCastShadows())
+   {
+      if (psc->mWorldToLightProjSC->isValid())
+         shaderConsts->set(psc->mWorldToLightProjSC,
+            lsm->getWorldToLightProj(),
+            psc->mWorldToLightProjSC->getType());
+
+      if (psc->mViewToLightProjSC->isValid())
+      {
+         // TODO: Should probably cache these results and
+         // not do this mul here on every material that needs
+         // this transform.
+
+         shaderConsts->set(psc->mViewToLightProjSC,
+            lsm->getWorldToLightProj() * state->getCameraTransform(),
+            psc->mViewToLightProjSC->getType());
+      }
+
+      shaderConsts->setSafe(psc->mShadowMapSizeSC, 1.0f / (F32)lsm->getTexSize());
+
+      // Do this last so that overrides can properly override parameters previously set
+      lsm->setShaderParameters(shaderConsts, psc);
+   }
+   else
+   {
+      if (psc->mViewToLightProjSC->isValid())
+      {
+         // TODO: Should probably cache these results and
+         // not do this mul here on every material that needs
+         // this transform.
+         MatrixF proj;
+         light->getWorldToLightProj(&proj);
+
+         shaderConsts->set(psc->mViewToLightProjSC,
+            proj * state->getCameraTransform(),
+            psc->mViewToLightProjSC->getType());
+      }
+   }
+
+   // Dynamic
+   if (dynamicShadowMap)
+   {
+      if (psc->mDynamicWorldToLightProjSC->isValid())
+         shaderConsts->set(psc->mDynamicWorldToLightProjSC,
+            dynamicShadowMap->getWorldToLightProj(),
+            psc->mDynamicWorldToLightProjSC->getType());
+
+      if (psc->mDynamicViewToLightProjSC->isValid())
+      {
+         // TODO: Should probably cache these results and
+         // not do this mul here on every material that needs
+         // this transform.
+
+         shaderConsts->set(psc->mDynamicViewToLightProjSC,
+            dynamicShadowMap->getWorldToLightProj() * state->getCameraTransform(),
+            psc->mDynamicViewToLightProjSC->getType());
+      }
+
+      shaderConsts->setSafe(psc->mShadowMapSizeSC, 1.0f / (F32)dynamicShadowMap->getTexSize());
+
+      // Do this last so that overrides can properly override parameters previously set
+      dynamicShadowMap->setShaderParameters(shaderConsts, psc);
+   }
+   else
+   {
+      if (psc->mDynamicViewToLightProjSC->isValid())
+      {
+         // TODO: Should probably cache these results and
+         // not do this mul here on every material that needs
+         // this transform.
+         MatrixF proj;
+         light->getWorldToLightProj(&proj);
+
+         shaderConsts->set(psc->mDynamicViewToLightProjSC,
+            proj * state->getCameraTransform(),
+            psc->mDynamicViewToLightProjSC->getType());
+      }
+   }*/
+}
+
+/// Allows us to set textures during the Material::setTextureStage call, return true if we've done work.
+bool ProbeManager::setTextureStage(const SceneData &sgData,
+   const U32 currTexFlag,
+   const U32 textureSlot,
+   GFXShaderConstBuffer *shaderConsts,
+   ShaderConstHandles *handles)
+{
+   return false;
+}
+
+AvailableSLInterfaces* ProbeManager::getSceneLightingInterface()
+{
+   //if ( !mAvailableSLInterfaces )
+   //   mAvailableSLInterfaces = new AvailableSLInterfaces();
+
+   return NULL;
+}
+
+/*bool ProbeManager::lightScene( const char* callback, const char* param )
+{
+   BitSet32 flags = 0;
+
+   if ( param )
+   {
+      if ( !dStricmp( param, "forceAlways" ) )
+         flags.set( SceneLighting::ForceAlways );
+      else if ( !dStricmp(param, "forceWritable" ) )
+         flags.set( SceneLighting::ForceWritable );
+      else if ( !dStricmp(param, "loadOnly" ) )
+         flags.set( SceneLighting::LoadOnly );
+   }
+
+   // The SceneLighting object will delete itself 
+   // once the lighting process is complete.   
+   SceneLighting* sl = new SceneLighting( getSceneLightingInterface() );
+   return sl->lightScene( callback, flags );
+}*/
+
+/*RenderDeferredMgr* ProbeManager::_findDeferredRenderBin()
+{
+   RenderPassManager* rpm = getSceneManager()->getDefaultRenderPass();
+   for( U32 i = 0; i < rpm->getManagerCount(); i++ )
+   {
+      RenderBinManager *bin = rpm->getManager( i );
+      if( bin->getRenderInstType() == RenderDeferredMgr::RIT_Deferred )
+      {
+         return ( RenderDeferredMgr* ) bin;
+      }
+   }
+
+   return NULL;
+}*/
+
+DefineEngineFunction( CreateProbeManager, bool, (),,
+   "Finds and activates the named light manager.\n"
+   "@return Returns true if the light manager is found and activated.\n"
+   "@ingroup Lighting\n" )
+{
+   ProbeManager* probeManager = new ProbeManager();
+   
+   if (probeManager != nullptr && gClientSceneGraph != nullptr)
+   {
+      probeManager->activate(gClientSceneGraph);
+      return true;
+   }
+
+   return false;
+}
+
+DefineEngineFunction( resetProbeManager, void, (),,
+   "@brief Deactivates and then activates the currently active light manager."
+   "This causes most shaders to be regenerated and is often used when global "
+   "rendering changes have occured.\n"
+   "@ingroup Lighting\n" )
+{
+   ProbeManager *pm = PROBEMGR;
+   if ( !pm)
+      return;
+
+   /*SceneManager *sm = lm->getSceneManager();
+   lm->deactivate();
+   lm->activate( sm );*/
+}