Implemented lighting debug in the shader.

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/HDRenderPipelineDebug.cs

         public MaterialDebugParameters materialDebugParameters = new MaterialDebugParameters();
         public LightingDebugParameters lightingDebugParameters = new LightingDebugParameters();
         public RenderingDebugParameters renderingDebugParametrs = new RenderingDebugParameters();
+
+        public void OnValidate()
+        {
+            lightingDebugParameters.OnValidate();
+        }
     }
 
 
         VisualizeShadowMap
     }
 
+    [GenerateHLSL]
     public enum LightingDebugMode
     {
         None,
 
         public LightingDebugMode    lightingDebugMode = LightingDebugMode.None;
         public bool                 overrideSmoothness = false;
-        public float                overrideSmoothnessValue = 1.0f;
+        public float                overrideSmoothnessValue = 0.5f;
+
+        public void OnValidate()
+        {
+            overrideSmoothnessValue = Mathf.Clamp(overrideSmoothnessValue, 0.0f, 1.0f);
+        }
     }
 }

Assets/ScriptableRenderLoop/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs

             // Global debug parameters
             public readonly GUIContent debugging = new GUIContent("Debugging");
             public readonly GUIContent debugOverlayRatio = new GUIContent("Overlay Ratio");
-            public readonly GUIContent debugParameters = new GUIContent("Debug Parameters");
+            public readonly GUIContent materialDebugLabel = new GUIContent("Material Debug");
             public readonly GUIContent debugViewMaterial = new GUIContent("DebugView Material", "Display various properties of Materials.");
             public bool isDebugViewMaterialInit = false;
             public GUIContent[] debugViewMaterialStrings = null;
             RenderingDebugParametersUI(renderContext);
             LightingDebugParametersUI(renderContext, renderpipelineInstance);
 
+            EditorGUILayout.Space();
+
             EditorGUI.indentLevel--;
         }
 
-            m_ShowMaterialDebug.boolValue = EditorGUILayout.Foldout(m_ShowMaterialDebug.boolValue, styles.debugParameters);
+            m_ShowMaterialDebug.boolValue = EditorGUILayout.Foldout(m_ShowMaterialDebug.boolValue, styles.materialDebugLabel);
             if (!m_ShowMaterialDebug.boolValue)
                 return;
 
                 HackSetDirty(renderContext); // Repaint
             }
             EditorGUI.indentLevel--;
-
-            EditorGUILayout.Space();
-
         }
 
         private void RenderingDebugParametersUI(HDRenderPipeline renderContext)
             EditorGUILayout.PropertyField(m_DisplayTransparentObjects, styles.displayTransparentObjects);
             EditorGUILayout.PropertyField(m_EnableDistortion, styles.enableDistortion);
             EditorGUI.indentLevel--;
-
-            EditorGUILayout.Space();
-            }
+        }
 
         private void SssSettingsUI(HDRenderPipeline pipe)
         {
             m_ShowLightingDebug.boolValue = EditorGUILayout.Foldout(m_ShowLightingDebug.boolValue, styles.lightingDebugParameters);
             if (!m_ShowLightingDebug.boolValue)
                 return;
+
+            EditorGUI.BeginChangeCheck();
 
             EditorGUI.indentLevel++;
             EditorGUILayout.PropertyField(m_DebugShadowEnabled, styles.shadowDebugEnable);
             }
             EditorGUI.indentLevel--;
 
-            EditorGUILayout.Space();
+            if (EditorGUI.EndChangeCheck())
+            {
+                HackSetDirty(renderContext);
+            }
         }
 
         private void SettingsUI(HDRenderPipeline renderContext)
+
+            EditorGUI.BeginChangeCheck();
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                HackSetDirty(renderContext); // Repaint
+            }
+
 
             SkySettingsUI(renderContext);
             SssSettingsUI(renderContext);

Assets/ScriptableRenderLoop/HDRenderPipeline/HDRenderPipeline.cs

         // Renderer Settings (per project)
         public RenderingParameters                      renderingParameters = new RenderingParameters();
         [SerializeField] ShadowSettings                 m_ShadowSettings = ShadowSettings.Default;
-        [SerializeField] SubsurfaceScatteringParameters m_SssParameters = SubsurfaceScatteringParameters.Default;
+        public SubsurfaceScatteringParameters           localSssParameters;
-        public SubsurfaceScatteringParameters sssParameters { get { return m_SssParameters; } }
         public TextureSettings textureSettings              { get { return m_TextureSettings; } set { m_TextureSettings = value; } }
 
         // Renderer Settings (per "scene")
                 return m_SkyParameters;
             }
         }
-
-        [SerializeField]
-        public SubsurfaceScatteringParameters localSssParameters;
-
+        
         public SubsurfaceScatteringParameters sssParameters
         {
             get
             m_ShadowSettings.directionalLightCascades = new Vector3(commonSettings.shadowCascadeSplit0, commonSettings.shadowCascadeSplit1, commonSettings.shadowCascadeSplit2);
             m_ShadowSettings.maxShadowDistance = commonSettings.shadowMaxDistance;
         }
+
+        public void OnValidate()
+        {
+            globalDebugParameters.OnValidate();
+        }
     }
 
     [Serializable]
             if (m_LightLoop != null)
                 m_LightLoop.NewFrame();
 
-            m_Owner. ApplyDebugParameters();
+            m_Owner.ApplyDebugParameters();
             m_Owner.UpdateCommonSettings();
 
             // Set Frame constant buffer
             RenderTargetIdentifier[] colorRTs = { m_CameraColorBufferRT, m_CameraSubsurfaceBufferRT };
 
             // Output split lighting for materials tagged with the SSS stencil bit.
-            m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, colorRTs, m_CameraStencilBufferRT, true);
+            m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, globalDebugParameters.lightingDebugParameters, colorRTs, m_CameraStencilBufferRT, true);
-            m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, colorRTs, m_CameraStencilBufferRT, false);
+            m_LightLoop.RenderDeferredLighting(hdCamera, renderContext, globalDebugParameters.lightingDebugParameters, colorRTs, m_CameraStencilBufferRT, false);
         }
 
         // Combines specular lighting and diffuse lighting with subsurface scattering.

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/LightLoop.cs

         public virtual void PushGlobalParams(Camera camera, ScriptableRenderContext loop) {}
 
         public virtual void RenderDeferredLighting(HDCamera hdCamera, ScriptableRenderContext renderContext,
+                                                   LightingDebugParameters lightDebugParameters,
                                                    RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier stencilBuffer,
                                                    bool outputSplitLighting) {}
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/Resources/Deferred.shader

             //-------------------------------------------------------------------------------------
 
             #include "Common.hlsl"
+            #include "Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/HDRenderPipelineDebug.cs.hlsl"
+            #include "Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/DebugLighting.hlsl"
 
             // Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
             // deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem),
 
             DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
 
-			TEXTURE2D_FLOAT(_CameraDepthTexture);
-			SAMPLER2D(sampler_CameraDepthTexture);
+            TEXTURE2D_FLOAT(_CameraDepthTexture);
+            SAMPLER2D(sampler_CameraDepthTexture);
 
             struct Attributes
             {

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TileLightLoopProducer.cs

 
 #endif
         [Serializable]
-        public struct TileSettings
+        public class TileSettings
         {
             public bool enableDrawLightBoundsDebug;
             public bool disableTileAndCluster; // For debug / test

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/Resources/shadeopaque.compute

-#pragma kernel ShadeOpaque_Fptl				SHADE_OPAQUE_ENTRY=ShadeOpaque_Fptl				USE_FPTL_LIGHTLIST=1
-#pragma kernel ShadeOpaque_Clustered		SHADE_OPAQUE_ENTRY=ShadeOpaque_Clustered		USE_CLUSTERED_LIGHTLIST=1
+#pragma kernel ShadeOpaque_Fptl				            SHADE_OPAQUE_ENTRY=ShadeOpaque_Fptl				        USE_FPTL_LIGHTLIST
+#pragma kernel ShadeOpaque_Fptl_DebugLighting			SHADE_OPAQUE_ENTRY=ShadeOpaque_Fptl_DebugLighting		USE_FPTL_LIGHTLIST        LIGHTING_DEBUG
+#pragma kernel ShadeOpaque_Clustered		            SHADE_OPAQUE_ENTRY=ShadeOpaque_Clustered		        USE_CLUSTERED_LIGHTLIST
+#pragma kernel ShadeOpaque_Clustered_DebugLighting		SHADE_OPAQUE_ENTRY=ShadeOpaque_Clustered_DebugLighting	USE_CLUSTERED_LIGHTLIST   LIGHTING_DEBUG
 
 // Split lighting is required for the SSS pass.
 // Not currently possible since we need to access the stencil buffer from the compute shader.
 //-------------------------------------------------------------------------------------
 
 #include "Common.hlsl"
+#include "Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/HDRenderPipelineDebug.cs.hlsl"
+#include "Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/DebugLighting.hlsl"
 
 // Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
 // deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem), 

Assets/ScriptableRenderLoop/HDRenderPipeline/Lighting/TilePass/TilePass.cs

             static int s_ClearVoxelAtomicKernel;
             static int s_shadeOpaqueClusteredKernel;
             static int s_shadeOpaqueFptlKernel;
+            static int s_shadeOpaqueClusteredDebugLightingKernel;
+            static int s_shadeOpaqueFptlDebugLightingKernel;
 
             static ComputeBuffer s_LightVolumeDataBuffer = null;
             static ComputeBuffer s_ConvexBoundsBuffer = null;
 
                 s_shadeOpaqueClusteredKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Clustered");
                 s_shadeOpaqueFptlKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Fptl");
+                s_shadeOpaqueClusteredDebugLightingKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Clustered_DebugLighting");
+                s_shadeOpaqueFptlDebugLightingKernel = shadeOpaqueShader.FindKernel("ShadeOpaque_Fptl_DebugLighting");
 
                 s_LightList = null;
 
                     Shader.SetGlobalFloat(name, value);
             }
 
+            private void SetGlobalVector(string name, Vector4 value)
+            {
+                if (activeComputeShader)
+                    activeCommandBuffer.SetComputeVectorParam(activeComputeShader, name, value);
+                else
+                    Shader.SetGlobalVector(name, value);
+            }
+
             private void SetGlobalVectorArray(string name, Vector4[] values)
             {
                 if (activeComputeShader)
             }
 #endif
 
+            private void SetupRenderingForDebug(LightingDebugParameters lightDebugParameters)
+            {
+                Utilities.SetKeyword(m_DeferredDirectMaterialSRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_DeferredDirectMaterialMRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_DeferredIndirectMaterialSRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_DeferredIndirectMaterialMRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_DeferredAllMaterialSRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_DeferredAllMaterialMRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_SingleDeferredMaterialSRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
+                Utilities.SetKeyword(m_SingleDeferredMaterialMRT, "LIGHTING_DEBUG", lightDebugParameters.lightingDebugMode != LightingDebugMode.None);
+
+                Vector4 debugModeAndAlbedo = new Vector4((float)lightDebugParameters.lightingDebugMode, lightDebugParameters.debugLightingAlbedo.r, lightDebugParameters.debugLightingAlbedo.g, lightDebugParameters.debugLightingAlbedo.b);
+                Vector4 debugSmoothness = new Vector4(lightDebugParameters.overrideSmoothness ? 1.0f : 0.0f, lightDebugParameters.overrideSmoothnessValue, 0.0f, 0.0f);
+                SetGlobalVector("_DebugLightModeAndAlbedo", debugModeAndAlbedo);
+                SetGlobalVector("_DebugLightingSmoothness", debugSmoothness);
+            }
+
+                                                        LightingDebugParameters lightDebugParameters,
                                                         RenderTargetIdentifier[] colorBuffers, RenderTargetIdentifier stencilBuffer,
                                                         bool outputSplitLighting)
             {
                     mousePixelCoord.y = (hdCamera.screenSize.y - 1.0f) - mousePixelCoord.y;
                 }
 #endif
+
                 using (new Utilities.ProfilingSample(m_PassSettings.disableTileAndCluster ? "SinglePass - Deferred Lighting Pass" : "TilePass - Deferred Lighting Pass", renderContext))
                 {
                     var cmd = new CommandBuffer();
+                    SetGlobalBuffer("g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
-                    SetGlobalBuffer("g_vLightListGlobal", bUseClusteredForDeferred ? s_PerVoxelLightLists : s_LightList);       // opaques list (unless MSAA possibly)
-                    SetGlobalPropertyRedirect(shadeOpaqueShader, usingFptl ? s_shadeOpaqueFptlKernel : s_shadeOpaqueClusteredKernel, cmd);
+                    bool useCompute = !m_PassSettings.disableTileAndCluster && !m_PassSettings.disableDeferredShadingInCompute;
+                    // We don't want to setup the compute if it's not needed. Otherwwise, the SetGlobalXXX method will not set the parameters properly for regular shaders.
+                    if (useCompute)
+                    {
+                        if (lightDebugParameters.lightingDebugMode == LightingDebugMode.None)
+                            SetGlobalPropertyRedirect(shadeOpaqueShader, usingFptl ? s_shadeOpaqueFptlKernel : s_shadeOpaqueClusteredKernel, cmd);
+                        else
+                            SetGlobalPropertyRedirect(shadeOpaqueShader, usingFptl ? s_shadeOpaqueFptlDebugLightingKernel : s_shadeOpaqueClusteredDebugLightingKernel, cmd);
+                    }
 
                     // In case of bUseClusteredForDeferred disable toggle option since we're using m_perVoxelLightLists as opposed to lightList
                     if (bUseClusteredForDeferred)
+
+                    // Must be done after setting up the compute shader above.
+                    SetupRenderingForDebug(lightDebugParameters);
 
                     if (m_PassSettings.disableTileAndCluster)
                     {

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

 // LightLoop
 // ----------------------------------------------------------------------------
 
+void ApplyDebug(inout float3 diffuseLighting, inout float3 specularLighting)
+{
+#ifdef LIGHTING_DEBUG
+    int lightDebugMode = (int)_DebugLightModeAndAlbedo.x;
+
+    if (lightDebugMode == LIGHTINGDEBUGMODE_DIFFUSE_LIGHTING)
+    {
+        specularLighting = float3(0.0, 0.0, 0.0);
+    }
+    else if (lightDebugMode == LIGHTINGDEBUGMODE_SPECULAR_LIGHTING)
+    {
+        diffuseLighting = float3(0.0, 0.0, 0.0);
+    }
+#endif
+}
+
 #ifdef LIGHTLOOP_TILE_PASS
 
 // Calculate the offset in global light index light for current light category
     // Add indirect diffuse + emissive (if any)
     diffuseLighting += bakeDiffuseLighting;
 #endif
+
+    ApplyDebug(diffuseLighting, specularLighting);
 }
 
 #else // LIGHTLOOP_SINGLE_PASS
 
     // Add indirect diffuse + emissive (if any)
     diffuseLighting += bakeDiffuseLighting;
+
+    ApplyDebug(diffuseLighting, specularLighting);
 }
 
 #endif

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

 #define DEBUGVIEW_LIT_SURFACEDATA_ANISOTROPY (1007)
 #define DEBUGVIEW_LIT_SURFACEDATA_METALLIC (1008)
 #define DEBUGVIEW_LIT_SURFACEDATA_SPECULAR (1009)
-#define DEBUGVIEW_LIT_SURFACEDATA_SUB_SURFACE_RADIUS (1010)
+#define DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_RADIUS (1010)
-#define DEBUGVIEW_LIT_SURFACEDATA_SUB_SURFACE_PROFILE (1012)
+#define DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_PROFILE (1012)
 #define DEBUGVIEW_LIT_SURFACEDATA_COAT_NORMAL_WS (1013)
 #define DEBUGVIEW_LIT_SURFACEDATA_COAT_PERCEPTUAL_SMOOTHNESS (1014)
 #define DEBUGVIEW_LIT_SURFACEDATA_SPECULAR_COLOR (1015)
 #define DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS_T (1039)
 #define DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS_B (1040)
 #define DEBUGVIEW_LIT_BSDFDATA_ANISOTROPY (1041)
-#define DEBUGVIEW_LIT_BSDFDATA_SUB_SURFACE_RADIUS (1042)
+#define DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_RADIUS (1042)
-#define DEBUGVIEW_LIT_BSDFDATA_SUB_SURFACE_PROFILE (1044)
+#define DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_PROFILE (1044)
 #define DEBUGVIEW_LIT_BSDFDATA_COAT_NORMAL_WS (1045)
 #define DEBUGVIEW_LIT_BSDFDATA_COAT_ROUGHNESS (1046)
 

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.hlsl

 #endif
 }
 
+void ApplyDebugToBSDFData(inout BSDFData bsdfData)
+{
+#ifdef LIGHTING_DEBUG
+    int lightDebugMode = (int)_DebugLightModeAndAlbedo.x;
+    float3 lightDebugAlbedo = _DebugLightModeAndAlbedo.yzw;
+    bool overrideSmoothness = _DebugLightingSmoothness.x != 0.0f;
+    float overrideSmoothnessValue = _DebugLightingSmoothness.y;
+
+    if (overrideSmoothness)
+    {
+        bsdfData.perceptualRoughness = PerceptualSmoothnessToPerceptualRoughness(overrideSmoothnessValue);
+        bsdfData.roughness = PerceptualRoughnessToRoughness(bsdfData.perceptualRoughness);
+    }
+
+    if (lightDebugMode == LIGHTINGDEBUGMODE_DIFFUSE_LIGHTING)
+    {
+        bsdfData.diffuseColor = lightDebugAlbedo;
+    }
+#endif
+}
 //-----------------------------------------------------------------------------
 // conversion function for forward
 //-----------------------------------------------------------------------------
         bsdfData.fresnel0 = surfaceData.specularColor;
     }
 
+    ApplyDebugToBSDFData(bsdfData);
+    
     return bsdfData;
 }
 
     }
 
     bakeDiffuseLighting = inGBuffer3.rgb;
+
+    ApplyDebugToBSDFData(bsdfData);
 }
 
 //-----------------------------------------------------------------------------
         case DEBUGVIEW_LIT_SURFACEDATA_SPECULAR:
             result = surfaceData.specular.xxx;
             break;
-        case DEBUGVIEW_LIT_SURFACEDATA_SUB_SURFACE_RADIUS:
+        case DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_RADIUS:
-        case DEBUGVIEW_LIT_SURFACEDATA_SUB_SURFACE_PROFILE:
+        case DEBUGVIEW_LIT_SURFACEDATA_SUBSURFACE_PROFILE:
             result = GetIndexColor(surfaceData.subsurfaceProfile);
             break;
         case DEBUGVIEW_LIT_SURFACEDATA_COAT_NORMAL_WS:
         case DEBUGVIEW_LIT_BSDFDATA_ANISOTROPY:
             result = bsdfData.anisotropy.xxx;
             break;
-        case DEBUGVIEW_LIT_BSDFDATA_SUB_SURFACE_RADIUS:
+        case DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_RADIUS:
-        case DEBUGVIEW_LIT_BSDFDATA_SUB_SURFACE_PROFILE:
+        case DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_PROFILE:
             result = GetIndexColor(bsdfData.subsurfaceProfile);
             break;
         case DEBUGVIEW_LIT_BSDFDATA_COAT_NORMAL_WS:

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/DebugLighting.hlsl

+#ifndef UNITY_DEBUG_LIGHTING_INCLUDED
+#define UNITY_DEBUG_LIGHTING_INCLUDED
+
+float4 _DebugLightModeAndAlbedo; // x == debug mode, yzw = albedo for diffuse.
+float4 _DebugLightingSmoothness; // x == bool override, y == override value
+
+#endif

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/DebugLighting.hlsl.meta

+fileFormatVersion: 2
+guid: 1af9f7b2ee767504fb89dc98550d62f6
+timeCreated: 1486032323
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/HDRenderPipelineDebug.cs.hlsl

+//
+// This file was automatically generated from Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/HDRenderPipelineDebug.cs.  Please don't edit by hand.
+//
+
+#ifndef HDRENDERPIPELINEDEBUG_CS_HLSL
+#define HDRENDERPIPELINEDEBUG_CS_HLSL
+//
+// UnityEngine.Experimental.Rendering.HDPipeline.LightingDebugMode:  static fields
+//
+#define LIGHTINGDEBUGMODE_NONE (0)
+#define LIGHTINGDEBUGMODE_DIFFUSE_LIGHTING (1)
+#define LIGHTINGDEBUGMODE_SPECULAR_LIGHTING (2)
+
+
+#endif

Assets/ScriptableRenderLoop/HDRenderPipeline/Debug/HDRenderPipelineDebug.cs.hlsl.meta

+fileFormatVersion: 2
+guid: 04e346a720261d94b85f6d20b0cd8064
+timeCreated: 1486041561
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: