Merge pull request #259 from Unity-Technologies/Shadow-debug-and-cleanup

Cleanup SRP project

Assets/ScriptableRenderPipeline/HDRenderPipeline/Debug/Resources/DebugViewTiles.shader

                 // Highlight selected tile
                 if (all(mouseTileCoord == tileCoord))
                 {
-                    bool border = any(offsetInTile == 0 || offsetInTile == GetTileSize() - 1);
+                    bool border = any(offsetInTile == 0 || offsetInTile == (int)GetTileSize() - 1);
                     float4 result2 = float4(1.0, 1.0, 1.0, border ? 1.0 : 0.5);
                     result = AlphaBlend(result, result2);
                 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

             get { return m_DefaultDiffuseMaterial; }
             private set { m_DefaultDiffuseMaterial = value; }
         }
+
+        public Shader DefaultShader
+        {
+            get { return m_DefaultShader; }
+            private set { m_DefaultShader = value; }
+        }
+
         public override Shader GetDefaultShader()
         {
             return m_DefaultShader;
         // Various set of material use in render loop
         readonly Material m_FilterSubsurfaceScattering;
         readonly Material m_FilterAndCombineSubsurfaceScattering;
-        
+
         private Material m_DebugViewMaterialGBuffer;
         private Material m_DebugDisplayLatlong;
 
         }
 
         void InitializeDebugMaterials()
-        {            
+        {
             m_DebugViewMaterialGBuffer = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/DebugViewMaterialGBuffer");
             m_DebugDisplayLatlong = Utilities.CreateEngineMaterial("Hidden/HDRenderPipeline/DebugDisplayLatlong");
         }
                 m_LightLoop.Cleanup();
 
             m_LitRenderLoop.Cleanup();
-            
+
             Utilities.Destroy(m_DebugViewMaterialGBuffer);
             Utilities.Destroy(m_DebugDisplayLatlong);
 
             renderContext.ExecuteCommandBuffer(debugCB);
 
             if (m_LightLoop != null)
-                m_LightLoop.RenderDebugOverlay(camera, renderContext, debugDisplaySettings, ref x, ref y, overlaySize, camera.pixelWidth);            
+                m_LightLoop.RenderDebugOverlay(camera, renderContext, debugDisplaySettings, ref x, ref y, overlaySize, camera.pixelWidth);
         }
 
         void InitAndClearBuffer(Camera camera, ScriptableRenderContext renderContext)

Assets/ScriptableRenderPipeline/LowEndMobilePipeline/LowEndMobilePipelineAsset.cs

             private set { m_DefaultDiffuseMaterial = value; }
         }
 
+        public Shader DefaultShader
+        {
+            get { return m_DefaultShader; }
+            private set { m_DefaultShader = value; }
+        }
+
         #endregion
         public override Material GetDefaultMaterial()
         {

Assets/ScriptableRenderPipeline/ShaderLibrary/Shadow/Shadow.hlsl

 
 #define SHADOW_SUPPORTS_DYNAMIC_INDEXING 0 // only on >= sm 5.1
 
-#include "../../common/Shadow/ShadowBase.cs.hlsl"	// ShadowData definition, auto generated (don't modify)
+#include "../../Core/Shadow/ShadowBase.cs.hlsl"	// ShadowData definition, auto generated (don't modify)
 #include "ShadowTexFetch.hlsl"						// Resource sampling definitions (don't modify)
 
 // Declares a shadow context struct with members and sampling code based on whether _...Slots > 0

Assets/ScriptableRenderPipeline/fptl/LightingConvexHullUtils.hlsl

 #define __LIGHTINGCONVEXHULLUTILS_H__
 
 
-#include "..\common\ShaderBase.h"
+#include "ShaderBase.h"
 #include "LightDefinitions.cs.hlsl"
 
 

Assets/ScriptableRenderPipeline/fptl/LightingUtils.hlsl

 #define __LIGHTINGUTILS_H__
 
 
-#include "..\common\ShaderBase.h"
+#include "ShaderBase.h"
 #include "LightDefinitions.cs.hlsl"
 
 

Assets/ScriptableRenderPipeline/fptl/lightlistbuild-bigtile.compute

 #pragma kernel BigTileLightListGen
 
-#include "..\common\ShaderBase.h"
+#include "ShaderBase.h"
 #include "LightDefinitions.cs.hlsl"
 
 #include "LightingConvexHullUtils.hlsl"
 
 	float onePixDiagDist = GetOnePixDiagWorldDistAtDepthOne();
 	float halfTileSizeAtZDistOne = 32*onePixDiagDist;		// scale by half a tile
-	
+
-	
+
 		if( !DoesSphereOverlapTile(V, halfTileSizeAtZDistOne, lgtDat.center.xyz, lgtDat.radius) )
 			lightsListLDS[l]=0xffffffff;
 	}
 		[branch]if(canEnter)
 		{
 			SFiniteLightBound lgtDat = g_data[idxCoarse];
-	
+
 			const float3 boxX = lgtDat.boxAxisX.xyz;
 			const float3 boxY = lgtDat.boxAxisY.xyz;
 			const float3 boxZ = -lgtDat.boxAxisZ.xyz;	// flip axis (so it points away from the light direction for a spot-light)
 				int idx_cur=0, idx_twin=0;
 				float3 vP0, vE0;
 				GetHullEdge(idx_cur, idx_twin, vP0, vE0, e0, boxX, boxY, boxZ, center, scaleXY);
-				
-			
+
+
-				
+
-			
+
 				int positive=0, negative=0;
 				for(int k=1; k<8; k++)		// only need to test 7 verts (technically just 6).
 				{

Assets/ScriptableRenderPipeline/fptl/lightlistbuild-clustered.compute

 #pragma kernel TileLightListGen_DepthRT_MSAA_SrcBigTile		LIGHTLISTGEN=TileLightListGen_DepthRT_MSAA_SrcBigTile		ENABLE_DEPTH_TEXTURE_BACKPLANE		MSAA_ENABLED		USE_TWO_PASS_TILED_LIGHTING
 #pragma kernel ClearAtomic
 
-#include "..\common\ShaderBase.h"
+#include "ShaderBase.h"
 #include "LightDefinitions.cs.hlsl"
 #include "LightingConvexHullUtils.hlsl"
 
 		for(int p=0; p<6; p++)
 		{
 			float4 plane = lightPlanes[6*(l&3)+p];
-		
+
 			bool bAllInvisib = true;
 
 			for(int i=0; i<8; i++)
 #endif
 
 	int iNrCoarseLights = min(lightOffs,MAX_NR_COARSE_ENTRIES);
-	
+
 #ifdef PERFORM_SPHERICAL_INTERSECTION_TESTS
 	iNrCoarseLights = SphericalIntersectionTests( t, iNrCoarseLights, float2(min(viTilLL.xy+uint2(TILE_SIZE_CLUSTERED/2,TILE_SIZE_CLUSTERED/2), uint2(iWidth-1, iHeight-1))) );
 #endif
 
 
 	//////////////////////////////////////////////////////////
-	
+
 	uint start = 0;
 	int i=(int) t;
 	int iSpaceAvail = 0;
 float4 FetchPlane(int l, int p)
 {
 	SFiniteLightBound lgtDat = g_data[coarseList[l]];
-	
+
 	const float3 boxX = lgtDat.boxAxisX.xyz;
 	const float3 boxY = lgtDat.boxAxisY.xyz;
 	const float3 boxZ = -lgtDat.boxAxisZ.xyz;           // flip axis (so it points away from the light direction for a spot-light)
 
 	float onePixDiagDist = GetOnePixDiagWorldDistAtDepthOne();
 	float halfTileSizeAtZDistOne = (TILE_SIZE_CLUSTERED/2)*onePixDiagDist;		// scale by half a tile
-	
+
 	for(int l=threadID; l<iNrCoarseLights; l+=NR_THREADS)
 	{
 		SFiniteLightBound lgtDat = g_data[coarseList[l]];
 		[branch]if(g_vLightData[idxCoarse].lightType!=SPHERE_LIGHT)		// don't bother doing edge tests for sphere lights since these have camera aligned bboxes.
 		{
 			SFiniteLightBound lgtDat = g_data[idxCoarse];
-	
+
 			const float3 boxX = lgtDat.boxAxisX.xyz;
 			const float3 boxY = lgtDat.boxAxisY.xyz;
 			const float3 boxZ = -lgtDat.boxAxisZ.xyz;           // flip axis (so it points away from the light direction for a spot-light)
 				int idx_cur=0, idx_twin=0;
 				float3 vP0, vE0;
 				GetHullEdge(idx_cur, idx_twin, vP0, vE0, e0, boxX, boxY, boxZ, center, scaleXY);
-				
-			
+
+
-				
+
-			
+
 				int positive=0, negative=0;
 				for(int k=1; k<8; k++)		// only need to test 7 verts (technically just 6).
 				{

Assets/ScriptableRenderPipeline/fptl/lightlistbuild.compute

 #pragma kernel TileLightListGen					LIGHTLISTGEN=TileLightListGen
 #pragma kernel TileLightListGen_SrcBigTile		LIGHTLISTGEN=TileLightListGen_SrcBigTile		USE_TWO_PASS_TILED_LIGHTING
 
-#include "..\common\ShaderBase.h"
+#include "ShaderBase.h"
 #include "LightDefinitions.cs.hlsl"
 #include "LightingConvexHullUtils.hlsl"
 
 
 	if(t<MAX_NR_COARSE_ENTRIES)
 		prunedList[t]=0;
-	
+
 	uint iWidth = g_viDimensions.x;
 	uint iHeight = g_viDimensions.y;
 	uint nrTilesX = (iWidth+15)/16;
 	float3 vTileLL = float3(viTilLL.x/(float) iWidth, viTilLL.y/(float) iHeight, asfloat(ldsZMin));
 	float3 vTileUR = float3((viTilLL.x+16)/(float) iWidth, (viTilLL.y+16)/(float) iHeight, asfloat(ldsZMax));
 	vTileUR.xy = min(vTileUR.xy,float2(1.0,1.0)).xy;
-	
+
 
 	// build coarse list using AABB
 #ifdef USE_TWO_PASS_TILED_LIGHTING
 		}
 	}
 
-#ifdef FINE_PRUNING_ENABLED	
+#ifdef FINE_PRUNING_ENABLED
 	if(t<2) ldsDoesLightIntersect[t] = 0;
 #endif
 
 	iNrCoarseLights = SphericalIntersectionTests( t, iNrCoarseLights, float2(min(viTilLL.xy+uint2(16/2,16/2), uint2(iWidth-1, iHeight-1))) );
 #endif
 
-#ifndef FINE_PRUNING_ENABLED	
+#ifndef FINE_PRUNING_ENABLED
 	{
 		if((int)t<iNrCoarseLights) prunedList[t] = coarseList[t];
 		if(t==0) ldsNrLightsFinal=iNrCoarseLights;
 	GroupMemoryBarrierWithGroupSync();
 #endif
 
-	
+
-	for(int i=t; i<nrLightsCombinedList; i+=NR_THREADS) 
+	for(int i=t; i<nrLightsCombinedList; i+=NR_THREADS)
 	{
 		InterlockedAdd(ldsModelListCount[ g_vLightData[ prunedList[i] ].lightModel ], 1);
 	}
 
 	float onePixDiagDist = GetOnePixDiagWorldDistAtDepthOne();
 	float halfTileSizeAtZDistOne = 8*onePixDiagDist;		// scale by half a tile
-	
+
-	
+
 		if( DoesSphereOverlapTile(V, halfTileSizeAtZDistOne, lightData.center.xyz, lightData.radius) )
 		{
 			unsigned int uIndex;
 		{
 			SFiniteLightData lightData = g_vLightData[idxCoarse];
 			const bool bIsSpotDisc = (lightData.flags&IS_CIRCULAR_SPOT_SHAPE)!=0;
-				
+
-	
+
-	
+
 				// check pixel
 				float3 fromLight = vVPos-lightData.lightPos.xyz;
 				float distSq = dot(fromLight,fromLight);
 			for(int i=0; i<4; i++)
 			{
 				int idx = t + i*NR_THREADS;
-	
+
-	
+
-				float3 toLight = vLp - vVPos; 
+				float3 toLight = vLp - vVPos;
-			
+
 				if(lightData.radiusSq>distSq) uVal = 1;
 			}
 
 			for(int i=0; i<4; i++)
 			{
 				int idx = t + i*NR_THREADS;
-	
+
 				uint2 uPixLoc = min(uint2(viTilLL.x+(idx&0xf), viTilLL.y+(idx>>4)), uint2(iWidth-1, iHeight-1));
 				float3 vVPos = GetViewPosFromLinDepth(uPixLoc + float2(0.5,0.5), vLinDepths[i]);
 

Assets/ScriptableRenderPipeline/fptl/scrbound.compute

 
 #pragma kernel ScreenBoundsAABB
 
-#include "..\common\ShaderBase.h"
+#include "ShaderBase.h"
 #include "LightDefinitions.cs.hlsl"
 
 uniform int g_iNrVisibLights;
 void ScreenBoundsAABB(uint threadID : SV_GroupIndex, uint3 u3GroupID : SV_GroupID)
 {
 	uint groupID = u3GroupID.x;
-	
+
 	//uint vindex = groupID * NR_THREADS + threadID;
 	unsigned int g = groupID;
 	unsigned int t = threadID;
 	const int sideIndex = (int) (t%8);
-	
+
-	
+
 	const float3 boxX = lgtDat.boxAxisX.xyz;
 	const float3 boxY = lgtDat.boxAxisY.xyz;
 	const float3 boxZ = -lgtDat.boxAxisZ.xyz;           // flip axis (so it points away from the light direction for a spot-light)
 			const unsigned int uFlag3 = GetClip(vP3);
 
 			const float4 vPnts[] = {vP0, vP1, vP2, vP3};
-				
+
 			// screen-space AABB of one quad (assuming no intersection)
 			float3 vMin, vMax;
 			for(int k=0; k<4; k++)
 				fW = fS * (fWabs<FLT_EPSILON ? FLT_EPSILON : fWabs);
 				float3 vP = float3(vPnts[k].x/fW, vPnts[k].y/fW, vPnts[k].z/fW);
 				if(k==0) { vMin=vP; vMax=vP; }
-				
+
 				vMax = max(vMax, vP); vMin = min(vMin, vP);
 			}
 
 
 						float3 vFaceMi = float3(posX[subLigt*MAX_PNTS*2 + sideIndex + 0], posY[subLigt*MAX_PNTS*2 + sideIndex + 0], posZ[subLigt*MAX_PNTS*2 + sideIndex + 0]);
 						float3 vFaceMa = float3(posX[subLigt*MAX_PNTS*2 + sideIndex + 6], posY[subLigt*MAX_PNTS*2 + sideIndex + 6], posZ[subLigt*MAX_PNTS*2 + sideIndex + 6]);
-						
+
-							
+
 							vMax = max(vMax, vP); vMin = min(vMin, vP);
 						}
 					}
 			else		// :( need true clipping
 			{
-				
+
-			
+
 					// 4 vertices to a quad of the convex hull in post projection space
 					const float4 vP0 = mul(g_mProjection, float4(q0, 1));
 					const float4 vP1 = mul(g_mProjection, float4(q1, 1));
-					
+
 					int iSrcIndex = 0;
 
 					int offs = iSrcIndex*MAX_PNTS+subLigt*MAX_PNTS*2;
 						for(int k=0; k<iNrSrcVerts; k++)
 						{
 							float4 vCur = float4(posX[offs_src+k], posY[offs_src+k], posZ[offs_src+k], posW[offs_src+k]);
-							
+
-							
+
-						
+
 				}
 
 				////////////////////// look for camera frustum verts that need to be included. That is frustum vertices inside the convex hull for the light
 					float3 vVertPSpace = float3((i&1)!=0 ? 1 : (-1), (i&2)!=0 ? 1 : (-1), (i&4)!=0 ? 1 : 0);
-				
+
 					float4 v4ViewSpace = mul(g_mInvProjection, float4(vVertPSpace,1));
 					float3 vViewSpace = float3(v4ViewSpace.x/v4ViewSpace.w, v4ViewSpace.y/v4ViewSpace.w, v4ViewSpace.z/v4ViewSpace.w);
 
 						float3 vP = float3((i&1)!=0 ? 1 : (-1), (i&2)!=0 ? 1 : (-1), (i&4)!=0 ? 1 : 0);
 
 						if(!bSetBoundYet) { vMin=vP; vMax=vP; bSetBoundYet=true; }
-							
+
 						vMax = max(vMax, vP); vMin = min(vMin, vP);
 					}
 				}
-			
+
 			// determine AABB bound in [-1;1]x[-1;1] screen space using bounding sphere.
 			// Use the result to make our already established AABB from the convex hull
 			// potentially tighter.
 					float2 vMi, vMa;
 					bool2 bMi, bMa;
 					CalcBound(bMi, bMa, vMi, vMa, g_mInvProjection, center, radius);
-		
+
 					vMin.xy = bMi ? max(vMin.xy, vMi) : vMin.xy;
 					vMax.xy = bMa ? min(vMax.xy, vMa) : vMax.xy;
 				}
 			// to see if the light is occluded: vMin.z*VIEWPORT_SCALE_Z > MipTexelMaxDepth
 			//g_vBoundsBuffer[lgtIndex+0] = float3(0.5*vMin.x+0.5, -0.5*vMax.y+0.5, vMin.z*VIEWPORT_SCALE_Z);
 			//g_vBoundsBuffer[lgtIndex+g_iNrVisibLights] = float3(0.5*vMax.x+0.5, -0.5*vMin.y+0.5, vMax.z*VIEWPORT_SCALE_Z);
-			
+
 			// changed for unity
 			g_vBoundsBuffer[lgtIndex+0] = float3(0.5*vMin.x+0.5, 0.5*vMin.y+0.5, vMin.z*VIEWPORT_SCALE_Z);
 			g_vBoundsBuffer[lgtIndex+(int) g_iNrVisibLights] = float3(0.5*vMax.x+0.5, 0.5*vMax.y+0.5, vMax.z*VIEWPORT_SCALE_Z);
 				++nrVertsDst;
 			}
 		}
-							
+
 		if(bIsCurVisib)
 		{
 			//assert(nrVertsDst<MAX_PNTS);
 	const int index = ((uint) p)/2;
 	float x1 = index==0 ? vVisib.x : (index==1 ? vVisib.y : vVisib.z);
 	float x0 = index==0 ? vInvisib.x : (index==1 ? vInvisib.y : vInvisib.z);
-	
+
 	//fS*((vVisib.w-vInvisib.w)*t + vInvisib.w) = (x1-x0)*t + x0;
 
 	const float fT = (fS*vInvisib.w-x0)/((x1-x0) - fS*(vVisib.w-vInvisib.w));
 	float4 planeY0 = TransformPlaneToPostSpace(InvProjection, float4(0, planeY.x, planeY.y, 0));
 	float4 planeY1 = TransformPlaneToPostSpace(InvProjection, float4(0, planeY.z, planeY.w, 0));
 
-	
+
 	// convert planes to the forms (1,0,0,D) and (0,1,0,D)
 	// 2D bound is given by -D components
 	float2 A = -float2(planeX0.w / planeX0.x, planeY0.w / planeY0.y);

Assets/TestScenes/Common/Scripts/MiniProfiler.cs

     private const int kAverageFrameCount = 64;
     private float m_AccDeltaTime;
     private float m_AvgDeltaTime;
-    private	bool m_UseNewBatcher = false;
+ //   private	bool m_UseNewBatcher = false;
 
     internal class RecorderEntry
     {

Assets/ScriptableRenderPipeline/HDRenderPipeline/Sky/Resources/BlitCubemap.shader

             #pragma fragment frag
             #pragma target 4.5
 
-            #include "../../ShaderLibrary/Common.hlsl"
+            #include "../../../ShaderLibrary/Common.hlsl"
 
             TEXTURECUBE(_MainTex);
             SAMPLERCUBE(sampler_MainTex);

Assets/ScriptableRenderPipeline/Core/Debugging/DebugItemDrawer.cs

 #endif
     }
 
-}
+}

Assets/ScriptableRenderPipeline/Core/Resources.meta

+fileFormatVersion: 2
+guid: 059214a704804ae4490357c01c763f42
+folderAsset: yes
+timeCreated: 1494862081
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Shadow.meta

-fileFormatVersion: 2
-guid: f4cebcdbc19874c46ab4194e5ce59c67
-folderAsset: yes
-timeCreated: 1477395055
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/ScriptableRenderPipeline/common.meta

-fileFormatVersion: 2
-guid: 88c7531cefb4c7043bcfda092215f20c
-folderAsset: yes
-timeCreated: 1467917164
-licenseType: Pro
-DefaultImporter:
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: