Merge pull request #291 from Unity-Technologies/Update-hlsl-generator

Update hlsl generator to C# convention

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.asset

   m_Script: {fileID: 11500000, guid: 0cf1dab834d4ec34195b920ea7bbf9ec, type: 3}
   m_Name: HDRenderPipelineAsset
   m_EditorClassIdentifier: 
-  m_RenderPipelineResources: {fileID: 11400000, guid: 42086e81f4f0c724f96f7f09cc995354,
-    type: 2}
+  m_RenderPipelineResources: {fileID: 0}
-    numProfiles: 2
+    numProfiles: 1
-    - {fileID: 11400000, guid: d6ee4403015766f4093158d69216c0bf, type: 2}
-    - {fileID: 11400000, guid: 906339bac2066fc4aa22a3652e1283ef, type: 2}
+    - {fileID: 0}
-    enableTileAndCluster: 0
+    enableTileAndCluster: 1
     enableSplitLightEvaluation: 1
     enableComputeLightEvaluation: 0
     enableComputeFeatureVariants: 0
     spotCookieSize: 128
     pointCookieSize: 512
     reflectionCubemapSize: 128
-  m_DefaultDiffuseMaterial: {fileID: 2100000, guid: 73c176f402d2c2f4d929aa5da7585d17,
-    type: 2}
-  m_DefaultShader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  m_DefaultDiffuseMaterial: {fileID: 0}
+  m_DefaultShader: {fileID: 0}

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.asset.meta

 fileFormatVersion: 2
 guid: 449281dd2b4fbee49b8397de0541ea3c
-timeCreated: 1496162200
+timeCreated: 1496931629
 licenseType: Pro
 NativeFormatImporter:
   mainObjectFileID: 11400000

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/ClusteredUtils.hlsl

 
 int SnapToClusterIdxFlex(float z_in, float suggestedBase, bool logBasePerTile)
 {
-#if USE_LEFTHAND_CAMERASPACE
+#if USE_LEFT_HAND_CAMERA_SPACE
     float z = z_in;
 #else
     float z = -z_in;
     float dist = (PositivePow(suggestedBase, (float)k) - 1.0) / (userscale * (suggestedBase - 1.0f));
     res = dist + g_fNearPlane;
 
-#if USE_LEFTHAND_CAMERASPACE
+#if USE_LEFT_HAND_CAMERA_SPACE
     return res;
 #else
     return -res;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/FeatureFlags.hlsl

 #ifndef __FEATURE_FLAGS_H__
 #define __FEATURE_FLAGS_H__
 
-static const uint FEATURE_FLAG_ALL_MATERIALS = FEATURE_FLAG_MATERIAL_LIT_STANDARD | FEATURE_FLAG_MATERIAL_LIT_SSS | FEATURE_FLAG_MATERIAL_LIT_SPECULAR | FEATURE_FLAG_MATERIAL_LIT_ANISO;
+static const uint FEATURE_FLAG_ALL_MATERIALS = MATERIALFEATUREFLAGS_LIT_STANDARD | MATERIALFEATUREFLAGS_LIT_SSS | MATERIALFEATUREFLAGS_LIT_SPECULAR | MATERIALFEATUREFLAGS_LIT_ANISO;
-/*  1 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
-/*  2 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
-/*  3 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
-/*  3 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
-/*  5 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_AREA | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
-/*  6 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_AREA | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
-/*  7 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_AREA | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_LIGHT_PROJECTOR | FEATURE_FLAG_MATERIAL_LIT_STANDARD,
-/*  8 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_ALL_MATERIALS,
-/*  9 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_ALL_MATERIALS,
-/* 10 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_ALL_MATERIALS,
-/* 11 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_ALL_MATERIALS,
-/* 12 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_AREA | FEATURE_FLAG_ALL_MATERIALS,
-/* 13 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_AREA | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_ALL_MATERIALS,
-/* 14 */ FEATURE_FLAG_LIGHT_SKY | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_AREA | FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_LIGHT_ENV | FEATURE_FLAG_LIGHT_PROJECTOR |  FEATURE_FLAG_ALL_MATERIALS,
+/*  1 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | MATERIALFEATUREFLAGS_LIT_STANDARD,
+/*  2 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_STANDARD,
+/*  3 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | MATERIALFEATUREFLAGS_LIT_STANDARD,
+/*  3 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_STANDARD,
+/*  5 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | MATERIALFEATUREFLAGS_LIT_STANDARD,
+/*  6 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | MATERIALFEATUREFLAGS_LIT_STANDARD,
+/*  7 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | LIGHTFEATUREFLAGS_PROJECTOR | MATERIALFEATUREFLAGS_LIT_STANDARD,
+/*  8 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | FEATURE_FLAG_ALL_MATERIALS,
+/*  9 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | FEATURE_FLAG_ALL_MATERIALS,
+/* 10 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | FEATURE_FLAG_ALL_MATERIALS,
+/* 11 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | FEATURE_FLAG_ALL_MATERIALS,
+/* 12 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | FEATURE_FLAG_ALL_MATERIALS,
+/* 13 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | FEATURE_FLAG_ALL_MATERIALS,
+/* 14 */ LIGHTFEATUREFLAGS_SKY | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_AREA | LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_ENV | LIGHTFEATUREFLAGS_PROJECTOR |  FEATURE_FLAG_ALL_MATERIALS,
 /* 15 */ 0xFFFFFFFF
 };
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/LightingConvexHullUtils.hlsl

     p0 = center + (vA + vB - vC);       // center + vA is center of face when scaleXY is 1.0
     float3 vNout = cross( vB2, 0.5*(vA-vA2) - vC );
 
-#if USE_LEFTHAND_CAMERASPACE
+#if USE_LEFT_HAND_CAMERA_SPACE
     vNout = -vNout;
 #endif
 
 #endif
 
     // enlarge sphere so it overlaps the center of the tile assuming it overlaps the tile to begin with.
-#if USE_LEFTHAND_CAMERASPACE
+#if USE_LEFT_HAND_CAMERA_SPACE
     float sphRadius = sphRadiusIn + (sphCen.z+offs)*halfTileSizeAtZDistOne;
 #else
     float sphRadius = sphRadiusIn - (sphCen.z-offs)*halfTileSizeAtZDistOne;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

         }
 
         [GenerateHLSL]
-        public class LightFeatureFlags
+        public enum LightFeatureFlags
-            public static uint FEATURE_FLAG_LIGHT_PUNCTUAL    = 1 << 0;
-            public static uint FEATURE_FLAG_LIGHT_AREA        = 1 << 1;
-            public static uint FEATURE_FLAG_LIGHT_DIRECTIONAL = 1 << 2;
-            public static uint FEATURE_FLAG_LIGHT_PROJECTOR   = 1 << 3;
-            public static uint FEATURE_FLAG_LIGHT_ENV         = 1 << 4;
-            public static uint FEATURE_FLAG_LIGHT_SKY         = 1 << 5;
+            Punctual    = 1 << 0,
+            Area        = 1 << 1,
+            Directional = 1 << 2,
+            Projector   = 1 << 3,
+            Env         = 1 << 4,
+            Sky         = 1 << 5
-            public static int MAX_NR_LIGHTS_PER_CAMERA = 1024;
-            public static int MAX_NR_BIGTILE_LIGHTS_PLUSONE = 512;      // may be overkill but the footprint is 2 bits per pixel using uint16.
-            public static float VIEWPORT_SCALE_Z = 1.0f;
+            public static int s_MaxNrLightsPerCamera = 1024;
+            public static int s_MaxNrBigTileLightsPlusOne = 512;      // may be overkill but the footprint is 2 bits per pixel using uint16.
+            public static float s_ViewportScaleZ = 1.0f;
-            public static int USE_LEFTHAND_CAMERASPACE = 1;
+            public static int s_UseLeftHandCameraSpace = 1;
-            public static int TILE_SIZE_FPTL = 16;
-            public static int TILE_SIZE_CLUSTERED = 32;
-
-            // flags
-            public static int IS_CIRCULAR_SPOT_SHAPE = 1;
-            public static int HAS_COOKIE_TEXTURE = 2;
-            public static int IS_BOX_PROJECTED = 4;
-            public static int HAS_SHADOW = 8;
+            public static int s_TileSizeFptl = 16;
+            public static int s_TileSizeClustered = 32;
-            public static int NUM_FEATURE_VARIANTS = 16;
+            public static int s_NumFeatureVariants = 16;
         }
 
         [GenerateHLSL]
             static int s_shadeOpaqueDirectFptlKernel;
             static int s_shadeOpaqueDirectClusteredDebugDisplayKernel;
             static int s_shadeOpaqueDirectFptlDebugDisplayKernel;
-            static int[] s_shadeOpaqueIndirectClusteredKernels = new int[LightDefinitions.NUM_FEATURE_VARIANTS];
-            static int[] s_shadeOpaqueIndirectFptlKernels = new int[LightDefinitions.NUM_FEATURE_VARIANTS];
+            static int[] s_shadeOpaqueIndirectClusteredKernels = new int[LightDefinitions.s_NumFeatureVariants];
+            static int[] s_shadeOpaqueIndirectFptlKernels = new int[LightDefinitions.s_NumFeatureVariants];
 
             static ComputeBuffer s_LightVolumeDataBuffer = null;
             static ComputeBuffer s_ConvexBoundsBuffer = null;
 
             int GetNumTileFtplX(Camera camera)
             {
-                return (camera.pixelWidth + (LightDefinitions.TILE_SIZE_FPTL - 1)) / LightDefinitions.TILE_SIZE_FPTL;
+                return (camera.pixelWidth + (LightDefinitions.s_TileSizeFptl - 1)) / LightDefinitions.s_TileSizeFptl;
-                return (camera.pixelHeight + (LightDefinitions.TILE_SIZE_FPTL - 1)) / LightDefinitions.TILE_SIZE_FPTL;
+                return (camera.pixelHeight + (LightDefinitions.s_TileSizeFptl - 1)) / LightDefinitions.s_TileSizeFptl;
-                return (camera.pixelWidth + (LightDefinitions.TILE_SIZE_CLUSTERED - 1)) / LightDefinitions.TILE_SIZE_CLUSTERED;
+                return (camera.pixelWidth + (LightDefinitions.s_TileSizeClustered - 1)) / LightDefinitions.s_TileSizeClustered;
-                return (camera.pixelHeight + (LightDefinitions.TILE_SIZE_CLUSTERED - 1)) / LightDefinitions.TILE_SIZE_CLUSTERED;
+                return (camera.pixelHeight + (LightDefinitions.s_TileSizeClustered - 1)) / LightDefinitions.s_TileSizeClustered;
             }
 
             bool GetFeatureVariantsEnabled()
                 s_AABBBoundsBuffer = new ComputeBuffer(2 * k_MaxLightsOnScreen, 3 * sizeof(float));
                 s_ConvexBoundsBuffer = new ComputeBuffer(k_MaxLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(SFiniteLightBound)));
                 s_LightVolumeDataBuffer = new ComputeBuffer(k_MaxLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightVolumeData)));
-                s_DispatchIndirectBuffer = new ComputeBuffer(LightDefinitions.NUM_FEATURE_VARIANTS * 3, sizeof(uint), ComputeBufferType.IndirectArguments);
+                s_DispatchIndirectBuffer = new ComputeBuffer(LightDefinitions.s_NumFeatureVariants * 3, sizeof(uint), ComputeBufferType.IndirectArguments);
 
                 if (m_TileSettings.enableClustered)
                 {
                 s_shadeOpaqueDirectClusteredDebugDisplayKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Direct_Clustered_DebugDisplay");
                 s_shadeOpaqueDirectFptlDebugDisplayKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Direct_Fptl_DebugDisplay");
 
-                for (int variant = 0; variant < LightDefinitions.NUM_FEATURE_VARIANTS; variant++)
+                for (int variant = 0; variant < LightDefinitions.s_NumFeatureVariants; variant++)
                 {
                     s_shadeOpaqueIndirectClusteredKernels[variant] = shadeOpaqueShader.FindKernel("ShadeOpaque_Indirect_Clustered_Variant" + variant);
                     s_shadeOpaqueIndirectFptlKernels[variant] = shadeOpaqueShader.FindKernel("ShadeOpaque_Indirect_Fptl_Variant" + variant);
 
             public void AllocResolutionDependentBuffers(int width, int height)
             {
-                var nrTilesX = (width + LightDefinitions.TILE_SIZE_FPTL - 1) / LightDefinitions.TILE_SIZE_FPTL;
-                var nrTilesY = (height + LightDefinitions.TILE_SIZE_FPTL - 1) / LightDefinitions.TILE_SIZE_FPTL;
+                var nrTilesX = (width + LightDefinitions.s_TileSizeFptl - 1) / LightDefinitions.s_TileSizeFptl;
+                var nrTilesY = (height + LightDefinitions.s_TileSizeFptl - 1) / LightDefinitions.s_TileSizeFptl;
-                s_TileList = new ComputeBuffer((int)LightDefinitions.NUM_FEATURE_VARIANTS * nrTiles, sizeof(uint));
+                s_TileList = new ComputeBuffer((int)LightDefinitions.s_NumFeatureVariants * nrTiles, sizeof(uint));
-                    var nrClustersX = (width + LightDefinitions.TILE_SIZE_CLUSTERED - 1) / LightDefinitions.TILE_SIZE_CLUSTERED;
-                    var nrClustersY = (height + LightDefinitions.TILE_SIZE_CLUSTERED - 1) / LightDefinitions.TILE_SIZE_CLUSTERED;
+                    var nrClustersX = (width + LightDefinitions.s_TileSizeClustered - 1) / LightDefinitions.s_TileSizeClustered;
+                    var nrClustersY = (height + LightDefinitions.s_TileSizeClustered - 1) / LightDefinitions.s_TileSizeClustered;
                     var nrClusterTiles = nrClustersX * nrClustersY;
 
                     s_PerVoxelOffset = new ComputeBuffer((int)LightCategory.Count * (1 << k_Log2NumClusters) * nrClusterTiles, sizeof(uint));
                     var nrBigTilesX = (width + 63) / 64;
                     var nrBigTilesY = (height + 63) / 64;
                     var nrBigTiles = nrBigTilesX * nrBigTilesY;
-                    s_BigTileLightList = new ComputeBuffer(LightDefinitions.MAX_NR_BIGTILE_LIGHTS_PLUSONE * nrBigTiles, sizeof(uint));
+                    s_BigTileLightList = new ComputeBuffer(LightDefinitions.s_MaxNrBigTileLightsPlusOne * nrBigTiles, sizeof(uint));
                 }
             }
 
-                bool isLeftHand = ((int)LightDefinitions.USE_LEFTHAND_CAMERASPACE) != 0;
+                bool isLeftHand = ((int)LightDefinitions.s_UseLeftHandCameraSpace) != 0;
                 if (isLeftHand) flip.SetColumn(2, new Vector4(0.0f, 0.0f, -1.0f, 0.0f));
                 return flip;
             }
                     lightVolumeData.lightPos = worldToView.MultiplyPoint(lightPos);
                     lightVolumeData.radiusSq = range * range;
                     lightVolumeData.cotan = cota;
-                    lightVolumeData.featureFlags = (gpuLightType == GPULightType.Spot) ? LightFeatureFlags.FEATURE_FLAG_LIGHT_PUNCTUAL
-                                                                                       : LightFeatureFlags.FEATURE_FLAG_LIGHT_PROJECTOR;
+                    lightVolumeData.featureFlags = (gpuLightType == GPULightType.Spot) ? (uint)LightFeatureFlags.Punctual
+                                                                                       : (uint)LightFeatureFlags.Projector;
                 }
                 else if (gpuLightType == GPULightType.Point)
                 {
                     lightVolumeData.lightAxisZ = vz;
                     lightVolumeData.lightPos = bound.center;
                     lightVolumeData.radiusSq = range * range;
-                    lightVolumeData.featureFlags = LightFeatureFlags.FEATURE_FLAG_LIGHT_PUNCTUAL;
+                    lightVolumeData.featureFlags = (uint)LightFeatureFlags.Punctual;
                 }
                 else if (gpuLightType == GPULightType.Rectangle)
                 {
                     lightVolumeData.lightAxisZ = zAxisVS;
                     lightVolumeData.boxInnerDist = dimensions;
                     lightVolumeData.boxInvRange.Set(1e5f, 1e5f, 1e5f);
-                    lightVolumeData.featureFlags = LightFeatureFlags.FEATURE_FLAG_LIGHT_AREA;
+                    lightVolumeData.featureFlags = (uint)LightFeatureFlags.Area;
                 }
                 else if (gpuLightType == GPULightType.Line)
                 {
                     lightVolumeData.lightAxisZ = zAxisVS;
                     lightVolumeData.boxInnerDist = new Vector3(lightData.size.x * 0.5f, 0.01f, 0.01f);
                     lightVolumeData.boxInvRange.Set(1.0f / radius, 1.0f / radius, 1.0f / radius);
-                    lightVolumeData.featureFlags = LightFeatureFlags.FEATURE_FLAG_LIGHT_AREA;
+                    lightVolumeData.featureFlags = (uint)LightFeatureFlags.Area;
                 }
                 else if (gpuLightType == GPULightType.ProjectorOrtho)
                 {
                     lightVolumeData.lightAxisZ   = zAxisVS;
                     lightVolumeData.boxInnerDist = halfDims;                                                  // No idea what this is. Document your code
                     lightVolumeData.boxInvRange.Set(1.0f / halfDims.x, 1.0f / halfDims.y, 1.0f / halfDims.z); // No idea what this is. Document your code
-                    lightVolumeData.featureFlags = LightFeatureFlags.FEATURE_FLAG_LIGHT_PROJECTOR;
+                    lightVolumeData.featureFlags = (uint)LightFeatureFlags.Projector;
                 }
                 else
                 {
 
                 lightVolumeData.lightCategory = (uint)LightCategory.Env;
                 lightVolumeData.lightVolume = (uint)lightVolumeType;
-                lightVolumeData.featureFlags = LightFeatureFlags.FEATURE_FLAG_LIGHT_ENV;
+                lightVolumeData.featureFlags = (uint)LightFeatureFlags.Env;
 
                 lightVolumeData.lightPos = Cw;
                 lightVolumeData.lightAxisX = vx;
                         uint baseFeatureFlags = 0;
                         if (m_lightList.directionalLights.Count > 0)
                         {
-                            baseFeatureFlags |= LightFeatureFlags.FEATURE_FLAG_LIGHT_DIRECTIONAL;
+                            baseFeatureFlags |= (uint)LightFeatureFlags.Directional;
-                            baseFeatureFlags |= LightFeatureFlags.FEATURE_FLAG_LIGHT_SKY;
+                            baseFeatureFlags |= (uint)LightFeatureFlags.Sky;
                         }
                         cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_DispatchIndirectBuffer", s_DispatchIndirectBuffer);
                         cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, "g_TileList", s_TileList);
 
                             int numVariants = 1;
                             if (enableFeatureVariants)
-                                numVariants = LightDefinitions.NUM_FEATURE_VARIANTS;
+                                numVariants = LightDefinitions.s_NumFeatureVariants;
 
                             for (int variant = 0; variant < numVariants; variant++)
                             {

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs.hlsl

 //
 // UnityEngine.Experimental.Rendering.HDPipeline.TilePass.LightFeatureFlags:  static fields
 //
-#define FEATURE_FLAG_LIGHT_PUNCTUAL (1)
-#define FEATURE_FLAG_LIGHT_AREA (2)
-#define FEATURE_FLAG_LIGHT_DIRECTIONAL (4)
-#define FEATURE_FLAG_LIGHT_PROJECTOR (8)
-#define FEATURE_FLAG_LIGHT_ENV (16)
-#define FEATURE_FLAG_LIGHT_SKY (32)
+#define LIGHTFEATUREFLAGS_PUNCTUAL (1)
+#define LIGHTFEATUREFLAGS_AREA (2)
+#define LIGHTFEATUREFLAGS_DIRECTIONAL (4)
+#define LIGHTFEATUREFLAGS_PROJECTOR (8)
+#define LIGHTFEATUREFLAGS_ENV (16)
+#define LIGHTFEATUREFLAGS_SKY (32)
-#define MAX_NR_BIGTILE_LIGHTS_PLUSONE (512)
+#define MAX_NR_BIG_TILE_LIGHTS_PLUS_ONE (512)
-#define USE_LEFTHAND_CAMERASPACE (1)
+#define USE_LEFT_HAND_CAMERA_SPACE (1)
-#define IS_CIRCULAR_SPOT_SHAPE (1)
-#define HAS_COOKIE_TEXTURE (2)
-#define IS_BOX_PROJECTED (4)
-#define HAS_SHADOW (8)
 #define NUM_FEATURE_VARIANTS (16)
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.TilePass.SFiniteLightBound

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePassLoop.hlsl

     uint i = 0; // Declare once to avoid the D3D11 compiler warning.
 
 #ifdef PROCESS_DIRECTIONAL_LIGHT
-    if(featureFlags & FEATURE_FLAG_LIGHT_DIRECTIONAL)
+    if(featureFlags & LIGHTFEATUREFLAGS_DIRECTIONAL)
     {
         for(i = 0; i < _DirectionalLightCount; ++i)
         {
 #endif
 
 #ifdef PROCESS_PUNCTUAL_LIGHT
-    if(featureFlags & FEATURE_FLAG_LIGHT_PUNCTUAL)
+    if(featureFlags & LIGHTFEATUREFLAGS_PUNCTUAL)
     {
         // TODO: Convert the for loop below to a while on each type as we know we are sorted!
         uint punctualLightStart;
 #endif
 
 #ifdef PROCESS_AREA_LIGHT
-    if(featureFlags & FEATURE_FLAG_LIGHT_AREA)
+    if(featureFlags & LIGHTFEATUREFLAGS_AREA)
     {
         // TODO: Convert the for loop below to a while on each type as we know we are sorted!
         uint areaLightStart;
 #endif
 
 #ifdef PROCESS_PROJECTOR_LIGHT
-    if(featureFlags & FEATURE_FLAG_LIGHT_PROJECTOR)
+    if(featureFlags & LIGHTFEATUREFLAGS_PROJECTOR)
     {
         // TODO: Convert the for loop below to a while on each type as we know we are sorted!
         uint projectorLightStart;
     float3 iblSpecularLighting = float3(0.0, 0.0, 0.0);
 
     // Only apply sky IBL if the sky texture is available.
-    if(featureFlags & FEATURE_FLAG_LIGHT_SKY)
+    if(featureFlags & LIGHTFEATUREFLAGS_SKY)
     {
         if(_EnvLightSkyEnabled)
         {
     }
 
 
-    if(featureFlags & FEATURE_FLAG_LIGHT_ENV)
+    if(featureFlags & LIGHTFEATUREFLAGS_ENV)
     {
         uint envLightStart;
         uint envLightCount;
                 out float3 diffuseLighting,
                 out float3 specularLighting)
 {
-    LightLoopContext context;    
+    LightLoopContext context;
     // Note: When we ImageLoad outside of texture size, the value returned by Load is 0 (Note: On Metal maybe it clamp to value of texture which is also fine)
     // We use this property to have a neutral value for AO that doesn't consume a sampler and work also with compute shader (i.e use ImageLoad)
     // We store inverse AO so neutral is black. So either we sample inside or outside the texture it return 0 in case of neutral

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/lightlistbuild-bigtile.compute

 #define EXACT_EDGE_TESTS
 #define PERFORM_SPHERICAL_INTERSECTION_TESTS
 
-#define MAX_NR_BIGTILE_LIGHTS				(MAX_NR_BIGTILE_LIGHTS_PLUSONE-1)
+#define MAX_NR_BIGTILE_LIGHTS				(MAX_NR_BIG_TILE_LIGHTS_PLUS_ONE-1)
 
 
 uniform int g_iNrVisibLights;
 
 
 // 2kB (room for roughly 30 wavefronts)
-groupshared unsigned int lightsListLDS[MAX_NR_BIGTILE_LIGHTS_PLUSONE];
+groupshared unsigned int lightsListLDS[MAX_NR_BIG_TILE_LIGHTS_PLUS_ONE];
 groupshared uint lightOffs;
 
 
 	float fSy = g_mScrProjection[1].y;
 	float fCy = g_mScrProjection[1].z;
 
-#if USE_LEFTHAND_CAMERASPACE
+#if USE_LEFT_HAND_CAMERA_SPACE
 	return fLinDepth*float3( ((v2ScrPos.x-fCx)/fSx), ((v2ScrPos.y-fCy)/fSy), 1.0 );
 #else
 	return fLinDepth*float3( -((v2ScrPos.x+fCx)/fSx), -((v2ScrPos.y+fCy)/fSy), 1.0 );
 
 
 	// sort lights
-	SORTLIST(lightsListLDS, iNrCoarseLights, MAX_NR_BIGTILE_LIGHTS_PLUSONE, t, NR_THREADS);
+	SORTLIST(lightsListLDS, iNrCoarseLights, MAX_NR_BIG_TILE_LIGHTS_PLUS_ONE, t, NR_THREADS);
 
 	if(t==0) lightOffs = 0;
 	GroupMemoryBarrierWithGroupSync();
 	int offs = tileIDX.y*nrBigTilesX + tileIDX.x;
 
 	for(i=t; i<(iNrCoarseLights+1); i+=NR_THREADS)
-		g_vLightList[MAX_NR_BIGTILE_LIGHTS_PLUSONE*offs + i] = i==0 ? iNrCoarseLights : lightsListLDS[max(i-1, 0)];
+		g_vLightList[MAX_NR_BIG_TILE_LIGHTS_PLUS_ONE*offs + i] = i==0 ? iNrCoarseLights : lightsListLDS[max(i-1, 0)];
 }
 
 
-#if USE_LEFTHAND_CAMERASPACE
+#if USE_LEFT_HAND_CAMERA_SPACE
 	float3 V = GetViewPosFromLinDepth( screenCoordinate, 1.0);
 #else
 	float3 V = GetViewPosFromLinDepth( screenCoordinate, -1.0);
 	float x = (i&1)==0 ? viTilLL.x : viTilUR.x;
 	float y = (i&2)==0 ? viTilLL.y : viTilUR.y;
 	float z = (i&4)==0 ? g_fNearPlane : fTileFarPlane;
-#if !USE_LEFTHAND_CAMERASPACE
+#if !USE_LEFT_HAND_CAMERA_SPACE
 	z = -z;
 #endif
 	return GetViewPosFromLinDepth( float2(x, y), z);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/lightlistbuild-clustered.compute

 	float fSy = g_mScrProjection[1].y;
 	float fCy = g_mScrProjection[1].z;
 
-#if USE_LEFTHAND_CAMERASPACE
+#if USE_LEFT_HAND_CAMERA_SPACE
 	return fLinDepth*float3( ((v2ScrPos.x-fCx)/fSx), ((v2ScrPos.y-fCy)/fSy), 1.0 );
 #else
 	return fLinDepth*float3( -((v2ScrPos.x+fCx)/fSx), -((v2ScrPos.y+fCy)/fSy), 1.0 );
 
 	int NrBigTilesX = (nrTilesX+((1<<log2BigTileToClustTileRatio)-1))>>log2BigTileToClustTileRatio;
 	const int bigTileIdx = (tileIDX.y>>log2BigTileToClustTileRatio)*NrBigTilesX + (tileIDX.x>>log2BigTileToClustTileRatio);		// map the idx to 64x64 tiles
-	int nrBigTileLights = g_vBigTileLightList[MAX_NR_BIGTILE_LIGHTS_PLUSONE*bigTileIdx+0];
+	int nrBigTileLights = g_vBigTileLightList[MAX_NR_BIG_TILE_LIGHTS_PLUS_ONE*bigTileIdx+0];
-		int l = g_vBigTileLightList[MAX_NR_BIGTILE_LIGHTS_PLUSONE*bigTileIdx+l0+1];
+		int l = g_vBigTileLightList[MAX_NR_BIG_TILE_LIGHTS_PLUS_ONE*bigTileIdx+l0+1];
 #else
 	for(int l=(int) t; l<(int) g_iNrVisibLights; l += NR_THREADS)
 	{
 
 #ifdef ENABLE_DEPTH_TEXTURE_BACKPLANE
 
-#if USE_LEFTHAND_CAMERASPACE
+#if USE_LEFT_HAND_CAMERA_SPACE
 	float fTileFarPlane = GetLinearDepth(dpt_ma);
 #else
 	float fTileFarPlane = -GetLinearDepth(dpt_ma);
 #ifdef PERFORM_SPHERICAL_INTERSECTION_TESTS
 int SphericalIntersectionTests(uint threadID, int iNrCoarseLights, float2 screenCoordinate)
 {
-#if USE_LEFTHAND_CAMERASPACE
+#if USE_LEFT_HAND_CAMERA_SPACE
 	float3 V = GetViewPosFromLinDepth( screenCoordinate, 1.0);
 #else
 	float3 V = GetViewPosFromLinDepth( screenCoordinate, -1.0);
 	float x = (i&1)==0 ? viTilLL.x : viTilUR.x;
 	float y = (i&2)==0 ? viTilLL.y : viTilUR.y;
 	float z = (i&4)==0 ? g_fNearPlane : fTileFarPlane;
-#if !USE_LEFTHAND_CAMERASPACE
+#if !USE_LEFT_HAND_CAMERA_SPACE
 	z = -z;
 #endif
 	return GetViewPosFromLinDepth( float2(x, y), z);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/lightlistbuild.compute

 	float fSy = g_mScrProjection[1].y;
 	float fCy = g_mScrProjection[1].z;
 
-#if USE_LEFTHAND_CAMERASPACE
+#if USE_LEFT_HAND_CAMERA_SPACE
 	return fLinDepth*float3( ((v2ScrPos.x-fCx)/fSx), ((v2ScrPos.y-fCy)/fSy), 1.0 );
 #else
 	return fLinDepth*float3( -((v2ScrPos.x+fCx)/fSx), -((v2ScrPos.y+fCy)/fSy), 1.0 );
 
 	int NrBigTilesX = (nrTilesX+((1<<log2BigTileToTileRatio)-1))>>log2BigTileToTileRatio;
 	const int bigTileIdx = (tileIDX.y>>log2BigTileToTileRatio)*NrBigTilesX + (tileIDX.x>>log2BigTileToTileRatio);		// map the idx to 64x64 tiles
-	int nrBigTileLights = g_vBigTileLightList[MAX_NR_BIGTILE_LIGHTS_PLUSONE*bigTileIdx+0];
+	int nrBigTileLights = g_vBigTileLightList[MAX_NR_BIG_TILE_LIGHTS_PLUS_ONE*bigTileIdx+0];
-		int l = g_vBigTileLightList[MAX_NR_BIGTILE_LIGHTS_PLUSONE*bigTileIdx+l0+1];
+		int l = g_vBigTileLightList[MAX_NR_BIG_TILE_LIGHTS_PLUS_ONE*bigTileIdx+l0+1];
 #else
 	for(int l=(int) t; l<(int) g_iNrVisibLights; l += NR_THREADS)
 	{
 		uint featureFlags = g_BaseFeatureFlags | ldsFeatureFlags;
 		if(ldsZMax < ldsZMin)	// is background pixel
 		{
-			featureFlags &= ~(FEATURE_FLAG_LIGHT_PUNCTUAL | FEATURE_FLAG_LIGHT_AREA | FEATURE_FLAG_LIGHT_DIRECTIONAL | FEATURE_FLAG_LIGHT_ENV | 0xFFFFF);	// list of features that are not enabled on background
+			featureFlags &= ~(LIGHTFEATUREFLAGS_PUNCTUAL | LIGHTFEATUREFLAGS_AREA | LIGHTFEATUREFLAGS_DIRECTIONAL | LIGHTFEATUREFLAGS_ENV | 0xFFFFF);	// list of features that are not enabled on background
 		}
 
 		uint variant = FeatureFlagsToTileVariant(featureFlags);
 	GroupMemoryBarrierWithGroupSync();
 #endif
 
-#if USE_LEFTHAND_CAMERASPACE
+#if USE_LEFT_HAND_CAMERA_SPACE
 	float3 V = GetViewPosFromLinDepth( screenCoordinate, 1.0);
 #else
 	float3 V = GetViewPosFromLinDepth( screenCoordinate, -1.0);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/scrbound.compute

 					vMax.xy = bMa ? min(vMax.xy, vMa) : vMax.xy;
 				}
 
-#if USE_LEFTHAND_CAMERASPACE
+#if USE_LEFT_HAND_CAMERA_SPACE
 				if((center.z-radius)>0.0)
 				{
 					float4 vPosF = mul(g_mProjection, float4(0,0,center.z-radius,1));
 	float4 planeY = EvalPlanePair(validY, float2(pos_view_space.y, pos_view_space.z), r);
 
 
-#if USE_LEFTHAND_CAMERASPACE
+#if USE_LEFT_HAND_CAMERA_SPACE
 	planeX = planeX.zwxy;		// need to swap left/right and top/bottom planes when using left hand system
 	planeY = planeY.zwxy;
 #endif

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.cs

         };
 
         [GenerateHLSL]
-        public class MaterialFeatureFlags
+        public enum MaterialFeatureFlags
-            public static uint FEATURE_FLAG_MATERIAL_LIT_SSS      = 1 << 12;
-            public static uint FEATURE_FLAG_MATERIAL_LIT_STANDARD = 1 << 13;
-            public static uint FEATURE_FLAG_MATERIAL_LIT_SPECULAR = 1 << 14;
-            public static uint FEATURE_FLAG_MATERIAL_LIT_ANISO    = 1 << 15;
+            LitSSS      = 1 << 12,
+            LitStandard = 1 << 13,
+            LitSpecular = 1 << 14,
+            LitAniso    = 1 << 15
         }
 
         //-----------------------------------------------------------------------------

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.cs.hlsl

 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit+MaterialFeatureFlags:  static fields
 //
-#define FEATURE_FLAG_MATERIAL_LIT_SSS (4096)
-#define FEATURE_FLAG_MATERIAL_LIT_STANDARD (8192)
-#define FEATURE_FLAG_MATERIAL_LIT_SPECULAR (16384)
-#define FEATURE_FLAG_MATERIAL_LIT_ANISO (32768)
+#define MATERIALFEATUREFLAGS_LIT_SSS (4096)
+#define MATERIALFEATUREFLAGS_LIT_STANDARD (8192)
+#define MATERIALFEATUREFLAGS_LIT_SPECULAR (16384)
+#define MATERIALFEATUREFLAGS_LIT_ANISO (32768)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit+SurfaceData:  static fields

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 
     bsdfData.roughness = PerceptualRoughnessToRoughness(bsdfData.perceptualRoughness);
 
-    int supportsStandard = (featureFlags & (FEATURE_FLAG_MATERIAL_LIT_STANDARD | FEATURE_FLAG_MATERIAL_LIT_ANISO)) != 0;
-    int supportsSSS = (featureFlags & (FEATURE_FLAG_MATERIAL_LIT_SSS)) != 0;
-    int supportsSpecular = (featureFlags & (FEATURE_FLAG_MATERIAL_LIT_SPECULAR)) != 0;
+    int supportsStandard = (featureFlags & (MATERIALFEATUREFLAGS_LIT_STANDARD | MATERIALFEATUREFLAGS_LIT_ANISO)) != 0;
+    int supportsSSS = (featureFlags & (MATERIALFEATUREFLAGS_LIT_SSS)) != 0;
+    int supportsSpecular = (featureFlags & (MATERIALFEATUREFLAGS_LIT_SPECULAR)) != 0;
 
     if(supportsStandard + supportsSSS + supportsSpecular > 1)
     {
         float3 tangentWS = UnpackNormalOctEncode(float2(inGBuffer2.rg * 2.0 - 1.0));
         FillMaterialIdStandardData(baseColor, specular, metallic, bsdfData.roughness, bsdfData.normalWS, tangentWS, anisotropy, bsdfData);
 
-        if ((featureFlags & FEATURE_FLAG_MATERIAL_LIT_ANISO) && (featureFlags & FEATURE_FLAG_MATERIAL_LIT_STANDARD) == 0 || anisotropy > 0)
+        if ((featureFlags & MATERIALFEATUREFLAGS_LIT_ANISO) && (featureFlags & MATERIALFEATUREFLAGS_LIT_STANDARD) == 0 || anisotropy > 0)
         {
             bsdfData.materialId = MATERIALID_LIT_ANISO;
         }
     uint featureFlags = 0;
     if (materialId == MATERIALID_LIT_STANDARD)
     {
-        featureFlags |= (anisotropy > 0) ? FEATURE_FLAG_MATERIAL_LIT_ANISO : FEATURE_FLAG_MATERIAL_LIT_STANDARD;
+        featureFlags |= (anisotropy > 0) ? MATERIALFEATUREFLAGS_LIT_ANISO : MATERIALFEATUREFLAGS_LIT_STANDARD;
-        featureFlags |= FEATURE_FLAG_MATERIAL_LIT_SSS;
+        featureFlags |= MATERIALFEATUREFLAGS_LIT_SSS;
-        featureFlags |= FEATURE_FLAG_MATERIAL_LIT_SPECULAR;
+        featureFlags |= MATERIALFEATUREFLAGS_LIT_SPECULAR;
     }
     return featureFlags;
 }

Assets/ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/HDRenderPipelineResources.asset

   buildPerVoxelLightListShader: {fileID: 7200000, guid: 0bb1b7e0ddcd5c44baf3ddc7456eb196,
     type: 3}
   shadeOpaqueShader: {fileID: 7200000, guid: 0b64f79746d2daf4198eaf6eab9af259, type: 3}
-  drawGaussianProfileShader: {fileID: 4800000, guid: 2e8a76823cb2af944b4b45169f2649f9,
-    type: 3}
-  drawTransmittanceGraphShader: {fileID: 4800000, guid: 4517edda0467bb14489d5eccc9973ba2,
-    type: 3}
   blitCubemap: {fileID: 4800000, guid: d05913e251bed7a4992c921c62e1b647, type: 3}
   buildProbabilityTables: {fileID: 7200000, guid: b9f26cf340afe9145a699753531b2a4c,
     type: 3}

Assets/ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/HDRenderPipelineResources.asset.meta

 fileFormatVersion: 2
 guid: 42086e81f4f0c724f96f7f09cc995354
-timeCreated: 1496162188
+timeCreated: 1496931626
 licenseType: Pro
 NativeFormatImporter:
   mainObjectFileID: 11400000

Assets/ScriptableRenderPipeline/ShaderGenerator/Editor/ShaderTypeGeneration.cs

                 {
                     if (field.FieldType.IsPrimitive)
                     {
-                        m_Statics[field.Name] = field.GetValue(null).ToString();
+                        // Unity convention is to start static of constant with k_ or s_, remove this part
+                        string name = InsertUnderscore(field.Name);
+                        if (name.StartsWith("k_") || name.StartsWith("s_"))
+                        {
+                            name = name.Substring(2);
+                        }
+                        string defineName = name.ToUpper();
+                        m_Statics[defineName] = field.GetValue(null).ToString();
                     }
                     continue;
                 }