Disable reflection probes when rendering reflections (no multiple bounces)

Source/RenderBeast/Include/BsLightRendering.h

@@ -130,8 +130,8 @@ namespace bs { namespace ct
 	};
 
 	/** Shader that performs a lighting pass over data stored in the Gbuffer. */
-	template<int MSAA_COUNT>
-	class TTiledDeferredLightingMat : public ITiledDeferredLightingMat, public RendererMaterial<TTiledDeferredLightingMat<MSAA_COUNT>>
+	template<int MSAA_COUNT, bool FixedReflColor>
+	class TTiledDeferredLightingMat : public ITiledDeferredLightingMat, public RendererMaterial<TTiledDeferredLightingMat<MSAA_COUNT, FixedReflColor>>
 	{
 		RMAT_DEF("TiledDeferredLighting.bsl");
 
@@ -147,6 +147,26 @@ namespace bs { namespace ct
 		TiledDeferredLighting mInternal;
 	};
 
+    /** Contains instances for all types of tile deferred lighting materials. */
+    class TiledDeferredLightingMaterials
+    {
+    public:
+        TiledDeferredLightingMaterials();
+        ~TiledDeferredLightingMaterials();
+
+        /**
+         * Returns a version of the tile-deferred lighting material that matches the parameters.
+         * 
+         * @param[in]   msaa                Number of samples per pixel.
+         * @param[in]   fixedReflColor      If true reflection probes will not be evaluated and instead a fixed color will
+         *                                  be returned instead. Useful when rendering reflection probes.
+         */
+        ITiledDeferredLightingMat* get(UINT32 msaa, bool fixedReflColor);
+
+    private:
+        ITiledDeferredLightingMat* mInstances[8];
+    };
+
 	BS_PARAM_BLOCK_BEGIN(FlatFramebufferToTextureParamDef)
 		BS_PARAM_BLOCK_ENTRY(Vector2I, gFramebufferSize)
 		BS_PARAM_BLOCK_ENTRY(INT32, gSampleCount)

Source/RenderBeast/Include/BsRenderBeast.h

@@ -246,7 +246,7 @@ namespace bs
 		SPtr<RenderBeastOptions> mCoreOptions;
 
 		DefaultMaterial* mDefaultMaterial;
-		ITiledDeferredLightingMat* mTiledDeferredLightingMats[4];
+        TiledDeferredLightingMaterials* mTiledDeferredLightingMats;
 		FlatFramebufferToTextureMat* mFlatFramebufferToTextureMat;
 		SkyboxMat<false>* mSkyboxMat;
 		SkyboxMat<true>* mSkyboxSolidColorMat;

Source/RenderBeast/Include/BsRendererCamera.h

@@ -95,6 +95,7 @@ namespace bs { namespace ct
 		bool noLighting : 1;
 		bool triggerCallbacks : 1;
 		bool runPostProcessing : 1;
+        bool renderingReflections : 1;
 
 		UINT64 visibleLayers;
 		ConvexVolume cullFrustum;
@@ -177,6 +178,9 @@ namespace bs { namespace ct
 		/** Returns the number of samples per pixel to render. */
 		UINT32 getNumSamples() const { return mViewDesc.target.numSamples; }
 
+        /** Returns true if the current view is being used to render reflection probes. */
+        bool isRenderingReflections() const { return mViewDesc.renderingReflections; }
+
 		/** Returns the scene camera this object is based of. This can be null for manually constructed renderer cameras. */
 		const Camera* getSceneCamera() const { return mViewDesc.sceneCamera; }
 

Source/RenderBeast/Source/BsLightRendering.cpp

@@ -10,6 +10,7 @@
 #include "BsGpuBuffer.h"
 #include "BsLight.h"
 #include "BsRendererUtility.h"
+#include "BsReflectionProbeSampling.h"
 
 namespace bs { namespace ct
 {
@@ -311,37 +312,88 @@ namespace bs { namespace ct
 		return texture;
 	}
 
-	template<int MSAA_COUNT>
-	TTiledDeferredLightingMat<MSAA_COUNT>::TTiledDeferredLightingMat()
+	template<int MSAA_COUNT, bool FixedReflColor>
+	TTiledDeferredLightingMat<MSAA_COUNT, FixedReflColor>::TTiledDeferredLightingMat()
 		:mInternal(mMaterial, mParamsSet, MSAA_COUNT)
 	{
 
 	}
 
-	template<int MSAA_COUNT>
-	void TTiledDeferredLightingMat<MSAA_COUNT>::_initDefines(ShaderDefines& defines)
+	template<int MSAA_COUNT, bool FixedReflColor>
+	void TTiledDeferredLightingMat<MSAA_COUNT, FixedReflColor>::_initDefines(ShaderDefines& defines)
 	{
 		defines.set("TILE_SIZE", TiledDeferredLighting::TILE_SIZE);
 		defines.set("MSAA_COUNT", MSAA_COUNT);
+        defines.set("FIXED_REFLECTION_COLOR", FixedReflColor);
 	}
 
-	template<int MSAA_COUNT>
-	void TTiledDeferredLightingMat<MSAA_COUNT>::execute(const SPtr<RenderTargets>& gbuffer,
+	template<int MSAA_COUNT, bool FixedReflColor>
+	void TTiledDeferredLightingMat<MSAA_COUNT, FixedReflColor>::execute(const SPtr<RenderTargets>& gbuffer,
 													const SPtr<GpuParamBlockBuffer>& perCamera, bool noLighting)
 	{
 		mInternal.execute(gbuffer, perCamera, noLighting);
 	}
 
-	template<int MSAA_COUNT>
-	void TTiledDeferredLightingMat<MSAA_COUNT>::setLights(const GPULightData& lightData)
+	template<int MSAA_COUNT, bool FixedReflColor>
+	void TTiledDeferredLightingMat<MSAA_COUNT, FixedReflColor>::setLights(const GPULightData& lightData)
 	{
 		mInternal.setLights(lightData);
 	}
 
-	template class TTiledDeferredLightingMat<1>;
-	template class TTiledDeferredLightingMat<2>;
-	template class TTiledDeferredLightingMat<4>;
-	template class TTiledDeferredLightingMat<8>;
+	template class TTiledDeferredLightingMat<1, false>;
+	template class TTiledDeferredLightingMat<2, false>;
+	template class TTiledDeferredLightingMat<4, false>;
+	template class TTiledDeferredLightingMat<8, false>;
+
+    template class TTiledDeferredLightingMat<1, true>;
+    template class TTiledDeferredLightingMat<2, true>;
+    template class TTiledDeferredLightingMat<4, true>;
+    template class TTiledDeferredLightingMat<8, true>;
+
+    TiledDeferredLightingMaterials::TiledDeferredLightingMaterials()
+    {
+        mInstances[0] = bs_new<TTiledDeferredLightingMat<1, false>>();
+        mInstances[1] = bs_new<TTiledDeferredLightingMat<2, false>>();
+        mInstances[2] = bs_new<TTiledDeferredLightingMat<4, false>>();
+        mInstances[3] = bs_new<TTiledDeferredLightingMat<8, false>>();
+
+        mInstances[4] = bs_new<TTiledDeferredLightingMat<1, true>>();
+        mInstances[5] = bs_new<TTiledDeferredLightingMat<2, true>>();
+        mInstances[6] = bs_new<TTiledDeferredLightingMat<4, true>>();
+        mInstances[7] = bs_new<TTiledDeferredLightingMat<8, true>>();
+    }
+
+    TiledDeferredLightingMaterials::~TiledDeferredLightingMaterials()
+    {
+        for (UINT32 i = 0; i < 8; i++)
+            bs_delete(mInstances[i]);
+    }
+
+    ITiledDeferredLightingMat* TiledDeferredLightingMaterials::get(UINT32 msaa, bool fixedReflColor)
+    {
+        if(!fixedReflColor)
+        {
+            if (msaa == 1)
+                return mInstances[0];
+            else if (msaa == 2)
+                return mInstances[1];
+            else if (msaa == 4)
+                return mInstances[2];
+            else
+                return mInstances[3];
+        }
+        else
+        {
+            if (msaa == 1)
+                return mInstances[4];
+            else if (msaa == 2)
+                return mInstances[5];
+            else if (msaa == 4)
+                return mInstances[6];
+            else
+                return mInstances[7];
+        }
+    }
 
 	FlatFramebufferToTextureParamDef gFlatFramebufferToTextureParamDef;
 

Source/RenderBeast/Source/BsRenderBeast.cpp

@@ -92,10 +92,7 @@ namespace bs { namespace ct
 		mSkyboxSolidColorMat = bs_new<SkyboxMat<true>>();
 		mFlatFramebufferToTextureMat = bs_new<FlatFramebufferToTextureMat>();
 
-		mTiledDeferredLightingMats[0] = bs_new<TTiledDeferredLightingMat<1>>();
-		mTiledDeferredLightingMats[1] = bs_new<TTiledDeferredLightingMat<2>>();
-		mTiledDeferredLightingMats[2] = bs_new<TTiledDeferredLightingMat<4>>();
-		mTiledDeferredLightingMats[3] = bs_new<TTiledDeferredLightingMat<8>>();
+		mTiledDeferredLightingMats = bs_new<TiledDeferredLightingMaterials>();
 
 		mGPULightData = bs_new<GPULightData>();
 		mGPUReflProbeData = bs_new<GPUReflProbeData>();
@@ -135,10 +132,7 @@ namespace bs { namespace ct
 		bs_delete(mGPUReflProbeData);
 		bs_delete(mLightGrid);
 		bs_delete(mFlatFramebufferToTextureMat);
-
-		UINT32 numDeferredMats = sizeof(mTiledDeferredLightingMats) / sizeof(mTiledDeferredLightingMats[0]);
-		for (UINT32 i = 0; i < numDeferredMats; i++)
-			bs_delete(mTiledDeferredLightingMats[i]);
+		bs_delete(mTiledDeferredLightingMats);
 
 		RendererUtility::shutDown();
 
@@ -640,6 +634,7 @@ namespace bs { namespace ct
 			viewDesc.noLighting = camera->getFlags().isSet(CameraFlag::NoLighting);
 			viewDesc.triggerCallbacks = true;
 			viewDesc.runPostProcessing = true;
+            viewDesc.renderingReflections = false;
 
 			viewDesc.cullFrustum = camera->getWorldFrustum();
 			viewDesc.visibleLayers = camera->getLayers();
@@ -1033,25 +1028,8 @@ namespace bs { namespace ct
 		rapi.setRenderTarget(nullptr);
 
 		// Render light pass
-		ITiledDeferredLightingMat* lightingMat;
-
-		UINT32 numSamples = viewInfo->getNumSamples();
-		switch(numSamples)
-		{
-		case 0:
-		case 1:
-			lightingMat = mTiledDeferredLightingMats[0]; // No MSAA
-			break;
-		case 2:
-			lightingMat = mTiledDeferredLightingMats[1]; // 2X MSAA
-			break;
-		case 4:
-			lightingMat = mTiledDeferredLightingMats[2]; // 4X MSAA
-			break;
-		default:
-			lightingMat = mTiledDeferredLightingMats[3]; // 8X MSAA or higher
-			break;
-		}
+        UINT32 numSamples = viewInfo->getNumSamples();
+		ITiledDeferredLightingMat* lightingMat = mTiledDeferredLightingMats->get(numSamples, viewInfo->isRenderingReflections());
 
 		lightingMat->setLights(*mGPULightData);
 		lightingMat->execute(renderTargets, perCameraBuffer, viewInfo->renderWithNoLighting());
@@ -1422,6 +1400,7 @@ namespace bs { namespace ct
 		viewDesc.noLighting = false;
 		viewDesc.triggerCallbacks = false;
 		viewDesc.runPostProcessing = false;
+        viewDesc.renderingReflections = true;
 
 		viewDesc.visibleLayers = 0xFFFFFFFFFFFFFFFF;
 		viewDesc.nearPlane = 0.5f;