Fix various C sharp and shader warning

ScriptableRenderPipeline/Core/CoreRP/Editor/CoreEditorDrawers.cs

             AnimBoolGetter m_IsExpanded;
             string m_Title;
             FoldoutOption m_Options;
-            bool m_Animate;
 
             bool animate { get { return (m_Options & FoldoutOption.Animate) != 0; } }
             bool indent { get { return (m_Options & FoldoutOption.Indent) != 0; } }

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/GeometricTools.hlsl

 // This simplified version assume that we care about the result only when we are inside the box
 float IntersectRayAABBSimple(float3 start, float3 dir, float3 boxMin, float3 boxMax)
 {
-    float3 invDir = 1.0 / dir;
+    float3 invDir = rcp(dir);
 
     // Find the ray intersection with box plane
     float3 rbmin = (boxMin - start) * invDir;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Volumetrics/VolumetricLighting.compute

 
 // #pragma enable_d3d11_debug_symbols
 
+#define SHADOW_USE_ONLY_VIEW_BASED_BIASING 1 // We don't use normal biasing as it is not available when doing volumetric
+
 #include "../../ShaderPass/ShaderPass.cs.hlsl"
 #define SHADERPASS SHADERPASS_VOLUMETRIC_LIGHTING
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.hlsl

     float3x3 ltcTransformCoat;       // Inverse transformation for GGX                                 (4x VGPRs)
     float    ltcMagnitudeCoatFresnel;
 
+#if HAS_REFRACTION
+#endif
-    ZERO_INITIALIZE(PreLightData, preLightData);
+    // Don't init to zero to allow to track warning about uninitialized data
 
     float3 N = bsdfData.normalWS;
     preLightData.NdotV = dot(N, V);
         ltcGGXFresnelMagnitude      = ltcMagnitude.g;
         preLightData.ltcMagnitudeCoatFresnel = (CLEAR_COAT_F0 * ltcGGXFresnelMagnitudeDiff + ltcGGXFresnelMagnitude) * bsdfData.coatMask;
     }
+    else
+    {
+        preLightData.ltcTransformCoat = 0.0;
+        preLightData.ltcMagnitudeCoatFresnel = 0.0;
+    }
-#ifdef REFRACTION_MODEL
+#if HAS_REFRACTION
     RefractionModelResult refraction = REFRACTION_MODEL(V, posInput, bsdfData);
     preLightData.transparentRefractV = refraction.rayWS;
     preLightData.transparentPositionWS = refraction.positionWS;
 
     float3 R = preLightData.iblR;
 
+#if HAS_REFRACTION
+#endif
 
     // Note: using influenceShapeType and projectionShapeType instead of (lightData|proxyData).shapeType allow to make compiler optimization in case the type is know (like for sky)
     EvaluateLight_EnvIntersection(positionWS, bsdfData.normalWS, lightData, influenceShapeType, R, weight);
             // Can't attenuate diffuse lighting here, may try to apply something on bakeLighting in PostEvaluateBSDF
         }
     }
+#if HAS_REFRACTION
     else
     {
         // No clear coat support with refraction
         envLighting = (1.0 - F) * preLD.rgb * preLightData.transparentTransmittance;
     }
+#endif
 
 #endif // LIT_DISPLAY_REFERENCE_IBL
 
     if (GPUImageBasedLightingType == GPUIMAGEBASEDLIGHTINGTYPE_REFLECTION)
         lighting.specularReflected = envLighting;
+#if HAS_REFRACTION
+#endif
 
     return lighting;
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

         private RenderTargetIdentifier m_CopyColorRT;
         private RenderTargetIdentifier m_DepthRT;
         private RenderTargetIdentifier m_CopyDepth;
-        private RenderTargetIdentifier m_Color;
         private float[] m_OpaqueScalerValues = {1.0f, 0.5f, 0.25f, 0.25f};
 
         private float m_RenderScale;

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/011_UnlitSprites/Scripts/Oscilate.cs

 
     private float elapsed;
     Vector3 startPosition;
-    private float time;
 
     void Start()
     {