Refactor: Modified the renderer so it can work without texture view support (not present on earlier OpenGL versions)

Data/Raw/Engine/Shaders/PPBuildHiZ.bsl

@@ -3,15 +3,44 @@
 technique PPBuildHiZ
 {
 	mixin PPBase;
-
+	
 	code
 	{	
+		#define NO_TEXTURE_VIEWS 0
+			
+		#ifdef OPENGL 
+		#ifdef __VERSION__
+			#if __VERSION__ < 430
+				#define NO_TEXTURE_VIEWS 1
+			#endif
+		#endif
+		#endif
+	
 		SamplerState gDepthSamp;
 		Texture2D gDepthTex;
 		
+		// Older OpenGL versions don't support views, meaning we need to specify mip level explicitly
+#if NO_TEXTURE_VIEWS
+		[internal]
+		cbuffer Input
+		{
+			float2 gHalfPixelOffset;
+			int gMipLevel;
+		}
+#endif
+		
 		float fsmain(VStoFS input) : SV_Target0
 		{
+#if NO_TEXTURE_VIEWS 	
+			float4 depth;
+			depth.x = gDepthTex.Sample(gDepthSamp, input.uv0, int2(1, 1));
+			depth.y = gDepthTex.Sample(gDepthSamp, input.uv0, int2(-1, 1));
+			depth.z = gDepthTex.Sample(gDepthSamp, input.uv0, int2(1, -1));
+			depth.w = gDepthTex.Sample(gDepthSamp, input.uv0, int2(-1, -1));
+#else
 			float4 depth = gDepthTex.Gather(gDepthSamp, input.uv0);
+#endif
+			
 			return min(min(depth.x, depth.y), min(depth.z, depth.w));
 		}	
 	};

Data/Raw/Engine/Shaders/ReflectionCubeDownsample.bsl

@@ -12,6 +12,7 @@ technique ReflectionCubeDownsample
 		cbuffer Input
 		{
 			int gCubeFace;
+			int gMipLevel;
 		}	
 	
 		SamplerState gInputSamp;
@@ -22,7 +23,7 @@ technique ReflectionCubeDownsample
 			float2 scaledUV = input.uv0 * 2.0f - 1.0f;
 			float3 dir = getDirFromCubeFace(gCubeFace, scaledUV);
 			
-			return gInputTex.Sample(gInputSamp, dir);
+			return gInputTex.SampleLevel(gInputSamp, dir, gMipLevel);
 		}	
 	};
 };

Data/Raw/Engine/Shaders/ShadowProject.bsl

@@ -24,7 +24,7 @@ technique ShadowProject
 		writemask = 0x7F;
 	};
 	
