work in progress, avoid using cubemap textures on mobile targets

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

                 m_CubeCookieTexArray = new TextureCacheCubemap();
                 m_CubeCookieTexArray.AllocTextureArray(4, textureSettings.pointCookieSize, TextureFormat.RGBA32, true);
                 m_CubeReflTexArray = new TextureCacheCubemap();
-                m_CubeReflTexArray.AllocTextureArray(32, textureSettings.reflectionCubemapSize, TextureFormat.BC6H, true);
+                m_CubeReflTexArray.AllocTextureArray(32, textureSettings.reflectionCubemapSize, TextureCache.GetPreferredCompressedTextureFormat, true);
 
                 s_GenAABBKernel = buildScreenAABBShader.FindKernel("ScreenBoundsAABB");
                 s_GenListPerTileKernel = buildPerTileLightListShader.FindKernel(m_PassSettings.enableBigTilePrepass ? "TileLightListGen_SrcBigTile" : "TileLightListGen");

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

 SAMPLER2D(sampler_CookieTextures);
 
 // Used by point lights
+#ifdef UNITY_NO_CUBEMAP_ARRAY
+TEXTURE2D_ARRAY(_CookieCubeTextures);
+SAMPLER2D(sampler_CookieCubeTextures);
+#else
+#endif
-#ifdef CUBE_ARRAY_NOT_SUPPORTED
+#ifdef UNITY_NO_CUBEMAP_ARRAY
 TEXTURE2D_ARRAY(_EnvTextures);
 SAMPLER2D(sampler_EnvTextures);
 #else
 // Returns the color in the RGB components, and the transparency (lack of occlusion) in A.
 float4 SampleCookieCube(LightLoopContext lightLoopContext, float3 coord, int index)
 {
+    #ifdef UNITY_NO_CUBEMAP_ARRAY
+    return SAMPLE_TEXTURE2D_ARRAY_LOD(_CookieCubeTextures, sampler_CookieCubeTextures, DirectionToLatLongCoordinate(coord), index, 0);
+    #else
+    #endif
 }
 
 //-----------------------------------------------------------------------------
     // This code will be inlined as lightLoopContext is hardcoded in the light loop
     if (lightLoopContext.sampleReflection == SINGLE_PASS_CONTEXT_SAMPLE_REFLECTION_PROBES)
     {
-        #ifdef CUBE_ARRAY_NOT_SUPPORTED
+        #ifdef UNITY_NO_CUBEMAP_ARRAY
         return SAMPLE_TEXTURE2D_ARRAY_LOD(_EnvTextures, sampler_EnvTextures, DirectionToLatLongCoordinate(texCoord), index, lod);
         #else
         return SAMPLE_TEXTURECUBE_ARRAY_LOD(_EnvTextures, sampler_EnvTextures, texCoord, index, lod);

Assets/ScriptableRenderPipeline/common/ShaderBase.h

 #ifndef __SHADERBASE_H__
 #define __SHADERBASE_H__
 
-
-//#define CUBE_ARRAY_NOT_SUPPORTED
-
 half2 DirectionToSphericalTexCoordinate(half3 dir)
 {
 	// coordinate frame is (-Z,X) meaning negative Z is primary axis and X is secondary axis.
 
 
-#ifdef CUBE_ARRAY_NOT_SUPPORTED
+#ifdef UNITY_NO_CUBEMAP_ARRAY
 	#define UNITY_DECLARE_ABSTRACT_CUBE_ARRAY						UNITY_DECLARE_TEX2DARRAY
 	#define	UNITY_PASS_ABSTRACT_CUBE_ARRAY							UNITY_PASS_TEX2DARRAY
 	#define UNITY_ARGS_ABSTRACT_CUBE_ARRAY							UNITY_ARGS_TEX2DARRAY

Assets/ScriptableRenderPipeline/common/TextureCache.cs

 using UnityEngine;
 using System.Collections.Generic;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
 
 public class TextureCache2D : TextureCache
 {
 {
     private CubemapArray m_Cache;
 
-    // alternative panorama path intended for mobile
-    // the member variables below are only in use when m_IsNoCubeArray is true.
-    private bool m_IsNoCubeArray = false;
+    // the member variables below are only in use when TextureCache.supportsCubemapArrayTextures is false
     private Texture2DArray m_CacheNoCubeArray;
     private RenderTexture[] m_StagingRTs;
     private int m_NumPanoMipLevels;
-    // alternative panorama path intended for mobile
-    // the member variables below are only in use when m_IsNoCubeArray is true.
-
-        if(m_IsNoCubeArray)
+        if(!TextureCache.supportsCubemapArrayTextures)
             TransferToPanoCache(sliceIndex, texture);
         else
         {
 
     public override Texture GetTexCache()
     {
-        return m_IsNoCubeArray ? (Texture) m_CacheNoCubeArray : m_Cache;
+        return !TextureCache.supportsCubemapArrayTextures ? (Texture) m_CacheNoCubeArray : m_Cache;
     }
 
     public bool AllocTextureArray(int numCubeMaps, int width, TextureFormat format, bool isMipMapped)
         
-        if(m_IsNoCubeArray)
+        if(!TextureCache.supportsCubemapArrayTextures)
         {
             if(!m_CubeBlitMaterial) m_CubeBlitMaterial = new Material(Shader.Find("Hidden/CubeToPano"));
 
-            // create panorama 2D array. Hardcoding the render target for now when m_IsNoCubeArray is true. No convenient way atm. to
+            // create panorama 2D array. Hardcoding the render target for now. No convenient way atm to
             // map from TextureFormat to RenderTextureFormat and don't want to deal with sRGB issues for now.
             m_CacheNoCubeArray = new Texture2DArray(panoWidthTop, panoHeightTop, numCubeMaps, TextureFormat.RGBAHalf, isMipMapped)
             {
 
     public void Release()
     {
-        if(m_IsNoCubeArray)
+        if (m_CacheNoCubeArray)
         {
             Texture.DestroyImmediate(m_CacheNoCubeArray);
             for(int m=0; m<m_NumPanoMipLevels; m++)
             m_StagingRTs=null;
             if(m_CubeBlitMaterial) Material.DestroyImmediate(m_CubeBlitMaterial);
         }
-        else Texture.DestroyImmediate(m_Cache);
+        if (m_Cache)
+            Texture.DestroyImmediate(m_Cache);
     }
 
     private void TransferToPanoCache(int sliceIndex, Texture texture)
         }
     }
 #endif
+
+    public static bool isMobileBuildTarget
+    {
+        get
+        {
+#if UNITY_EDITOR
+            switch (EditorUserBuildSettings.activeBuildTarget)
+            {
+                case BuildTarget.iOS:
+                case BuildTarget.Android:
+                case BuildTarget.Tizen:
+                case BuildTarget.WSAPlayer:
+                    // Note: We return true on purpose even if Windows Store Apps are running on Desktop.
+                    return true;
+                default:
+                    return false;
+            }
+#else
+            return Application.isMobilePlatform;
+#endif
+        }
+    }
+
+    public static TextureFormat GetPreferredCompressedTextureFormat
+    {
+        get
+        {
+            var format = TextureFormat.RGBAHalf;
+
+            var probeFormat = TextureFormat.BC6H;
+
+            // On editor the texture is uncompressed when operating against mobile build targets
+            if (SystemInfo.SupportsTextureFormat(probeFormat) && !TextureCache.isMobileBuildTarget)
+                format = probeFormat;
+
+            return format;
+        }
+    }
+
+    public static bool supportsCubemapArrayTextures
+    {
+        get
+        {
+            return (SystemInfo.supportsCubemapArrayTextures && !TextureCache.isMobileBuildTarget);
+        }
+    }
 
     private struct SSliceEntry
     {

Assets/ScriptableRenderPipeline/fptl/FptlLighting.cs

             m_CubeReflTexArray = new TextureCacheCubemap();
             m_CookieTexArray.AllocTextureArray(8, m_TextureSettings.spotCookieSize, m_TextureSettings.spotCookieSize, TextureFormat.RGBA32, true);
             m_CubeCookieTexArray.AllocTextureArray(4, m_TextureSettings.pointCookieSize, TextureFormat.RGBA32, true);
-            m_CubeReflTexArray.AllocTextureArray(64, m_TextureSettings.reflectionCubemapSize, TextureFormat.BC6H, true);
+            m_CubeReflTexArray.AllocTextureArray(64, m_TextureSettings.reflectionCubemapSize, TextureCache.GetPreferredCompressedTextureFormat, true);
 
             //m_DeferredMaterial.SetTexture("_spotCookieTextures", m_cookieTexArray.GetTexCache());
             //m_DeferredMaterial.SetTexture("_pointCookieTextures", m_cubeCookieTexArray.GetTexCache());