Fixed newline endings in the files touched by this PR.

ScriptableRenderPipeline/LightweightPipeline/LWRP/Data/LightweightPipelineAsset.cs

                 "LightweightAsset.asset", null, null);
         }
 
-
         //[MenuItem("Assets/Create/Rendering/Lightweight Pipeline Resources", priority = CoreUtils.assetCreateMenuPriority1)]
         static void CreateLightweightPipelineResources()
         {
             var instance = CreateInstance<LightweightPipelineEditorResources>();
             AssetDatabase.CreateAsset(instance, string.Format("Assets/{0}.asset", typeof(LightweightPipelineEditorResources).Name));
         }
-
 
         class CreateLightweightPipelineAsset : EndNameEditAction
         {
         private static T LoadResourceFile<T>() where T : ScriptableObject
         {
             T resourceAsset = null;
-            var guids = AssetDatabase.FindAssets(typeof(T).Name + " t:scriptableobject", new []{m_SearchPathProject});
+            var guids = AssetDatabase.FindAssets(typeof(T).Name + " t:scriptableobject", new[] {m_SearchPathProject});
             foreach (string guid in guids)
             {
                 string path = AssetDatabase.GUIDToAssetPath(guid);

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

             m_Asset = asset;
 
             SetRenderingFeatures();
-            
+
             PerFrameBuffer._GlossyEnvironmentColor = Shader.PropertyToID("_GlossyEnvironmentColor");
             PerFrameBuffer._SubtractiveShadowColor = Shader.PropertyToID("_SubtractiveShadowColor");
 
                         perObjectLightIndexMap[i] = -1;
                     else
                         perObjectLightIndexMap[i] -= directionalLightCount;
-
                 }
                 m_CullResults.SetLightIndexMap(perObjectLightIndexMap);
 
 
         private float GetScaledCameraWidth(Camera camera)
         {
-            return (float) camera.pixelWidth * GetRenderScale();
+            return (float)camera.pixelWidth * GetRenderScale();
-            return (float) camera.pixelHeight * GetRenderScale();
+            return (float)camera.pixelHeight * GetRenderScale();
         }
 
         private RendererConfiguration GetRendererSettings(ref LightData lightData)

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightShadowPass.cs

         public float RenderingDistance { get { return m_ShadowSettings.maxShadowDistance; } }
 
         private const int kMaxCascades = 4;
-        
+
         private int m_ShadowCasterCascadesCount;
         private int m_DirectionalShadowmapID;
         private int m_LocalShadowmapID;
             m_ScreenSpaceShadowmapTexture = new RenderTargetIdentifier(m_ScreenSpaceShadowmapID);
 
             m_DirectionalShadowmapDescriptor = new RenderTextureDescriptor(m_ShadowSettings.directionalShadowAtlasWidth,
-                m_ShadowSettings.directionalShadowAtlasHeight, m_ShadowSettings.shadowmapTextureFormat, m_ShadowSettings.bufferBitCount);
+                    m_ShadowSettings.directionalShadowAtlasHeight, m_ShadowSettings.shadowmapTextureFormat, m_ShadowSettings.bufferBitCount);
-                m_ShadowSettings.localShadowAtlasHeight, m_ShadowSettings.shadowmapTextureFormat, m_ShadowSettings.bufferBitCount);
+                    m_ShadowSettings.localShadowAtlasHeight, m_ShadowSettings.shadowmapTextureFormat, m_ShadowSettings.bufferBitCount);
 
             m_ScreenSpaceShadowsMaterial = CoreUtils.CreateEngineMaterial(pipelineAsset.ScreenSpaceShadowShader);
 
 
             // Until we can have keyword stripping forcing single cascade hard shadows on gles2
             m_ShadowSettings.screenSpace = !isOpenGLES2;
-            m_ShadowSettings.directionalLightCascadeCount = (isOpenGLES2)? 1 : pipelineAsset.CascadeCount;
+            m_ShadowSettings.directionalLightCascadeCount = (isOpenGLES2) ? 1 : pipelineAsset.CascadeCount;
 
             m_ShadowSettings.directionalShadowAtlasWidth = pipelineAsset.ShadowAtlasResolution;
             m_ShadowSettings.directionalShadowAtlasHeight = pipelineAsset.ShadowAtlasResolution;
                 : RenderTextureFormat.Depth;
 
             m_ShadowSettings.screenspaceShadowmapTextureFormat = SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.R8)
-                    ? RenderTextureFormat.R8
-                    : RenderTextureFormat.ARGB32;
+                ? RenderTextureFormat.R8
+                : RenderTextureFormat.ARGB32;
 
             switch (m_ShadowSettings.directionalLightCascadeCount)
             {
             m_CascadeSplitRadii = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
 
             for (int i = 0; i < m_CascadeSlices.Length; ++i)
-                m_CascadeSlices[i].Clear(); 
+                m_CascadeSlices[i].Clear();
 
             for (int i = 0; i < m_LocalLightSlices.Length; ++i)
                 m_LocalLightSlices[i].Clear();
         {
             List<int> localLightIndices = lightData.localLightIndices;
             List<VisibleLight> visibleLights = lightData.visibleLights;
-            
+
             int shadowCastingLightsCount = 0;
             int localLightsCount = localLightIndices.Count;
             for (int i = 0; i < localLightsCount; ++i)
             cmd.SetGlobalVectorArray(DirectionalShadowConstantBuffer._DirShadowSplitSpheres, m_CascadeSplitDistances);
             cmd.SetGlobalVector(DirectionalShadowConstantBuffer._DirShadowSplitSphereRadii, m_CascadeSplitRadii);
             cmd.SetGlobalVector(DirectionalShadowConstantBuffer._ShadowOffset0, new Vector4(-invHalfShadowAtlasWidth, -invHalfShadowAtlasHeight, 0.0f, 0.0f));
-            cmd.SetGlobalVector(DirectionalShadowConstantBuffer._ShadowOffset1, new Vector4( invHalfShadowAtlasWidth, -invHalfShadowAtlasHeight, 0.0f, 0.0f));
+            cmd.SetGlobalVector(DirectionalShadowConstantBuffer._ShadowOffset1, new Vector4(invHalfShadowAtlasWidth, -invHalfShadowAtlasHeight, 0.0f, 0.0f));
-            cmd.SetGlobalVector(DirectionalShadowConstantBuffer._ShadowOffset3, new Vector4( invHalfShadowAtlasWidth,  invHalfShadowAtlasHeight, 0.0f, 0.0f));
+            cmd.SetGlobalVector(DirectionalShadowConstantBuffer._ShadowOffset3, new Vector4(invHalfShadowAtlasWidth,  invHalfShadowAtlasHeight, 0.0f, 0.0f));
-                m_ShadowSettings.directionalShadowAtlasWidth, m_ShadowSettings.directionalShadowAtlasHeight));
+                    m_ShadowSettings.directionalShadowAtlasWidth, m_ShadowSettings.directionalShadowAtlasHeight));
             context.ExecuteCommandBuffer(cmd);
             cmd.Clear();
         }
             cmd.SetGlobalMatrixArray(LocalShadowConstantBuffer._LocalWorldToShadowAtlas, m_LocalShadowMatrices);
             cmd.SetGlobalFloatArray(LocalShadowConstantBuffer._LocalShadowStrength, m_LocalShadowStrength);
             cmd.SetGlobalVector(LocalShadowConstantBuffer._LocalShadowOffset0, new Vector4(-invHalfShadowAtlasWidth, -invHalfShadowAtlasHeight, 0.0f, 0.0f));
-            cmd.SetGlobalVector(LocalShadowConstantBuffer._LocalShadowOffset1, new Vector4( invHalfShadowAtlasWidth, -invHalfShadowAtlasHeight, 0.0f, 0.0f));
+            cmd.SetGlobalVector(LocalShadowConstantBuffer._LocalShadowOffset1, new Vector4(invHalfShadowAtlasWidth, -invHalfShadowAtlasHeight, 0.0f, 0.0f));
-            cmd.SetGlobalVector(LocalShadowConstantBuffer._LocalShadowOffset3, new Vector4( invHalfShadowAtlasWidth,  invHalfShadowAtlasHeight, 0.0f, 0.0f));
+            cmd.SetGlobalVector(LocalShadowConstantBuffer._LocalShadowOffset3, new Vector4(invHalfShadowAtlasWidth,  invHalfShadowAtlasHeight, 0.0f, 0.0f));
-                m_ShadowSettings.localShadowAtlasWidth, m_ShadowSettings.localShadowAtlasHeight));
+                    m_ShadowSettings.localShadowAtlasWidth, m_ShadowSettings.localShadowAtlasHeight));
-};
+}

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Lighting.hlsl

 #if USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA
     int lightIndex = _LightIndexBuffer[unity_LightIndicesOffsetAndCount.x + i];
 #else
-    // The following code is more optimal than indexing unity_4LightIndices0. 
+    // The following code is more optimal than indexing unity_4LightIndices0.
     // Conditional moves are branch free even on mali-400
     half i_rem = (i < 2.0h) ? i : i - 2.0h;
     half2 lightIndex2 = (i < 2.0h) ? unity_4LightIndices0.xy : unity_4LightIndices0.zw;
 
     half3 fullDiffuse = diffuseColor + inputData.vertexLighting;
     half3 finalColor = fullDiffuse * diffuse + emission;
-    
+
 #if defined(_SPECGLOSSMAP) || defined(_SPECULAR_COLOR)
     finalColor += specularColor;
 #endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightScreenSpaceShadows.shader

         {
             UNITY_SETUP_INSTANCE_ID(i);
 #if !defined(UNITY_STEREO_INSTANCING_ENABLED)
-            // Completely unclear why i.stereoTargetEyeIndex doesn't work here, considering 
+            // Completely unclear why i.stereoTargetEyeIndex doesn't work here, considering
             // this has to be correct in order for the texture array slices to be rasterized to
             // We can limit this workaround to stereo instancing for now.
             UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
         ENDHLSL
 
         Pass
-        {           
+        {
             ZTest Always
             ZWrite Off
             Cull Off
             #pragma multi_compile _ _SHADOWS_CASCADE
-            
+
             #pragma vertex   Vertex
             #pragma fragment Fragment
             ENDHLSL

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardParticlesSimpleLighting.shader

 
             #define BUMP_SCALE_NOT_SUPPORTED 1
             #define NO_SHADOWS 1
-            
+
             #include "LWRP/ShaderLibrary/Particles.hlsl"
             #include "LWRP/ShaderLibrary/Lighting.hlsl"