-	#ifdef FADE_PLANE
+	#ifdef CASCADING
 	blend
 	{
 		target
@@ -48,7 +48,12 @@ technique ShadowProject
 	
 	code
 	{
+		#if CASCADING
+		Texture2DArray gShadowTex;
+		#else
 		Texture2D gShadowTex;
+		#endif
+		
 		SamplerState gShadowSampler;
 	
 		[internal]
@@ -64,6 +69,8 @@ technique ShadowProject
 			
 			float gFadePlaneDepth;
 			float gInvFadePlaneRange;
+			
+			float gFace;
 		};
 		
 		// Converts a set of shadow depths into occlusion values, where 1 means scene object is occluded and 0
@@ -95,15 +102,25 @@ technique ShadowProject
 		
 		float PCF1x1(float2 uv, float sceneDepth)
 		{
-			float depthSample = gShadowTex.Sample(gShadowSampler, uv).r;
+			#if CASCADING
+			float3 sampleCenter = float3(uv, gFace);
+			#else
+			float2 sampleCenter = uv;
+			#endif
+			
+			float depthSample = gShadowTex.Sample(gShadowSampler, sampleCenter).r;
 			return getOcclusion(depthSample.rrrr, sceneDepth).r;
 		}
 	
 		float PCF2x2(float2 uv, float sceneDepth)
 		{
 			float2 fraction;
+			#if CASCADING
+			float3 sampleCenter = float3(getFilteringInfo(uv, fraction), gFace);
+			#else
 			float2 sampleCenter = getFilteringInfo(uv, fraction);
-						
+			#endif			
+				
 			// Gather four samples. Samples are returned in counter-clockwise order, starting with lower left
 			float4 depthSamples = gShadowTex.GatherRed(gShadowSampler, sampleCenter);
 			
@@ -118,7 +135,11 @@ technique ShadowProject
 		float PCF4x4(float2 uv, float sceneDepth)
 		{
 			float2 fraction;
+			#if CASCADING
+			float3 sampleCenter = float3(getFilteringInfo(uv, fraction), gFace);
+			#else
 			float2 sampleCenter = getFilteringInfo(uv, fraction);
+			#endif	
 							
 			// Gather 16 samples in four 2x2 gathers. Samples are returned in counter-clockwise order, starting with lower left.
 			// Gathers are performed in clockwise order, starting with top left block.
@@ -187,7 +208,11 @@ technique ShadowProject
 		float PCF6x6(float2 uv, float sceneDepth)
 		{
 			float2 fraction;
+			#if CASCADING
+			float3 sampleCenter = float3(getFilteringInfo(uv, fraction), gFace);
+			#else
 			float2 sampleCenter = getFilteringInfo(uv, fraction);
+			#endif	
 							
 			// Gather 36 samples in nine 2x2 gathers. Gathers are performed in clockwise order, starting with top left block.
 			// Every three gathers (one row), the values are accumulated to their corresponding row.
@@ -249,7 +274,7 @@ technique ShadowProject
 			#endif
 			
 			float alpha = 1.0f;
-			#ifdef FADE_PLANE
+			#ifdef CASCADING
 				alpha = 1.0f - saturate((-depth - gFadePlaneDepth) * gInvFadePlaneRange);
 			#endif
 

Source/BansheeCore/RenderAPI/BsGpuBuffer.h

@@ -100,8 +100,8 @@ namespace bs
 	 * @note	Sim thread only.
 	 */
 	class BS_CORE_EXPORT GpuBuffer : public CoreObject
-    {
-    public:
+	{
+	public:
 		virtual ~GpuBuffer() { }
 
 		/** Returns properties describing the buffer. */
@@ -125,7 +125,7 @@ namespace bs
 		SPtr<ct::CoreObject> createCore() const override;
 
 		GpuBufferProperties mProperties;
-    };
+	};
 
 	/** @} */
 

Source/BansheeCore/RenderAPI/BsRenderAPI.h

@@ -192,7 +192,17 @@ namespace bs
 		 */
 		MultiThreadedCB			= 1 << 4,
 		/** If set, the render API supports unordered stores to a texture with more than one sample. */
-		MSAAImageStores			= 1 << 5
+		MSAAImageStores			= 1 << 5,
+		/** 
+		 * If set, the render API supports binds of parts of a texture (e.g. a single mip level, or a single element of a
+		 * texture array). This only applies to texture reads and individual mip levels or layers can still be bound as
+		 * render texture targets regardless of this flag.
+		 */
+		TextureViews			= 1 << 6,
+		/** If set, the render API supports compute shaders. */
+		Compute					= 1 << 7,
+		/** If set, the render API supports load-store textures or buffers (AKA unordered access (UAV). */
+		LoadStore				= 1 << 8
 	};
 
 	typedef Flags<RenderAPIFeatureFlag> RenderAPIFeatures;

Source/BansheeD3D11RenderAPI/BsD3D11RenderAPI.cpp

@@ -1362,7 +1362,12 @@ namespace bs { namespace ct
 
 	const RenderAPIInfo& D3D11RenderAPI::getAPIInfo() const
 	{
-		static RenderAPIInfo info(0.0f, 0.0f, 0.0f, 1.0f, VET_COLOR_ABGR, RenderAPIFeatures());
+		RenderAPIFeatures featureFlags =
+			RenderAPIFeatureFlag::TextureViews |
+			RenderAPIFeatureFlag::Compute | 
+			RenderAPIFeatureFlag::LoadStore;
+
+		static RenderAPIInfo info(0.0f, 0.0f, 0.0f, 1.0f, VET_COLOR_ABGR, featureFlags);
 
 		return info;
 	}

Source/BansheeGLRenderAPI/BsGLRenderAPI.cpp

@@ -2733,10 +2733,21 @@ namespace bs { namespace ct
 
 	const RenderAPIInfo& GLRenderAPI::getAPIInfo() const
 	{
-		static RenderAPIInfo info(0.0f, 0.0f, -1.0f, 1.0f, VET_COLOR_ABGR,
-								  RenderAPIFeatureFlag::UVYAxisUp |
-								  RenderAPIFeatureFlag::ColumnMajorMatrices |
-								  RenderAPIFeatureFlag::MSAAImageStores);
+		RenderAPIFeatures featureFlags =
+			RenderAPIFeatureFlag::UVYAxisUp |
+			RenderAPIFeatureFlag::ColumnMajorMatrices |
+			RenderAPIFeatureFlag::MSAAImageStores;
+
+#if BS_OPENGL_4_3 || BS_OPENGLES_3_1
+		featureFlags |= RenderAPIFeatureFlag::TextureViews;
+		featureFlags |= RenderAPIFeatureFlag::Compute;
+#endif
+
+#if BS_OPENGL_4_2 || BS_OPENGLES_3_1
+		featureFlags |= RenderAPIFeatureFlag::LoadStore;
+#endif
+
+		static RenderAPIInfo info(0.0f, 0.0f, -1.0f, 1.0f, VET_COLOR_ABGR, featureFlags);
 								  
 		return info;
 	}

Source/BansheeGLRenderAPI/GLSL/BsGLSLGpuProgram.cpp

@@ -70,16 +70,17 @@ namespace bs { namespace ct
 
 	void GLSLGpuProgram::initialize()
 	{
+
 #if BS_OPENGL_4_5
-		static const char* VERSION_LINE = "#version 450\n";
+		static const char* VERSION_CHARS = "450";
 #elif BS_OPENGL_4_4
-		static const char* VERSION_LINE = "#version 440\n";
+		static const char* VERSION_CHARS = "440";
 #elif BS_OPENGL_4_3
-		static const char* VERSION_LINE = "#version 430\n";
+		static const char* VERSION_CHARS = "430";
 #elif BS_OPENGL_4_2
-		static const char* VERSION_LINE = "#version 420\n";
+		static const char* VERSION_CHARS = "420";
 #else
-		static const char* VERSION_LINE = "#version 410\n";
+		static const char* VERSION_CHARS = "410";
 #endif
 		
 		if (!isSupported())
@@ -136,7 +137,7 @@ namespace bs { namespace ct
 			UINT32 versionStrLen = (UINT32)strlen(versionStr);
 
 			UINT32 lineLength = 0;
-			INT32 versionLine = -1;
+			INT32 versionLineNum = -1;
 			for (UINT32 i = 0; i < source.size(); i++)
 			{
 				if (source[i] == '\n' || source[i] == '\r')
@@ -149,7 +150,7 @@ namespace bs { namespace ct
 					lineData[lineLength] = '\n';
 					lineData[lineLength + 1] = '\0';
 
-					if(versionLine == -1 && lineLength >= versionStrLen)
+					if(versionLineNum == -1 && lineLength >= versionStrLen)
 					{
 						bool isEqual = true;
 						for (UINT32 j = 0; j < versionStrLen; ++j)
@@ -162,7 +163,7 @@ namespace bs { namespace ct
 						}
 
 						if (isEqual)
-							versionLine = (INT32)lines.size();
+							versionLineNum = (INT32)lines.size();
 					}
 
 					lines.push_back(lineData);
@@ -188,20 +189,35 @@ namespace bs { namespace ct
 			}
 
 			int numInsertedLines = 0;
-			if(versionLine == -1)
+			if(versionLineNum == -1)
 			{
-				UINT32 length = (UINT32)strlen(VERSION_LINE) + 1;
+				char versionLine[50];
+				strcpy(versionLine, "#version ");
+				strcat(versionLine, VERSION_CHARS);
+				strcat(versionLine, "\n");
+
+				UINT32 length = (UINT32)strlen(versionLine) + 1;
 
 				GLchar* extraLineData = (GLchar*)bs_stack_alloc(length);
-				memcpy(extraLineData, VERSION_LINE, length);
+				memcpy(extraLineData, versionLine, length);
 
 				lines.insert(lines.begin(), extraLineData);
 				numInsertedLines++;
 			}
 
-			static const char* EXTRA_LINES[] = { "#define OPENGL\n" };
+			char versionDefine[50];
+			strcpy(versionDefine, "#define OPENGL");
+			strcat(versionDefine, VERSION_CHARS);
+			strcat(versionDefine, "\n");
+
+			static const char* EXTRA_LINES[] = 
+				{ 
+					"#define OPENGL\n",
+					versionDefine
+				};
+
 			UINT32 numExtraLines = sizeof(EXTRA_LINES) / sizeof(EXTRA_LINES[0]);
-			UINT32 extraLineOffset = versionLine != -1 ? versionLine + 1 : 0;
+			UINT32 extraLineOffset = versionLineNum != -1 ? versionLineNum + 1 : 0;
 			for (UINT32 i = 0; i < numExtraLines; i++)
 			{
 				UINT32 length = (UINT32)strlen(EXTRA_LINES[i]) + 1;

Source/BansheeVulkanRenderAPI/BsVulkanRenderAPI.cpp

@@ -283,7 +283,7 @@ namespace bs { namespace ct
 		RenderAPI::initialize();
 	}
 
-    void VulkanRenderAPI::destroyCore()
+	void VulkanRenderAPI::destroyCore()
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
@@ -566,12 +566,16 @@ namespace bs { namespace ct
 
 	const RenderAPIInfo& VulkanRenderAPI::getAPIInfo() const
 	{
-		static RenderAPIInfo info(0.0f, 0.0f, 0.0f, 1.0f, VET_COLOR_ABGR, 
-								  RenderAPIFeatureFlag::NDCYAxisDown |
-								  RenderAPIFeatureFlag::ColumnMajorMatrices |
-								  RenderAPIFeatureFlag::MultiThreadedCB |
-								  RenderAPIFeatureFlag::MSAAImageStores);
+		RenderAPIFeatures featureFlags =
+			RenderAPIFeatureFlag::NDCYAxisDown |
+			RenderAPIFeatureFlag::ColumnMajorMatrices |
+			RenderAPIFeatureFlag::MultiThreadedCB |
+			RenderAPIFeatureFlag::MSAAImageStores |
+			RenderAPIFeatureFlag::TextureViews |
+			RenderAPIFeatureFlag::Compute |
+			RenderAPIFeatureFlag::LoadStore;
 
+		static RenderAPIInfo info(0.0f, 0.0f, 0.0f, 1.0f, VET_COLOR_ABGR, featureFlags);
 		return info;
 	}
 

Source/RenderBeast/BsPostProcessing.cpp

@@ -9,7 +9,7 @@
 #include "BsRendererView.h"
 #include "Image/BsPixelUtil.h"
 #include "Utility/BsBitwise.h"
-#include "Resources/BsBuiltinResourcesHelper.h"
+#include "BsRenderBeast.h"
 
 namespace bs { namespace ct
 {
@@ -964,10 +964,28 @@ namespace bs { namespace ct
 			return get(VAR_NoNear_Far);
 	}
 
+	BuildHiZFParamDef gBuildHiZParamDef;
+
 	BuildHiZMat::BuildHiZMat()
 	{
 		SPtr<GpuParams> gpuParams = mParamsSet->getGpuParams();
 		gpuParams->getTextureParam(GPT_FRAGMENT_PROGRAM, "gDepthTex", mInputTexture);
+
+		// If no texture view support, we must manually pick a valid mip level in the shader
+		const RenderAPIInfo& rapiInfo = RenderAPI::instance().getAPIInfo();
+		if(!rapiInfo.isFlagSet(RenderAPIFeatureFlag::TextureViews))
+		{
+			mParamBuffer = gBuildHiZParamDef.createBuffer();
+
+			SAMPLER_STATE_DESC inputSampDesc;
+			inputSampDesc.minFilter = FO_POINT;
+			inputSampDesc.magFilter = FO_POINT;
+			inputSampDesc.mipFilter = FO_POINT;
+
+			SPtr<SamplerState> inputSampState = SamplerState::create(inputSampDesc);
+			if(gpuParams->hasSamplerState(GPT_FRAGMENT_PROGRAM, "gDepthSamp"))
+				gpuParams->setSamplerState(GPT_FRAGMENT_PROGRAM, "gDepthSamp", inputSampState);
+		}
 	}
 
 	void BuildHiZMat::_initVariations(ShaderVariations& variations)
@@ -980,7 +998,24 @@ namespace bs { namespace ct
 	{
 		RenderAPI& rapi = RenderAPI::instance();
 
-		mInputTexture.set(source, TextureSurface(srcMip));
+		// If no texture view support, we must manually pick a valid mip level in the shader
+		const RenderAPIInfo& rapiInfo = RenderAPI::instance().getAPIInfo();
+		if(rapiInfo.isFlagSet(RenderAPIFeatureFlag::TextureViews))
+			mInputTexture.set(source, TextureSurface(srcMip));
+		else
+		{
+			mInputTexture.set(source);
+
+			auto& props = source->getProperties();
+			float pixelWidth = (float)props.getWidth();
+			float pixelHeight = (float)props.getHeight();
+
+			Vector2 halfPixelOffset(0.5f / pixelWidth, 0.5f / pixelHeight);
+
+			gBuildHiZParamDef.gHalfPixelOffset.set(mParamBuffer, halfPixelOffset);
+			gBuildHiZParamDef.gMipLevel.set(mParamBuffer, srcMip);
+		}
+
 		rapi.setRenderTarget(output);
 		rapi.setViewport(dstRect);
 

Source/RenderBeast/BsPostProcessing.h

@@ -395,6 +395,13 @@ namespace bs { namespace ct
 		static ShaderVariation VAR_Near_NoFar;
 	};
 
+	BS_PARAM_BLOCK_BEGIN(BuildHiZFParamDef)
+		BS_PARAM_BLOCK_ENTRY(Vector2, gHalfPixelOffset)
+		BS_PARAM_BLOCK_ENTRY(int, gMipLevel)
+	BS_PARAM_BLOCK_END
+
+	extern BuildHiZFParamDef sBuildHiZFParamDef;
+
 	/** Shader that calculates a single level of the hierarchical Z mipmap chain. */
 	class BuildHiZMat : public RendererMaterial<BuildHiZMat>
 	{
@@ -417,6 +424,7 @@ namespace bs { namespace ct
 			const SPtr<RenderTexture>& output);
 	private:
 		GpuParamTexture mInputTexture;
+		SPtr<GpuParamBlockBuffer> mParamBuffer;
 	};
 
 	BS_PARAM_BLOCK_BEGIN(FXAAParamDef)

Source/RenderBeast/BsRenderBeast.cpp

@@ -30,6 +30,7 @@
 #include "BsRenderCompositor.h"
 #include "BsRendererTextures.h"
 #include "BsRenderBeastIBLUtility.h"
+#include "Renderer/BsRendererManager.h"
 
 using namespace std::placeholders;
 
@@ -63,6 +64,17 @@ namespace bs { namespace ct
 
 	void RenderBeast::initializeCore()
 	{
+		const RenderAPI& rapi = RenderAPI::instance();
+		const RenderAPIInfo& rapiInfo = rapi.getAPIInfo();
+
+		if(
+			!rapiInfo.isFlagSet(RenderAPIFeatureFlag::Compute) ||
+			!rapiInfo.isFlagSet(RenderAPIFeatureFlag::LoadStore) ||
+			!rapiInfo.isFlagSet(RenderAPIFeatureFlag::TextureViews))
+		{
+			mFeatureSet = RenderBeastFeatureSet::DesktopMacOS;
+		}
+
 		RendererUtility::startUp();
 		GpuResourcePool::startUp();
 		IBLUtility::startUp<RenderBeastIBLUtility>();
@@ -674,4 +686,9 @@ namespace bs { namespace ct
 		// Make sure the render texture is available for reads
 		RenderAPI::instance().setRenderTarget(nullptr);
 	}
+
+	SPtr<RenderBeast> gRenderBeast()
+	{
+		return std::static_pointer_cast<RenderBeast>(RendererManager::instance().getActive());
+	}
 }}

Source/RenderBeast/BsRenderBeast.h

@@ -72,6 +72,9 @@ namespace bs
 		/**	Returns current set of options used for controlling the rendering. */
 		SPtr<RendererOptions> getOptions() const override;
 
+		/** Returns the feature set the renderer is operating on. Core thread only. */
+		RenderBeastFeatureSet getFeatureSet() const { return mFeatureSet; }
+
 		/** @copydoc Renderer::initialize */
 		void initialize() override;
 
@@ -181,6 +184,7 @@ namespace bs
 		void updateReflProbeArray();
 
 		// Core thread only fields
+		RenderBeastFeatureSet mFeatureSet = RenderBeastFeatureSet::Desktop;
 
 		// Scene data
 		SPtr<RendererScene> mScene;
@@ -198,5 +202,8 @@ namespace bs
 		bool mOptionsDirty = true;
 	};
 
+	/**	Provides easy access to the RenderBeast renderer. */
+	SPtr<RenderBeast> gRenderBeast();
+
 	/** @} */
 }}

Source/RenderBeast/BsRenderBeastIBLUtility.cpp

@@ -24,11 +24,15 @@ namespace bs { namespace ct
 		// Do nothing
 	}
 
-	void ReflectionCubeDownsampleMat::execute(const SPtr<Texture>& source, UINT32 face, const TextureSurface& surface, 
-											 const SPtr<RenderTarget>& target)
+	void ReflectionCubeDownsampleMat::execute(
+		const SPtr<Texture>& source,
+		UINT32 face,
+		UINT32 mip,
+		const SPtr<RenderTarget>& target)
 	{
-		mInputTexture.set(source, surface);
+		mInputTexture.set(source);
 		gReflectionCubeDownsampleParamDef.gCubeFace.set(mParamBuffer, face);
+		gReflectionCubeDownsampleParamDef.gMipLevel.set(mParamBuffer, mip);
 
 		RenderAPI& rapi = RenderAPI::instance();
 		rapi.setRenderTarget(target);
@@ -438,9 +442,8 @@ namespace bs { namespace ct
 
 			SPtr<RenderTarget> target = RenderTexture::create(cubeFaceRTDesc);
 
-			TextureSurface sourceSurface(srcMip, 1, 0, 6);
 			ReflectionCubeDownsampleMat* material = ReflectionCubeDownsampleMat::get();
-			material->execute(src, face, sourceSurface, target);
+			material->execute(src, face, srcMip, target);
 		}
 	}
 }}

Source/RenderBeast/BsRenderBeastIBLUtility.h

@@ -15,6 +15,7 @@ namespace bs { namespace ct
 
 	BS_PARAM_BLOCK_BEGIN(ReflectionCubeDownsampleParamDef)
 		BS_PARAM_BLOCK_ENTRY(int, gCubeFace)
+		BS_PARAM_BLOCK_ENTRY(int, gMipLevel)
 	BS_PARAM_BLOCK_END
 
 	extern ReflectionCubeDownsampleParamDef gReflectionCubeDownsampleParamDef;
@@ -28,8 +29,7 @@ namespace bs { namespace ct
 		ReflectionCubeDownsampleMat();
 
 		/** Downsamples the provided texture face and outputs it to the provided target. */
-		void execute(const SPtr<Texture>& source, UINT32 face, const TextureSurface& surface, 
-					 const SPtr<RenderTarget>& target);
+		void execute(const SPtr<Texture>& source, UINT32 face, UINT32 mip, const SPtr<RenderTarget>& target);
 
 	private:
 		SPtr<GpuParamBlockBuffer> mParamBuffer;

Source/RenderBeast/BsRenderBeastPrerequisites.h

@@ -16,6 +16,19 @@
 
 namespace bs { namespace ct
 {
+	/**
+	 * Determines the feature set to be used by RenderBeast. Feature sets control the quality and type of rendering
+	 * effects depending on available hardware (For example a desktop computer can handle higher end rendering than a
+	 * mobile device).
+	 */
+	enum class RenderBeastFeatureSet
+	{
+		/** High end feature set utilizing the latest and greatest effects. */
+		Desktop,
+		/** Mid-range feature set optimized for macOS and its obsolete OpenGL 4.1 version. */
+		DesktopMacOS
+	};
+
 	class ObjectRenderer;
 	struct RenderBeastOptions;
 	struct PooledRenderTexture;

Source/RenderBeast/BsRendererView.cpp

@@ -51,7 +51,7 @@ namespace bs { namespace ct
 
 	void SkyboxMat::setParams(const SPtr<Texture>& texture, const Color& solidColor)
 	{
-		mSkyTextureParam.set(texture, TextureSurface(0, 1, 0, 0));
+		mSkyTextureParam.set(texture);
 
 		gSkyboxParamDef.gClearColor.set(mParamBuffer, solidColor);
 		mParamBuffer->flushToGPU();

Source/RenderBeast/BsShadowRendering.cpp

@@ -156,13 +156,13 @@ namespace bs { namespace ct
 #define VARIATION(QUALITY)																	\
 		ShaderVariation ShadowProjectMat::VAR_Q##QUALITY##_Dir_MSAA = ShaderVariation({		\
 			ShaderVariation::Param("SHADOW_QUALITY", QUALITY),								\
-			ShaderVariation::Param("FADE_PLANE", true),										\
+			ShaderVariation::Param("CASCADINGE", true),										\
 			ShaderVariation::Param("NEEDS_TRANSFORM", false),								\
 			ShaderVariation::Param("MSAA_COUNT", 2)											\
 		});																					\
 		ShaderVariation ShadowProjectMat::VAR_Q##QUALITY##_Dir_NoMSAA = ShaderVariation({	\
 			ShaderVariation::Param("SHADOW_QUALITY", QUALITY),								\
-			ShaderVariation::Param("FADE_PLANE", true),										\
+			ShaderVariation::Param("CASCADING", true),										\
 			ShaderVariation::Param("NEEDS_TRANSFORM", false),								\
 			ShaderVariation::Param("MSAA_COUNT", 1)											\
 		});																					\
@@ -231,12 +231,9 @@ namespace bs { namespace ct
 		Vector4 lightPosAndScale(Vector3(0.0f, 0.0f, 0.0f), 1.0f);
 		gShadowProjectVertParamsDef.gPositionAndScale.set(mVertParams, lightPosAndScale);
 
-		TextureSurface surface;
-		surface.face = params.shadowMapFace;
-
 		mGBufferParams.bind(params.gbuffer);
 
-		mShadowMapParam.set(params.shadowMap, surface);
+		mShadowMapParam.set(params.shadowMap);
 		mShadowSamplerParam.set(mSamplerState);
 
 		SPtr<GpuParams> gpuParams = mParamsSet->getGpuParams();
@@ -867,7 +864,7 @@ namespace bs { namespace ct
 				bool viewerInsideVolume = (tfrm.getPosition() - viewProps.viewOrigin).length() < lightRadius;
 
 				SPtr<Texture> shadowMap = mShadowCubemaps[shadowInfo.textureIdx].getTexture();
-				ShadowProjectParams shadowParams(*light, shadowMap, 0, shadowOmniParamBuffer, perViewBuffer, gbuffer);
+				ShadowProjectParams shadowParams(*light, shadowMap, shadowOmniParamBuffer, perViewBuffer, gbuffer);
 
 				ShadowProjectOmniMat* mat = ShadowProjectOmniMat::getVariation(effectiveShadowQuality, viewerInsideVolume, 
 					viewProps.numSamples > 1);
@@ -994,8 +991,8 @@ namespace bs { namespace ct
 					shadowMapFace = shadowInfo->cascadeIdx;
 				}
 
-				ShadowProjectParams shadowParams(*light, shadowMap, shadowMapFace, shadowParamBuffer, perViewBuffer, 
-					gbuffer);
+				gShadowProjectParamsDef.gFace.set(shadowParamBuffer, (float)shadowMapFace);
+				ShadowProjectParams shadowParams(*light, shadowMap, shadowParamBuffer, perViewBuffer, gbuffer);
 
 				ShadowProjectMat* mat = ShadowProjectMat::getVariation(effectiveShadowQuality, isCSM, viewProps.numSamples > 1);
 				mat->bind(shadowParams);

Source/RenderBeast/BsShadowRendering.h

@@ -131,11 +131,10 @@ namespace bs { namespace ct
 	/** Common parameters used by the shadow projection materials. */
 	struct ShadowProjectParams
 	{
-		ShadowProjectParams(const Light& light, const SPtr<Texture>& shadowMap, UINT32 shadowMapFace,
+		ShadowProjectParams(const Light& light, const SPtr<Texture>& shadowMap,
 			const SPtr<GpuParamBlockBuffer>& shadowParams, const SPtr<GpuParamBlockBuffer>& perCameraParams,
 			GBufferTextures gbuffer)
-			: light(light), shadowMap(shadowMap), shadowMapFace(shadowMapFace), shadowParams(shadowParams)
-			, perCamera(perCameraParams), gbuffer(gbuffer)
+			: light(light), shadowMap(shadowMap), shadowParams(shadowParams), perCamera(perCameraParams), gbuffer(gbuffer)
 		{ }
 
 		/** Light which is casting the shadow. */
@@ -144,9 +143,6 @@ namespace bs { namespace ct
 		/** Texture containing the shadow map. */
 		const SPtr<Texture>& shadowMap;
 
-		/** Face of the shadow map to bind, if it has multiple faces. */
-		UINT32 shadowMapFace;
-
 		/** Parameter block containing parameters specific for shadow projection. */
 		const SPtr<GpuParamBlockBuffer> shadowParams;
 
@@ -165,6 +161,7 @@ namespace bs { namespace ct
 		BS_PARAM_BLOCK_ENTRY(float, gFadePercent)
 		BS_PARAM_BLOCK_ENTRY(float, gFadePlaneDepth)
 		BS_PARAM_BLOCK_ENTRY(float, gInvFadePlaneRange)
+		BS_PARAM_BLOCK_ENTRY(float, gFace)
 	BS_PARAM_BLOCK_END
 
 	extern ShadowProjectParamsDef gShadowProjectParamsDef;