+Unity Runtime codeHEADmaster

1 files changed, 885 insertions, 0 deletions

diff --git a/Runtime/Camera/ShadowCulling.cpp b/Runtime/Camera/ShadowCulling.cpp
new file mode 100644
index 0000000..f245547
--- /dev/null
+++ b/Runtime/Camera/ShadowCulling.cpp
@@ -0,0 +1,885 @@
+#include "UnityPrefix.h"
+#include "ShadowCulling.h"
+#include "Runtime/Camera/Light.h"
+#include "Runtime/Camera/Camera.h"
+#include "Runtime/Camera/CameraUtil.h"
+#include "Runtime/Graphics/Transform.h"
+#include "Runtime/Geometry/Sphere.h"
+#include "Runtime/Geometry/Intersection.h"
+#include "Runtime/Math/Rect.h"
+#include "Runtime/Misc/QualitySettings.h"
+#include "Runtime/Shaders/Material.h"
+#include "Runtime/Shaders/Shader.h"
+#include "Runtime/Profiler/Profiler.h"
+#include "Runtime/Misc/GameObjectUtility.h"
+#include "External/shaderlab/Library/shaderlab.h"
+#include "External/shaderlab/Library/intshader.h"
+#include "Runtime/Camera/BaseRenderer.h"
+#include "Runtime/Camera/CullResults.h"
+#include "Runtime/Camera/SceneCulling.h"
+#include "Runtime/Camera/SceneNode.h"
+#include "Runtime/Camera/UnityScene.h"
+#include "Runtime/Geometry/BoundingUtils.h"
+
+#include "SceneCulling.h"
+
+PROFILER_INFORMATION(gShadowsCullCastersPoint, "Shadows.CullCastersPoint", kProfilerRender)
+PROFILER_INFORMATION(gShadowsCullCastersSpot, "Shadows.CullCastersSpot", kProfilerRender)
+PROFILER_INFORMATION(gShadowsCullCastersDir, "Shadows.CullCastersDir", kProfilerRender)
+
+static const float kShadowFadeRange = 0.2f;
+
+static bool AddShadowCasterCullPlane(const Plane frustumCullPlanes[6], const Matrix4x4f& clipToWorld, const Vector3f& centerWorld, float nearPlaneScale, float farPlaneScale, int sideA, int sideB, int sideNeighbor, LightType lightType, const Vector3f& lightVec, Plane& outPlane)
+{
+	static Vector3f sideOffsets[] = {
+		Vector3f(-1.0f,  0.0f,  0.0f),	// kPlaneFrustumLeft
+		Vector3f( 1.0f,  0.0f,  0.0f),	// kPlaneFrustumRight
+		Vector3f( 0.0f, -1.0f,  0.0f),	// kPlaneFrustumBottom
+		Vector3f( 0.0f,  1.0f,  0.0f),	// kPlaneFrustumTop
+		Vector3f( 0.0f,  0.0f, -1.0f),	// kPlaneFrustumNear
+		Vector3f( 0.0f,  0.0f,  1.0f)	// kPlaneFrustumFar
+	};
+
+	const Plane& planeA = frustumCullPlanes[sideA];
+	const Plane& planeB = frustumCullPlanes[sideB];
+	Vector3f edgeNormal = planeA.GetNormal() + planeB.GetNormal(); // No need to normalize
+	Vector3f edgeCenter = sideOffsets[sideA] + sideOffsets[sideB];
+	Vector3f edgeDir = sideOffsets[sideNeighbor];
+	Vector3f posWorld1, posWorld2;
+	Vector3f posLocal1 = edgeCenter - edgeDir;
+	Vector3f posLocal2 = edgeCenter + edgeDir;
+	clipToWorld.PerspectiveMultiplyPoint3( posLocal1, posWorld1 );
+	clipToWorld.PerspectiveMultiplyPoint3( posLocal2, posWorld2 );
+	float scale1 = (posLocal1.z < 0.0f) ? nearPlaneScale : farPlaneScale;
+	float scale2 = (posLocal2.z < 0.0f) ? nearPlaneScale : farPlaneScale;
+	posWorld1 = centerWorld + (posWorld1 - centerWorld) * scale1;
+	posWorld2 = centerWorld + (posWorld2 - centerWorld) * scale2;
+
+	if( lightType == kLightDirectional )
+	{
+		/////@TODO: RUnning around in debug mode this seems to hit quite often in the shantytown scene...
+		Vector3f edgeDirWorld = (posWorld2 != posWorld1) ? Normalize( posWorld2 - posWorld1 ) : Vector3f(0.0f, 0.0f, 0.0f);
+		Vector3f clipNormal = Cross( edgeDirWorld, lightVec );
+		float len = Magnitude( clipNormal );
+		// Discard plane if edge is almost parallel with light dir
+		if (len < 0.001f)
+			return false;
+		clipNormal /= len;
+
+		// Flip the normal if we got the wrong direction
+		if( Dot( clipNormal, edgeNormal ) < 0.0f )
+		{
+			clipNormal *= -1.0f;
+		}
+		outPlane.SetNormalAndPosition( clipNormal, posWorld1 );
+	}
+	else
+	{
+		// We know the light is not too close to either plane
+		outPlane.Set3Points( posWorld1, posWorld2, lightVec );
+
+		if( Dot( outPlane.GetNormal(), edgeNormal ) < 0.0f )
+		{
+			outPlane *= -1.0f;
+		}
+	}
+	return true;
+}
+
+void CalculateShadowCasterCull(const Plane frustumCullPlanes[6], const Matrix4x4f& clipToWorld,
+							   const Vector3f& centerWorld, float nearPlaneScale, float farPlaneScale,
+							   LightType lightType, const Vector3f& lightVec, ShadowCasterCull& result,
+							   const bool alreadyTested[kPlaneFrustumNum])
+{
+	// Create clip volume from the distant planes and silhouette edges of camera's frustum (as seen by the light)
+	// Maximum planes generated should be 10, but we check at runtime to be sure
+	result.planeCount = 0;
+	bool facingLight[kPlaneFrustumNum];
+	bool enablePlane[kPlaneFrustumNum];
+	float epsilon = 0.01f;
+	for( int i = 0; i < kPlaneFrustumNum; ++i )
+	{
+		Plane plane = frustumCullPlanes[i];
+		if( lightType == kLightDirectional )
+		{
+			// Compare light direction and normal
+			float d = Dot( plane.GetNormal(), lightVec );
+			facingLight[i] = d < 0.0f;
+			enablePlane[i] = true;
+		}
+		else
+		{
+			float dist = plane.GetDistanceToPoint( lightVec );
+			facingLight[i] = false;
+			enablePlane[i] = true;
+			if( dist > -epsilon )
+			{
+				// Light is inside or just outside the frustum
+				facingLight[i] = true;
+				if ( dist < epsilon )
+				{
+					// Point is too close to the plane to care about edges
+					enablePlane[i] = false;
+				}
+				if ( dist < 0.0f )
+				{
+					// Push plane slightly so the frustum encloses the light
+					plane.distance -= dist;
+				}
+			}
+		}
+		if( facingLight[i] && !alreadyTested[i] )
+		{
+			result.planes[result.planeCount++] = plane;
+			if( result.planeCount == ShadowCasterCull::kMaxPlanes )
+				return;
+		}
+	}
+
+	// Sides in running order (each plane touches previous)
+	static int camera4Sides[] = {
+		kPlaneFrustumLeft,
+		kPlaneFrustumBottom,
+		kPlaneFrustumRight,
+		kPlaneFrustumTop
+	};
+	static int cameraNearFar[] = {
+		kPlaneFrustumNear,
+		kPlaneFrustumFar
+	};
+
+	// Iterate over diagonal edges
+	for( int edge = 0; edge < 4; ++edge )
+	{
+		int sideA = camera4Sides[edge];
+		// If we already tested side A, we also tested B
+		if( alreadyTested[sideA] )
+			continue;
+		int sideB = camera4Sides[(edge + 1) % 4];
+		int sideNeighbor = kPlaneFrustumFar;
+		if( facingLight[sideA] != facingLight[sideB] &&
+			enablePlane[sideA] && enablePlane[sideB] )
+		{
+			Plane& plane = result.planes[result.planeCount];
+			bool success = AddShadowCasterCullPlane(frustumCullPlanes, clipToWorld,
+				centerWorld, nearPlaneScale, farPlaneScale,
+				sideA, sideB, sideNeighbor, lightType, lightVec, plane);
+			result.planeCount += success ? 1 : 0;
+			if( result.planeCount == ShadowCasterCull::kMaxPlanes )
+				return;
+		}
+	}
+
+	// Iterate over near and far edges
+	for( int nearFar = 0; nearFar < 2; ++nearFar )
+	{
+		int sideA = cameraNearFar[nearFar];
+		// If we already tested side A, we also tested B
+		if( alreadyTested[sideA] )
+			continue;
+		for( int edge = 0; edge < 4; ++edge )
+		{
+			int sideB = camera4Sides[edge];
+			int sideNeighbor = camera4Sides[(edge + 1) % 4];
+			if( facingLight[sideA] != facingLight[sideB] &&
+				enablePlane[sideA] && enablePlane[sideB] )
+			{
+				Plane& plane = result.planes[result.planeCount];
+				bool success = AddShadowCasterCullPlane(frustumCullPlanes, clipToWorld,
+					centerWorld, nearPlaneScale, farPlaneScale,
+					sideA, sideB, sideNeighbor, lightType, lightVec, plane);
+				result.planeCount += success ? 1 : 0;
+				if( result.planeCount == ShadowCasterCull::kMaxPlanes )
+					return;
+			}
+		}
+	}
+}
+
+static const bool s_AlreadyTestedNone[kPlaneFrustumNum] = { false, false, false, false, false, false };
+
+void CalculateShadowCasterCull(const Plane frustumCullPlanes[6], const Matrix4x4f& clipToWorld, const Vector3f& centerWorld, float nearPlaneScale, float farPlaneScale, LightType lightType, const Transform& trans, ShadowCasterCull& result)
+{
+	// Get position for positional lights and direction for directional lights
+	Vector3f lightVec;
+	if( lightType == kLightDirectional )
+	{
+		lightVec = trans.TransformDirection( Vector3f::zAxis );
+	}
+	else
+	{
+		Assert( lightType == kLightPoint || lightType == kLightSpot );
+		lightVec = trans.GetPosition();
+	}
+	CalculateShadowCasterCull(frustumCullPlanes, clipToWorld, centerWorld, nearPlaneScale, farPlaneScale, lightType, lightVec, result, s_AlreadyTestedNone);
+}
+
+static bool CanUseProjectionForShadows (const Matrix4x4f& clipToWorld, float farNearRatio, const Camera& camera, const Vector3f& cameraPos)
+{
+	// Check if eye position is the focal point of the camera projection
+	// and we can scale near plane from the eye pos to get the far plane.
+	// This works for asymmetric projections, not for oblique etc.
+	Vector3f cameraFrustum[8];
+	GetFrustumPoints(clipToWorld, cameraFrustum);
+	for (int i = 0; i < 4; i++)
+	{
+		const Vector3f& nearPos = cameraFrustum[i];
+		const Vector3f& farPos = cameraFrustum[i + 4];
+		Vector3f derivedFar = cameraPos + (nearPos - cameraPos) * farNearRatio;
+		float diff = SqrMagnitude(derivedFar - farPos);
+		float length = SqrMagnitude(farPos - nearPos);
+		if (!(diff <= length * 0.01f))
+		{
+			return false;
+		}
+	}
+	return true;
+}
+
+void SetupShadowCullData (Camera& camera, const Vector3f& cameraPos, const ShaderReplaceData& shaderReplaceData, const SceneCullingParameters* sceneCullParams, ShadowCullData& cullData)
+{
+	const Rectf screenRect = camera.GetScreenViewportRect();
+	float shadowDistance = CalculateShadowDistance (camera);
+
+	Vector3f viewDir = -NormalizeSafe(camera.GetCameraToWorldMatrix().GetAxisZ());
+
+	cullData.camera = &camera;
+	cullData.eyePos = cameraPos;
+	cullData.viewDir = viewDir;
+	cullData.shadowDistance = shadowDistance;
+	cullData.projectionNear = camera.GetProjectionNear();
+	cullData.projectionFar = camera.GetProjectionFar();
+	cullData.farPlaneScale = shadowDistance / cullData.projectionFar;
+	cullData.viewWidth = screenRect.width;
+	cullData.viewHeight = screenRect.height;
+	cullData.actualWorldToClip = camera.GetWorldToClipMatrix();
+	cullData.visbilityForShadowCulling = NULL;
+	Matrix4x4f::Invert_Full(cullData.actualWorldToClip, cullData.cameraClipToWorld);
+
+	float farNearRatio = cullData.projectionFar / cullData.projectionNear;
+	if (!CanUseProjectionForShadows(cullData.cameraClipToWorld, farNearRatio, camera, cameraPos))
+	{
+		// Use implicit projection instead (which we used always before 3.5)
+		Matrix4x4f proj;
+		camera.GetImplicitProjectionMatrix(camera.GetNear(), camera.GetFar(), proj);
+		MultiplyMatrices4x4 (&proj, &camera.GetWorldToCameraMatrix(), &cullData.cameraWorldToClip);
+		Matrix4x4f::Invert_Full(cullData.cameraWorldToClip, cullData.cameraClipToWorld);
+	}
+	else
+		cullData.cameraWorldToClip = cullData.actualWorldToClip;
+
+	camera.CalculateFrustumPlanes(cullData.shadowCullPlanes, cullData.cameraWorldToClip, shadowDistance, cullData.baseFarDistance, true);
+	for( int i = 0; i < kPlaneFrustumNum; i++ )
+		cullData.cameraCullPlanes[i] = cullData.shadowCullPlanes[i];
+	cullData.cameraCullPlanes[kPlaneFrustumFar].distance = cullData.baseFarDistance + camera.GetFar();
+	cullData.shadowCullCenter = Vector3f::zero;
+	float cullRadius = 1e15f;
+	cullData.useSphereCulling = CalculateSphericalShadowRange(camera, cullData.shadowCullCenter, cullRadius);
+	cullData.shadowCullRadius = cullRadius;
+	cullData.shadowCullSquareRadius = cullRadius * cullRadius;
+	const float* layerCullDistances = camera.GetLayerCullDistances();
+	std::copy(layerCullDistances, layerCullDistances + kNumLayers, cullData.layerCullDistances);
+	cullData.layerCullSpherical = camera.GetLayerCullSpherical();
+	cullData.shaderReplace = shaderReplaceData;
+	cullData.sceneCullParameters = sceneCullParams;
+}
+
+float CalculateShadowDistance (const Camera& camera)
+{
+	return std::min (QualitySettings::GetShadowDistanceForRendering(), camera.GetFar());
+}
+
+float CalculateShadowSphereOffset (const Camera& camera)
+{
+	float fov = camera.GetFov();
+	static float maxDegrees = 180.0f;
+	const float maxOffset = (1.0f - kShadowFadeRange) * 0.5f;
+	float weight = clamp(1.0f - fov / maxDegrees, 0.0f, 1.0f);
+	return maxOffset * weight;
+}
+
+bool CalculateSphericalShadowRange (const Camera& camera, Vector3f& outCenter, float& outRadius)
+{
+	const QualitySettings::QualitySetting& quality = GetQualitySettings().GetCurrent();
+	if (quality.shadowProjection == kShadowProjCloseFit)
+		return false;
+
+	outCenter = camera.GetPosition();
+	outRadius = CalculateShadowDistance(camera);
+
+	float sphereOffset = CalculateShadowSphereOffset(camera);
+	Vector3f vectorOffset(0, 0, -sphereOffset * outRadius);
+	outCenter += camera.GetCameraToWorldMatrix().MultiplyVector3(vectorOffset);
+	outRadius *= (1.0f - sphereOffset);
+	return true;
+
+	Assert(quality.shadowProjection == kShadowProjStableFit);
+	return true;
+}
+
+void CalculateLightShadowFade (const Camera& camera, float shadowStrength, Vector4f& outParams, Vector4f& outCenterAndType)
+{
+	float shadowDistance = CalculateShadowDistance(camera);
+	float shadowRange = shadowDistance;
+	Vector3f center = camera.GetPosition();
+	bool spherical = CalculateSphericalShadowRange(camera, center, shadowRange);
+
+	// R = 1-strength
+	// G = 1.0 / shadowDistance
+	// B = 1.0 / (shadowDistance - shadowStartFade)
+	// A = -shadowStartFade / (shadowDistance - shadowStartFade)
+	outParams.x = 1.0f - shadowStrength; // R = 1-strength
+
+	if (shadowRange > 0)
+	{
+		outParams.y = camera.GetFar() / shadowDistance;
+		// fade factor = (x-start)/len = x * invlen - start*invlen
+		const float shadowStartFade = shadowRange - shadowDistance * kShadowFadeRange;
+		const float shadowFadeInvLen = 1.0f / (shadowRange - shadowStartFade);
+		outParams.z = shadowFadeInvLen;
+		outParams.w = -shadowStartFade * shadowFadeInvLen;
+	}
+	else
+	{
+		outParams.y = std::numeric_limits<float>::infinity();
+		outParams.z = 0;
+		outParams.w = 1;
+	}
+
+	outCenterAndType = Vector4f(center.x, center.y, center.z, spherical);
+}
+
+struct ShadowCullContext
+{
+	const ShadowCullData* camera;
+	bool excludeLightmapped;
+	UInt32 cullLayers;
+};
+
+
+static void AddShadowCaster (const SceneNode& node, const AABB& aabb, const ShadowCullData& context, bool expandCasterBounds, MinMaxAABB& casterBounds, ShadowCasters& casters, ShadowCasterParts& casterParts)
+{
+	const BaseRenderer* renderer = node.renderer;
+	
+	Assert( renderer && renderer->GetCastShadows() );
+
+	// Find out which sub-materials do cast shadows
+	// and prefetch shader pointers.
+	size_t partsStartIndex = casterParts.size();
+	int matCount = renderer->GetMaterialCount();
+	
+	Shader* replaceShader = context.shaderReplace.replacementShader;
+	const bool replacementTagSet = context.shaderReplace.replacementTagSet;
+	const int replacementTagID = context.shaderReplace.replacementTagID;
+	
+	for( int i = 0; i < matCount; ++i )
+	{
+		Material* mat = renderer->GetMaterial(i);
+		if( !mat )
+			continue;
+
+		Shader* originalShader = mat->GetShader();
+		Shader* actualShader = replaceShader ? replaceShader : originalShader;
+		
+		// Find the subshader...
+		int usedSubshaderIndex = -1;
+		if (replaceShader)
+		{
+			if (replacementTagSet)
+			{
+				int subshaderTypeID = originalShader->GetShaderLabShader()->GetTag (replacementTagID, true);
+				if (subshaderTypeID < 0)
+					continue; // skip rendering
+				usedSubshaderIndex = replaceShader->GetSubShaderWithTagValue (replacementTagID, subshaderTypeID);
+				if (usedSubshaderIndex == -1)
+					continue; // skip rendering
+			}
+			else
+				usedSubshaderIndex = 0;
+		}
+		else
+			usedSubshaderIndex = originalShader->GetActiveSubShaderIndex();
+		
+		Assert (usedSubshaderIndex != -1);
+		
+		if (actualShader->GetShadowCasterPassToUse(usedSubshaderIndex))
+		{
+			ShadowCasterPartData part;
+			part.subMeshIndex = renderer->GetSubsetIndex(i);
+			part.shader = actualShader;
+			part.subShaderIndex = usedSubshaderIndex;
+			part.material = mat;
+			casterParts.push_back (part);
+		}
+	}
+
+	// This object does cast shadows, store info
+	size_t partsEndIndex = casterParts.size();
+	if( partsEndIndex != partsStartIndex )
+	{
+		ShadowCasterData data;
+		data.node = &node;
+		data.worldAABB = &aabb;
+		data.visibleCascades = 1;
+		data.partsStartIndex = partsStartIndex;
+		data.partsEndIndex = partsEndIndex;
+
+		casters.push_back( data );
+
+		if( expandCasterBounds )
+			casterBounds.Encapsulate( aabb );
+	}
+}
+
+static bool CullCastersCommon(const ShadowCullContext& context, const SceneNode& node, const AABB& aabb)
+{
+	const BaseRenderer* renderer = node.renderer;
+	if (!renderer->GetCastShadows())
+		return false;
+
+	if (context.excludeLightmapped && renderer->IsLightmappedForShadows())
+		return false;
+
+	const int nodeLayer = node.layer;
+	const int nodeLayerMask = 1 << nodeLayer;
+	if (!(nodeLayerMask & context.cullLayers))
+		return false;
+
+	// For casters that use per-layer culling distance: check if they are behind cull distance.
+	// If they are, don't cast shadows.
+	const ShadowCullData& cullData = *context.camera;
+	float layerCullDist = cullData.layerCullDistances[nodeLayer];
+	if (layerCullDist)
+	{
+		if (cullData.layerCullSpherical)
+		{
+
+			float sqDist = SqrMagnitude(aabb.GetCenter() - cullData.eyePos);
+			if (sqDist > Sqr(layerCullDist))
+				return false;
+		}
+		else
+		{
+			Plane farPlane = cullData.shadowCullPlanes[kPlaneFrustumFar];
+			farPlane.distance = layerCullDist + cullData.baseFarDistance;
+			if( !IntersectAABBPlaneBounds( aabb, &farPlane, 1 ) )
+				return false;			
+		}
+	}
+
+	return true;
+}
+
+//
+// Point light shadow caster culling
+
+struct PointCullContext : public ShadowCullContext
+{
+	Sphere lightSphere;
+};
+
+static bool CullCastersPoint( PointCullContext* context, const SceneNode& node, const AABB& aabb )
+{
+	if (!CullCastersCommon(*context, node, aabb))
+		return false;
+	
+	if (!IntersectAABBSphere( aabb, context->lightSphere ))
+		return false;
+
+	return true;
+}
+
+//
+// Spot light shadow caster culling
+
+struct SpotCullContext : public ShadowCullContext
+{
+	Matrix4x4f worldToLightMatrix, projectionMatrix;
+	Plane spotLightFrustum[6];
+};
+
+static bool CullCastersSpot( SpotCullContext* context, const SceneNode& node, const AABB& aabb )
+{
+	if (!CullCastersCommon(*context, node, aabb))
+		return false;
+
+	// World space light frustum vs. global AABB
+	if (!IntersectAABBFrustumFull (aabb, context->spotLightFrustum))
+		return false;
+
+	const TransformInfo& xformInfo = node.renderer->GetTransformInfo ();
+
+	Plane planes[6];
+	// NOTE: it's important to multiply world->light and node->world matrices
+	// before multiplying in the projection matrix. Otherwise when object/light
+	// coordinates will approach 10 thousands range, we'll get culling errors
+	// because of imprecision.
+	//Matrix4x4f proj = context->projectionMatrix * (context->worldToLightMatrix * node->worldMatrix);
+	Matrix4x4f temp, proj;
+	MultiplyMatrices4x4 (&context->worldToLightMatrix, &xformInfo.worldMatrix, &temp);
+	MultiplyMatrices4x4 (&context->projectionMatrix, &temp, &proj);
+	ExtractProjectionPlanes( proj, planes );
+
+	if (!IntersectAABBFrustumFull( xformInfo.localAABB, planes ) )
+		return false;
+
+	return true;
+}
+
+
+//
+// Directional light shadow caster culling
+
+struct DirectionalCullContext : public ShadowCullContext
+{
+};
+
+static bool CullCastersDirectional( DirectionalCullContext* context, const SceneNode& node, const AABB& aabb )
+{
+	return CullCastersCommon(*context, node, aabb);
+}
+
+
+static void CullDirectionalShadows (IndexList& visible, const SceneNode* nodes, const AABB* boundingBoxes, DirectionalCullContext &context )
+{
+	// Generate Visible nodes from all static & dynamic objects
+	int visibleCount = 0;
+	for (int i=0;i<visible.size;i++)
+	{
+		const SceneNode& node = nodes[visible.indices[i]];
+		const AABB& bounds = boundingBoxes[visible.indices[i]];
+
+		if (CullCastersDirectional( &context, node, bounds))
+			visible.indices[visibleCount++] = visible.indices[i];
+	}
+	visible.size = visibleCount;
+}
+
+static void CullSpotShadows (IndexList& visible, const SceneNode* nodes, const AABB* boundingBoxes, SpotCullContext &context )
+{
+	// Generate Visible nodes from all static & dynamic objects
+	int visibleCount = 0;
+	for (int i=0;i<visible.size;i++)
+	{
+		const SceneNode& node = nodes[visible.indices[i]];
+		const AABB& bounds = boundingBoxes[visible.indices[i]];
+
+		if (CullCastersSpot( &context, node, bounds))
+			visible.indices[visibleCount++] = visible.indices[i];
+	}
+	visible.size = visibleCount;
+}
+
+static void CullPointShadows (IndexList& visible, const SceneNode* nodes, const AABB* boundingBoxes, PointCullContext &context )
+{
+	// Generate Visible nodes from all static & dynamic objects
+	int visibleCount = 0;
+	for (int i=0;i<visible.size;i++)
+	{
+		const SceneNode& node = nodes[visible.indices[i]];
+		const AABB& bounds = boundingBoxes[visible.indices[i]];
+
+		if (CullCastersPoint( &context, node, bounds ))
+			visible.indices[visibleCount++] = visible.indices[i];
+	}
+	visible.size = visibleCount;
+}
+
+static void CullShadowCastersDetail( const Light& light, const ShadowCullData& cullData, bool excludeLightmapped, CullingOutput& visibleRenderers )
+{
+	const RendererCullData* rendererCullData = cullData.sceneCullParameters->renderers;
+	
+	int cullLayers = light.GetCullingMask() & cullData.camera->GetCullingMask();
+	LightType lightType = light.GetType();
+	switch (lightType)
+	{
+		case kLightPoint:
+		{
+			PointCullContext context;
+			const Transform& lt = light.GetComponent (Transform);
+			Vector3f lightPos = lt.GetPosition();
+			context.lightSphere = Sphere( lightPos, light.GetRange() );
+			context.camera = &cullData;
+			context.cullLayers = cullLayers;
+			context.excludeLightmapped = excludeLightmapped;
+			
+			for (int i=0;i<kVisibleListCount;i++)
+				CullPointShadows (visibleRenderers.visible[i], rendererCullData[i].nodes, rendererCullData[i].bounds, context);
+		}
+			break;
+			
+		case kLightSpot:
+		{
+			SpotCullContext context;
+			Matrix4x4f zscale, proj;
+			zscale.SetScale (Vector3f (1.0F, 1.0F, -1.0F));
+			proj.SetPerspectiveCotan( light.GetCotanHalfSpotAngle(), 0.0001F, light.GetRange() );
+			MultiplyMatrices4x4 (&proj, &zscale, &context.projectionMatrix);
+			const Transform& lt = light.GetComponent (Transform);
+			context.worldToLightMatrix = lt.GetWorldToLocalMatrixNoScale();
+			
+			Matrix4x4f temp;
+			MultiplyMatrices4x4 (&context.projectionMatrix, &context.worldToLightMatrix, &temp);
+			ExtractProjectionPlanes (temp, context.spotLightFrustum);
+			
+			context.camera = &cullData;
+			context.cullLayers = cullLayers;
+			context.excludeLightmapped = excludeLightmapped;
+			
+			for (int i=0;i<kVisibleListCount;i++)
+				CullSpotShadows (visibleRenderers.visible[i], rendererCullData[i].nodes, rendererCullData[i].bounds, context);
+		}
+			break;
+		case kLightDirectional:
+		{
+			DirectionalCullContext context;
+			context.camera = &cullData;
+			context.cullLayers = cullLayers;
+			context.excludeLightmapped = excludeLightmapped;
+			
+			for (int i=0;i<kVisibleListCount;i++)
+				CullDirectionalShadows (visibleRenderers.visible[i], rendererCullData[i].nodes, rendererCullData[i].bounds, context);
+		}
+			break;
+	}
+}
+
+void CullShadowCasters (const Light& light, const ShadowCullData& cullData, bool excludeLightmapped, CullingOutput& cullingOutput )
+{
+	LightType lightType = light.GetType();
+	
+	if (lightType == kLightPoint)
+	{
+		PROFILER_BEGIN(gShadowsCullCastersPoint,&light)
+	}
+	else if (lightType == kLightSpot)
+	{
+		PROFILER_BEGIN(gShadowsCullCastersSpot,&light)
+	}
+	else
+	{
+		PROFILER_BEGIN(gShadowsCullCastersDir,&light)
+	}
+	
+	const Transform& lt = light.GetComponent (Transform);
+	ShadowCasterCull casterCull;
+	
+	CalculateShadowCasterCull( cullData.shadowCullPlanes, cullData.cameraClipToWorld, cullData.eyePos,
+							  1.0, cullData.farPlaneScale, lightType, lt, casterCull );
+	
+	SceneCullingParameters cullParams = *cullData.sceneCullParameters;
+	cullData.camera->CalculateCustomCullingParameters(cullParams, casterCull.planes, casterCull.planeCount);
+	
+	if (lightType == kLightDirectional)
+	{
+		Vector3f lightDir = lt.TransformDirection (Vector3f(0,0,-1));
+		cullParams.lightDir = lightDir;
+	}
+	
+	if (cullParams.useShadowCasterCulling && (lightType == kLightDirectional))
+	{
+		CullShadowCastersWithUmbra(cullParams, cullingOutput);
+	}
+	else
+	{
+		CullSceneWithoutUmbra (cullParams, cullingOutput);
+	}
+	
+	
+	CullShadowCastersDetail (light, cullData, excludeLightmapped, cullingOutput);
+	
+	PROFILER_END
+}
+
+
+void GenerateShadowCasterParts (const Light& light, const ShadowCullData& cullData, const CullingOutput& visibleRenderers, MinMaxAABB& casterBounds, ShadowCasters& casters, ShadowCasterParts& casterParts)
+{
+	const bool isDirectionalLight = light.GetType() == kLightDirectional;
+	
+	const RendererCullData* rendererCullData = cullData.sceneCullParameters->renderers;
+	for (int t=0;t<kVisibleListCount;t++)
+	{
+		const IndexList& visibleList = visibleRenderers.visible[t];
+		const RendererCullData& renderLists = rendererCullData[t];
+		for (int i=0;i<visibleList.size;i++)
+		{
+			int renderIndex = visibleList[i];
+			bool casterTouchesView = false;
+			if (isDirectionalLight)
+			{
+				// Only compute caster AABB for casters that touch the view frustum.
+				// Other casters might be valid casters, but behind near plane of resulting
+				// shadow camera. This is ok, we manually push those onto near plane in caster vertex shader.
+				//
+				// If we'd bound all casters we get the issue of insufficient depth precision when some caster
+				// has a valid caster, but is waaay far away (50000 units or so).
+				casterTouchesView = IntersectAABBFrustumFull( renderLists.bounds[renderIndex], cullData.cameraCullPlanes );
+			}
+			
+			// Last argument expandCasterBounds should be false for point lights as they don't use casterBounds to adjust shadow map view
+			AddShadowCaster( renderLists.nodes[renderIndex], renderLists.bounds[renderIndex], cullData, casterTouchesView, casterBounds, casters, casterParts );
+		}
+	}
+}
+
+
+
+/*
+ 
+ static bool CullCastersDirectional( DirectionalCullContext* context, const SceneNode& node, const AABB& aabb, float lodFade )
+ {
+ if (!CullCastersCommon(*context, node, aabb))
+ return false;
+ 
+ // Only compute caster AABB for casters that touch the view frustum.
+ // Other casters might be valid casters, but behind near plane of resulting
+ // shadow camera. This is ok, we manually push those onto near plane in caster vertex shader.
+ //
+ // If we'd bound all casters we get the issue of insufficient depth precision when some caster
+ // has a valid caster, but is waaay far away (50000 units or so).
+ bool casterTouchesView = IntersectAABBFrustumFull( aabb, context->camera->cameraCullPlanes );
+ AddShadowCaster( node, aabb, *context, casterTouchesView );
+ return true;
+ }
+ 
+ 
+ */
+
+
+
+struct Circle2f
+{
+	Vector2f center;
+	float radius;
+};
+
+void CullDirectionalCascades(ShadowCasters& casters, const ShadowCascadeInfo cascades[kMaxShadowCascades], int cascadeCount,
+									const Quaternionf& lightRot, const Vector3f& lightDir, const ShadowCullData& cullData)
+{
+	Assert(cascadeCount <= kMaxShadowCascades);
+	const QualitySettings::QualitySetting& quality = GetQualitySettings().GetCurrent();
+	if (quality.shadowProjection == kShadowProjCloseFit && cascadeCount == 1)
+	{
+		// We already culled casters for one non-spherical cascade
+		return;
+	}
+	const Camera& camera = *cullData.camera;
+
+	// Split frustums extruded towards light
+	ShadowCasterCull cullPlanes[kMaxShadowCascades];
+
+	// Only objects inside a cylinder can cast shadows onto a sphere
+	// We cull in light space so the cylinders become circles
+	Circle2f cullCylinders[kMaxShadowCascades];
+
+	Matrix4x4f lightMat;
+	QuaternionToMatrix(lightRot, lightMat);
+
+	for (int casc = 0; casc < cascadeCount; casc++)
+	{
+		const ShadowCascadeInfo& cascade = cascades[casc];
+		if (!cascade.enabled)
+			continue;
+		if (quality.shadowProjection == kShadowProjStableFit)
+		{
+			// We use spherical splits so cull against a cylinder
+			const Vector3f& centerWorld = cascade.outerSphere.GetCenter();
+			cullCylinders[casc].center.x = Dot(centerWorld, lightMat.GetAxisX());
+			cullCylinders[casc].center.y = Dot(centerWorld, lightMat.GetAxisY());
+			cullCylinders[casc].radius = cascade.outerSphere.GetRadius();
+		}
+		if (cascadeCount == 1)
+		{
+			// We have already culled against non-cascaded frustum
+			cullPlanes[casc].planeCount = 0;
+			continue;
+		}
+
+		bool alreadyTested[kPlaneFrustumNum];
+		for (int p = 0; p < kPlaneFrustumNear; p++)
+			alreadyTested[p] = true;
+		alreadyTested[kPlaneFrustumNear] = (casc == 0);
+		alreadyTested[kPlaneFrustumFar] = ((casc + 1) == cascadeCount);
+
+		Plane splitPlanes[kPlaneFrustumNum];
+		memcpy(splitPlanes, cullData.shadowCullPlanes, sizeof(splitPlanes));
+		splitPlanes[kPlaneFrustumNear].distance += cascade.minViewDistance - camera.GetNear();
+		splitPlanes[kPlaneFrustumFar].distance += cascade.maxViewDistance - cullData.shadowDistance;
+		float nearPlaneScale = cascade.minViewDistance / cullData.projectionNear;
+		float farPlaneScale = cascade.maxViewDistance / cullData.projectionFar;
+		CalculateShadowCasterCull(splitPlanes, cullData.cameraClipToWorld, cullData.eyePos,
+			nearPlaneScale, farPlaneScale, kLightDirectional, lightDir, cullPlanes[casc], alreadyTested);
+	}
+
+	UInt32 allVisible = 0;
+	for (int casc = 0; casc < cascadeCount; casc++)
+		allVisible = (allVisible << 1) | 1;
+
+	// Go over casters and determine in which cascades they are visible
+	int casterCount = casters.size();
+	for (int i = 0; i < casterCount; i++)
+	{
+		ShadowCasterData& caster = casters[i];
+		const AABB& bounds = *caster.worldAABB;
+		caster.visibleCascades = allVisible;
+		UInt32 currentCascadeMask = 1;
+
+		if (quality.shadowProjection == kShadowProjStableFit)
+		{
+			float casterRadius = Magnitude(bounds.GetExtent());
+			Vector2f lightSpaceCenter;
+			lightSpaceCenter.x = Dot(bounds.GetCenter(), lightMat.GetAxisX());
+			lightSpaceCenter.y = Dot(bounds.GetCenter(), lightMat.GetAxisY());
+			currentCascadeMask = 1;
+			for (int casc = 0; casc < cascadeCount; casc++, currentCascadeMask <<= 1)
+			{
+				if (!cascades[casc].enabled)
+					continue;
+				// Do the caster bounds and cascade intersect in light space?
+				Vector2f vec = lightSpaceCenter - cullCylinders[casc].center;
+				float sqrDist = Sqr(vec.x) + Sqr(vec.y);
+				float cullRadius = cullCylinders[casc].radius;
+				if (sqrDist > Sqr(casterRadius + cullRadius))
+				{
+					// Circles do not intersect, mark as invisible
+					caster.visibleCascades &= ~currentCascadeMask;
+				}
+			}
+		}
+
+		if (cascadeCount > 1)
+		{
+			currentCascadeMask = 1;
+			for (int casc = 0; casc < cascadeCount; casc++, currentCascadeMask <<= 1)
+			{
+				if (!cascades[casc].enabled)
+					continue;
+				// Did we already cull this?
+				if (caster.visibleCascades & currentCascadeMask)
+				{
+					if (!IntersectAABBPlaneBounds(bounds, cullPlanes[casc].planes, cullPlanes[casc].planeCount))
+					{
+						// Outside cull planes, mark this as invisible
+						caster.visibleCascades &= ~currentCascadeMask;
+					}
+				}
+			}
+		}
+	}
+}
+
+bool IsObjectWithinShadowRange (const ShadowCullData& shadowCullData, const AABB& bounds)
+{
+	if (shadowCullData.useSphereCulling)
+	{
+		float sqrDist = SqrMagnitude(bounds.GetCenter() - shadowCullData.shadowCullCenter);
+		if (sqrDist < shadowCullData.shadowCullSquareRadius)
+			return true;
+		Sphere sphere(shadowCullData.shadowCullCenter, shadowCullData.shadowCullRadius);
+		return IntersectAABBSphere(bounds, sphere);
+	}
+	else
+	{
+		return IntersectAABBPlaneBounds(bounds, &shadowCullData.shadowCullPlanes[kPlaneFrustumFar], 1);
+	}
+}