Added support to per-object light list for SM 2.0 devices

Assets/ScriptableRenderPipeline/LightweightPipeline/Editor/LightweightAssetInspector.cs

             public static GUIContent shadowLabel = new GUIContent("Shadows");
             public static GUIContent defaults = new GUIContent("Defaults");
 
-            public static GUIContent maxPixelLights = new GUIContent("Max per-pixel lights supported",
-                    "Amount of dynamic lights processed in fragment shader. More than 1 per-pixel light is not recommended.");
+            public static GUIContent maxPixelLights = new GUIContent("Per-Object Pixel Lights",
+                    "Max amount of dynamic per-object pixel lights.");
-                    "Enable up to 4 per-vertex dynamic lights.");
+                    "Lightweight pipeline support at most 4 per-object lights between pixel and vertex. If value in pixel lights is set to max this settings has no effect.");
-                    "Only non-directional lightmaps are supported");
+                    "Enabled/Disable support for non-directional lightmaps.");
-                    "Enables/Disabled light probe support.");
+                    "Enables/Disable light probe support.");
 
             public static GUIContent shadowType = new GUIContent("Shadow Type",
                     "Single directional shadow supported. SOFT_SHADOWS applies shadow filtering.");
         private SerializedProperty m_EnableAmbientProbeProp;
         private SerializedProperty m_ShadowTypeProp;
         private SerializedProperty m_ShadowNearPlaneOffsetProp;
-        private SerializedProperty m_ShadowMinNormalBiasProperty;
-        private SerializedProperty m_ShadowNormalBiasProperty;
         private SerializedProperty m_ShadowDistanceProp;
         private SerializedProperty m_ShadowAtlasResolutionProp;
         private SerializedProperty m_ShadowCascadesProp;
             m_EnableAmbientProbeProp = serializedObject.FindProperty("m_EnableAmbientProbe");
             m_ShadowTypeProp = serializedObject.FindProperty("m_ShadowType");
             m_ShadowNearPlaneOffsetProp = serializedObject.FindProperty("m_ShadowNearPlaneOffset");
-            m_ShadowMinNormalBiasProperty = serializedObject.FindProperty("m_MinShadowNormalBias");
-            m_ShadowNormalBiasProperty = serializedObject.FindProperty("m_ShadowNormalBias");
             m_ShadowDistanceProp = serializedObject.FindProperty("m_ShadowDistance");
             m_ShadowAtlasResolutionProp = serializedObject.FindProperty("m_ShadowAtlasResolution");
             m_ShadowCascadesProp = serializedObject.FindProperty("m_ShadowCascades");
             EditorGUILayout.Space();
             EditorGUILayout.LabelField(Styles.renderingLabel, EditorStyles.boldLabel);
             EditorGUI.indentLevel++;
-            EditorGUILayout.PropertyField(m_MaxPixelLights, Styles.maxPixelLights);
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.LabelField(Styles.maxPixelLights);
+            m_MaxPixelLights.intValue = EditorGUILayout.IntSlider(m_MaxPixelLights.intValue, 0, 4);
+            EditorGUILayout.EndHorizontal();
             EditorGUILayout.PropertyField(m_SupportsVertexLightProp, Styles.enableVertexLightLabel);
             EditorGUILayout.PropertyField(m_EnableLightmapsProp, Styles.enableLightmap);
             EditorGUILayout.PropertyField(m_EnableAmbientProbeProp, Styles.enableAmbientProbe);

Assets/ScriptableRenderPipeline/LightweightPipeline/LightweightPipeline.cs

         // Max amount of visible lights. This controls the lights constant buffers in shader but not the max shaded lights.
         // Lights are set per-object and the max shaded lights for each object are controlled by the max pixel lights in pipeline asset and kMaxVertexLights.
         private static readonly int kMaxVisibleLights = 16;
-        private static readonly int kMaxVertexLights = 4;
+        private static readonly int kMaxPerObjectLights = 4;
 
         private Vector4[] m_LightPositions = new Vector4[kMaxVisibleLights];
         private Vector4[] m_LightColors = new Vector4[kMaxVisibleLights];
                 InitializeLightData(visibleLights, out lightData);
 
                 // Render Shadow Map
-                if (lightData.shadowLightIndex > -1) 
+                if (lightData.shadowLightIndex > -1)
                     lightData.shadowsRendered = RenderShadows(ref m_CullResults, ref visibleLights[lightData.shadowLightIndex], lightData.shadowLightIndex, ref context);
 
                 // Setup camera matrices and RT
                     configuration |= RendererConfiguration.PerObjectLightProbe;
 
                 if (!lightData.isSingleDirectionalLight)
-                    configuration |= RendererConfiguration.ProvideLightIndices;
+                    configuration |= RendererConfiguration.PerObjectLightIndices8;
 
                 // Render Opaques
                 var litSettings = new DrawRendererSettings(m_CullResults, camera, m_LitPassName);
             }
 
             int lightsCount = lights.Length;
-            lightData.pixelLightsCount = Mathf.Min(lightsCount, m_Asset.MaxSupportedPixelLights);
-            lightData.vertexLightsCount = (m_Asset.SupportsVertexLight) ? Mathf.Min(lightsCount - lightData.pixelLightsCount, kMaxVertexLights) : 0;
+            int maxPerPixelLights = Math.Min(m_Asset.MaxSupportedPixelLights, kMaxPerObjectLights);
+            lightData.pixelLightsCount = Math.Min(lightsCount, maxPerPixelLights);
+            lightData.vertexLightsCount = (m_Asset.SupportsVertexLight) ? Math.Min(lightsCount - lightData.pixelLightsCount, kMaxPerObjectLights) : 0;
-            
+
-        private void FillLightIndices(ref CullResults cullResults, int visibleLightsCount)
-        {
-            //int visibleRenderersCount = cullResults.GetVisibleRenderersCount();
-            // TODO: commenting cullResults.GetVisislbeRenderersCount() to avoid compiler errors as it is not in main SRP trunk yet
-            // For now setting a small amount enough for the test scenes.
-            int visibleRenderersCount = 1024;
-            if (visibleRenderersCount > m_LightIndicesCount)
-            {
-                m_LightIndicesCount = visibleRenderersCount * visibleLightsCount;
-                if (m_LightIndexListBuffer != null)
-                    m_LightIndexListBuffer.Release();
-                m_LightIndexListBuffer = new ComputeBuffer(m_LightIndicesCount, sizeof(uint));
-            }
-            cullResults.FillLightIndices(m_LightIndexListBuffer);
-        }
-
-            if (lightData.isSingleDirectionalLight) 
+            if (lightData.isSingleDirectionalLight)
-                SetupShaderLightListConstants(lights, lightData.pixelLightsCount, ref cullResults, ref context);
+                SetupShaderLightListConstants(lights, ref lightData, ref context);
-             
+
             CommandBuffer cmd = new CommandBuffer() { name = "SetupLightConstants" };
             cmd.SetGlobalVector("_LightPosition0", new Vector4(lightDir.x, lightDir.y, lightDir.z, 0.0f));
             cmd.SetGlobalColor("_LightColor0", light.finalColor);
 
-        // TODO: Perform tests on light lights memory pattern access (SOA vs AOS vs Swizzling)
-        private void SetupShaderLightListConstants(VisibleLight[] lights, int pixelLightsCount, ref CullResults cullResults, ref ScriptableRenderContext context)
+        private void SetupShaderLightListConstants(VisibleLight[] lights, ref LightData lightData, ref ScriptableRenderContext context)
-            FillLightIndices(ref cullResults, lights.Length);
-            for (int i = 0; i < maxLights; ++i) 
+            for (int i = 0; i < maxLights; ++i)
-                if (currLight.lightType == LightType.Directional) 
+                if (currLight.lightType == LightType.Directional)
-                } 
-                else 
+                }
+                else
                 {
                     Vector4 pos = currLight.localToWorld.GetColumn (3);
                     m_LightPositions [i] = new Vector4 (pos.x, pos.y, pos.z, 1.0f);
                 float rangeSq = currLight.range * currLight.range;
                 float quadAtten = (currLight.lightType == LightType.Directional) ? 0.0f : 25.0f / rangeSq;
 
-                if (currLight.lightType == LightType.Spot) 
+                if (currLight.lightType == LightType.Spot)
                 {
                     Vector4 dir = currLight.localToWorld.GetColumn (2);
                     m_LightSpotDirections [i] = new Vector4 (-dir.x, -dir.y, -dir.z, 0.0f);
                     float angleRange = cosInneAngle - cosOuterAngle;
                     m_LightAttenuations [i] = new Vector4 (cosOuterAngle,
                         Mathf.Approximately (angleRange, 0.0f) ? 1.0f : angleRange, quadAtten, rangeSq);
-                } 
+                }
                 else
                 {
                     m_LightSpotDirections [i] = new Vector4 (0.0f, 0.0f, 1.0f, 0.0f);
 
             CommandBuffer cmd = CommandBufferPool.Get("SetupShadowShaderConstants");
-            cmd.SetGlobalVector("globalLightCount", new Vector4 (pixelLightsCount, 0.0f, 0.0f, 0.0f));
+            cmd.SetGlobalVector("globalLightCount", new Vector4 (lightData.pixelLightsCount, lightData.vertexLightsCount, 0.0f, 0.0f));
-            cmd.SetGlobalBuffer("globalLightIndexList", m_LightIndexListBuffer);
             context.ExecuteCommandBuffer(cmd);
             CommandBufferPool.Release(cmd);
         }

Assets/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPipeline.shader

 
 #if defined(_VERTEX_LIGHTS) && !defined(_SINGLE_DIRECTIONAL_LIGHT)
                 half4 diffuseAndSpecular = half4(1.0, 1.0, 1.0, 1.0);
-                int vertexLightStart = unity_LightIndicesOffsetAndCount.x + globalLightCount.x;
-                int vertexLightEnd = vertexLightStart + (unity_LightIndicesOffsetAndCount.y - globalLightCount.x);
+                // pixel lights shaded = min(pixelLights, perObjectLights)
+                // vertex lights shaded = min(vertexLights, perObjectLights) - pixel lights shaded
+                // Therefore vertexStartIndex = pixelLightCount;  vertexEndIndex = min(vertexLights, perObjectLights)
+                int vertexLightStart = min(globalLightCount.x, unity_LightIndicesOffsetAndCount.y);
+                int vertexLightEnd = min(globalLightCount.y, unity_LightIndicesOffsetAndCount.y);
-                    int lightIndex = globalLightIndexList[lightIter];
+                    int lightIndex = unity_4LightIndices0[lightIter];
                     LightInput lightInput;
                     INITIALIZE_LIGHT(lightInput, lightIndex);
                     o.fogCoord.yzw += EvaluateOneLight(lightInput, diffuseAndSpecular.rgb, diffuseAndSpecular, normal, o.posWS, o.viewDir.xyz);
 #ifdef _SHADOWS
                 half shadowAttenuation = ComputeShadowAttenuation(i, _ShadowLightDirection.xyz);
 #endif
-                int pixelLightEnd = unity_LightIndicesOffsetAndCount.x + min(globalLightCount.x, unity_LightIndicesOffsetAndCount.y);
-                for (int lightIter = unity_LightIndicesOffsetAndCount.x; lightIter < pixelLightEnd; ++lightIter)
+                int pixelLightCount = min(globalLightCount.x, unity_LightIndicesOffsetAndCount.y);
+                for (int lightIter = 0; lightIter < pixelLightCount; ++lightIter)
-                    int lightIndex = globalLightIndexList[lightIter];
+                    int lightIndex = unity_4LightIndices0[lightIter];
-                    // multiplies shadowAttenuation to avoid branching.
-                    // step will only evaluate to 1 when lightIndex == _ShadowData.x (shadowLightIndex)
-                    half currLightAttenuation = shadowAttenuation * step(abs(lightIndex - _ShadowData.x), 0);
+                    half currLightAttenuation = max(shadowAttenuation, half(lightIter != _ShadowData.x));
                     color += EvaluateOneLight(lightData, diffuse, specularGloss, normal, i.posWS, viewDir) * currLightAttenuation;
 #else
                     color += EvaluateOneLight(lightData, diffuse, specularGloss, normal, i.posWS, viewDir);

Assets/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPipelineCore.cginc

 // Per object light list data
 #ifndef _SINGLE_DIRECTIONAL_LIGHT
 half4 unity_LightIndicesOffsetAndCount;
-StructuredBuffer<uint> globalLightIndexList;
+half4 unity_4LightIndices0;
 
 // The variables are very similar to built-in unity_LightColor, unity_LightPosition,
 // unity_LightAtten, unity_SpotDirection as used by the VertexLit shaders, except here

Assets/ScriptableRenderPipeline/LightweightPipeline/TestScenes/LDRenderPipelineBasicScene.unity

     m_PVRDirectSampleCount: 32
     m_PVRSampleCount: 500
     m_PVRBounces: 2
-    m_PVRFiltering: 0
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
-    m_PVRFilteringAtrousColorSigma: 1
-    m_PVRFilteringAtrousNormalSigma: 1
-    m_PVRFilteringAtrousPositionSigma: 1
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
   m_LightingDataAsset: {fileID: 112000002, guid: 740b181ab47c46a47ae28377711d7097,
     type: 2}
   m_UseShadowmask: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &1254169578
 Transform:
   m_ObjectHideFlags: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &1366180536
 Transform:
   m_ObjectHideFlags: 0
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1447851825}
   m_Enabled: 1
+  m_ExtensionPropertyValues: []
 --- !u!124 &1447851827
 Behaviour:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &1449522779
 Transform:
   m_ObjectHideFlags: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &1659249726
 Transform:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!108 &1677622457
 Light:
   m_ObjectHideFlags: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &1911408598
 Transform:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &2025477086
 Transform:
   m_ObjectHideFlags: 0
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5
   m_PreserveUVs: 1
   m_IgnoreNormalsForChartDetection: 0
   m_ImportantGI: 0
+  m_StitchSeams: 0
   m_SelectedEditorRenderState: 3
   m_MinimumChartSize: 4
   m_AutoUVMaxDistance: 0.5

Assets/GraphicsTests/RenderPipeline/LightweightPipeline/Assets/Scripts.meta

+fileFormatVersion: 2
+guid: ac5e33c9370558b4d88db4eca81a4c4f
+folderAsset: yes
+timeCreated: 1498746585
+licenseType: Pro
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GraphicsTests/RenderPipeline/LightweightPipeline/Assets/Scripts/Boomerang.cs

+using System.Collections;
+using UnityEngine;
+
+public class Boomerang : MonoBehaviour
+{
+    public Transform m_Target1;
+    public Transform m_Target2;
+    public float m_Speed = 2f;
+
+    private Vector3 m_Direction;
+    private Vector3[] m_Targets = new Vector3[2];
+    private int m_TargetIndex = 0;
+
+    void OnEnable()
+    {
+        m_Targets[0] = m_Target1.position;
+        m_Targets[1] = m_Target2.position;
+        transform.position = m_Targets[0];
+        m_Direction = Vector3.Normalize(m_Targets[1] - m_Targets[0]);
+
+        m_TargetIndex = 1;
+    }
+
+    void Update()
+    {
+        transform.position += m_Direction * m_Speed * Time.deltaTime;
+        Vector3 targetPosVec = m_Targets[m_TargetIndex] - transform.position;
+        if (Vector3.Dot(targetPosVec, m_Direction) < 0)
+        {
+            m_TargetIndex = (m_TargetIndex + 1) % 2;
+            m_Direction = -m_Direction;
+        }
+    }
+}

Assets/GraphicsTests/RenderPipeline/LightweightPipeline/Assets/Scripts/Boomerang.cs.meta

+fileFormatVersion: 2
+guid: e41d23cf7d8aa3f4cad90e0f87b9db57
+timeCreated: 1498748776
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/GraphicsTests/RenderPipeline/LightweightPipeline/Assets/Scripts/RotateAround.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class RotateAround : MonoBehaviour
+{
+    public Transform m_RotationPivot;
+    public float m_DegreePerSecond;
+
+    public void Update()
+    {
+        float step = m_DegreePerSecond * Time.deltaTime;
+        transform.RotateAround(m_RotationPivot.transform.position, Vector3.up, step);
+    }
+}

Assets/GraphicsTests/RenderPipeline/LightweightPipeline/Assets/Scripts/RotateAround.cs.meta

+fileFormatVersion: 2
+guid: 200ecff91ea6fc2429eb4ae8898b002d
+timeCreated: 1498746574
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: