Add support of debug font for debugging

ScriptableRenderPipeline/Core/CoreRP/CoreUtils.cs

         {
             // We should have the option to clear mip maps here, but since RenderTargetIdentifier, we can't know the number to clear...
             // So for now, we won't do it.
-            for(int i = 0; i < 6; ++i)
+            for (int i = 0; i < 6; ++i)
                 SetRenderTarget(cmd, buffer, ClearFlag.Color, clearColor, 0, (CubemapFace)i);
         }
 
 
             for (int i = 0; i < 6; ++i)
             {
-                for (int mip = 0; mip < mipCount; ++ mip )
+                for (int mip = 0; mip < mipCount; ++mip)
                 {
                     SetRenderTarget(cmd, new RenderTargetIdentifier(renderTexture), ClearFlag.Color, clearColor, mip, (CubemapFace)i);
                 }
                     {
                         innerTypes = t.GetTypes();
                     }
-                    catch {}
+                    catch { }
                     return innerTypes;
                 });
         }

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Debug.hlsl

 
     // Can't calculate without original mip count - return magenta
     return float3(1.0, 0.0, 1.0);
-}
-
+}
+
-{
+{
     const real3 red = { 1.0, 0.0, 0.0 };
     const real3 lightGreen = { 0.5, 1.0, 0.5 };
     const real3 darkGreen = { 0.1, 1.0, 0.1 };

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugDisplay.hlsl

 float4 _DebugLightingAlbedo; // xyz = albedo for diffuse, w unused
 float4 _DebugLuxMeterParam; // 4 increasing threshold
 float4 _DebugLightingSmoothness; // x == bool override, y == override value
+float4 _MousePixelCoord;  // xy unorm, zw norm
+
+TEXTURE2D(_DebugFont); // Debug font to write string in shader
 
 void GetPropertiesDataDebug(uint paramId, inout float3 result, inout bool needLinearToSRGB)
 {
     }
 
     return originalColor;
+}
+
+// font texture is 256x128
+#define DEBUG_FONT_TEXT_WIDTH	16
+#define DEBUG_FONT_TEXT_HEIGHT	16
+#define DEBUG_FONT_TEXT_SIZE	1.0f
+#define DEBUG_FONT_TEXT_COUNT_X	16
+#define DEBUG_FONT_TEXT_COUNT_Y	8
+#define DEBUG_FONT_TEXT_SCALE	0.7f
+
+float3 DrawCharacter(uint asciiValue, float2 currentAbsCoords, inout float2 referenceAbsCoord, float fontSize, float incrementSign)
+{
+    uint2 asciiCoord = uint2(asciiValue % DEBUG_FONT_TEXT_COUNT_X, asciiValue / DEBUG_FONT_TEXT_COUNT_Y);
+    const float charWidth = DEBUG_FONT_TEXT_WIDTH * fontSize;
+    const float charHeight = DEBUG_FONT_TEXT_HEIGHT * fontSize;
+    const float2 localCoords = currentAbsCoords - referenceAbsCoord;
+
+    float3 output = float3(0, 0, 0);
+    if (localCoords.x >= 0 && localCoords.x < charWidth && localCoords.y >= 0 && localCoords.y < charHeight)
+    {
+        float2 texOffset = float2(asciiCoord) / float2(DEBUG_FONT_TEXT_COUNT_X, DEBUG_FONT_TEXT_COUNT_Y);
+        float2 texCoord = localCoords / float2(charWidth * DEBUG_FONT_TEXT_COUNT_X, charHeight * DEBUG_FONT_TEXT_COUNT_Y);
+        output = SAMPLE_TEXTURE2D_LOD(_DebugFont, s_linear_clamp_sampler, texCoord + texOffset, 0).xyz;
+    }
+
+    referenceAbsCoord.x += charWidth * incrementSign * DEBUG_FONT_TEXT_SCALE;
+
+    return output;
+}
+
+float3 DrawCharacter(uint asciiValue, float2 currentAbsCoords, inout float2 referenceAbsCoord, float fontSize)
+{
+    return DrawCharacter(asciiValue, currentAbsCoords, referenceAbsCoord, fontSize, 1.0f);
+}
+
+float GetTextSize(uint intValue, float fontSize)
+{
+    const uint charWidth = DEBUG_FONT_TEXT_WIDTH * fontSize * DEBUG_FONT_TEXT_SCALE;
+    const uint maxCharCount = 16;
+    uint charCount = 0;
+
+    for (uint charIt = 0; charIt < maxCharCount; ++charIt)
+    {
+        ++charCount;
+        if (intValue  < 10)
+            break;
+        intValue /= 10;
+    }
+    return charCount * charWidth;
+}
+
+float3 DrawInteger(in uint intValue, in float2 coords, inout float2 referenceCoord, in float fontSize)
+{
+    const uint charWidth = DEBUG_FONT_TEXT_WIDTH * fontSize * DEBUG_FONT_TEXT_SCALE;
+    const uint maxCharCount = 16;
+    float2 localRefCoord = referenceCoord + float2(GetTextSize(intValue, fontSize), 0);
+    referenceCoord = localRefCoord + float2(charWidth, 0);
+
+    float3 output = float3(0, 0, 0);
+    for (uint charIt = 0; charIt < maxCharCount; ++charIt)
+    {
+        output += DrawCharacter((intValue % 10) + 48, coords, localRefCoord, fontSize, -1.0f).xyz;
+        if (intValue  < 10)
+            break;
+        intValue /= 10;
+    }
+
+    return output;
 }
 
 #endif

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugFullScreen.shader

             #pragma fragment Frag
 
             #include "CoreRP/ShaderLibrary/Common.hlsl"
+            #include "../ShaderVariables.hlsl"
-            #include "../ShaderVariables.hlsl"
+            #include "../Debug/DebugDisplay.hlsl"
 
             TEXTURE2D(_DebugFullScreenTexture);
             SAMPLER(sampler_DebugFullScreenTexture);
             }
             // <<<
 
-            float4 Frag(Varyings input) : SV_Target
+            float4 GetResult(Varyings input, float2 coord)
-                    return 1.0f - SAMPLE_TEXTURE2D(_DebugFullScreenTexture, sampler_DebugFullScreenTexture, input.texcoord).xxxx;
+                    return 1.0f - SAMPLE_TEXTURE2D(_DebugFullScreenTexture, sampler_DebugFullScreenTexture, coord).xxxx;
-                #if UNITY_UV_STARTS_AT_TOP
+#if UNITY_UV_STARTS_AT_TOP
-                #endif
+#endif
-                    float4 color = SAMPLE_TEXTURE2D(_DebugFullScreenTexture, sampler_DebugFullScreenTexture, input.texcoord);
+                    float4 color = SAMPLE_TEXTURE2D(_DebugFullScreenTexture, sampler_DebugFullScreenTexture, coord);
 
                     if (any(isnan(color)) || any(isinf(color)))
                     {
                 }
                 if (_FullScreenDebugMode == FULLSCREENDEBUGMODE_MOTION_VECTORS)
                 {
-                    float2 mv = SampleMotionVectors(input.texcoord);
+                    float2 mv = SampleMotionVectors(coord);
 
                     // Background color intensity - keep this low unless you want to make your eyes bleed
                     const float kIntensity = 0.15;
                 }
                 if (_FullScreenDebugMode == FULLSCREENDEBUGMODE_DEFERRED_SHADOWS)
                 {
-                    float4 color = SAMPLE_TEXTURE2D(_DebugFullScreenTexture, sampler_DebugFullScreenTexture, input.texcoord);
+                    float4 color = SAMPLE_TEXTURE2D(_DebugFullScreenTexture, sampler_DebugFullScreenTexture, coord);
-                    float4 color = SAMPLE_TEXTURE2D(_DebugFullScreenTexture, sampler_DebugFullScreenTexture, input.texcoord);
+                    float4 color = SAMPLE_TEXTURE2D(_DebugFullScreenTexture, sampler_DebugFullScreenTexture, coord);
-                    float4 color = SAMPLE_TEXTURE2D(_DebugFullScreenTexture, sampler_DebugFullScreenTexture, input.texcoord);
+                    float4 color = SAMPLE_TEXTURE2D(_DebugFullScreenTexture, sampler_DebugFullScreenTexture, coord);
+            }
+
+            float4 Frag(Varyings input) : SV_Target
+            {
+                float4 result = GetResult(input, input.texcoord);
+
+                if (_MousePixelCoord.z >= 0.0 && _MousePixelCoord.z <= 1.0 && _MousePixelCoord.w >= 0 && _MousePixelCoord.w <= 1.0)
+                {
+                    float2 unormTextCoord2d = float2(_MousePixelCoord.x - DEBUG_FONT_TEXT_WIDTH, _MousePixelCoord.y - DEBUG_FONT_TEXT_WIDTH * DEBUG_FONT_TEXT_SIZE);
+                    float2 unormCoord2d = input.positionCS.xy;
+
+                    float4 mouseResult = GetResult(input, _MousePixelCoord);
+
+                    float2 textCoord = unormTextCoord2d;
+                    textCoord.x -= GetTextSize(mouseResult.x, DEBUG_FONT_TEXT_SIZE);
+
+                    result.rgb += DrawInteger(mouseResult.x, unormCoord2d, textCoord, DEBUG_FONT_TEXT_SIZE);
+                    result.rgb += DrawCharacter(' ', unormCoord2d, textCoord, 1.0f);
+                    result.rgb += DrawCharacter('t', unormCoord2d, textCoord, 1.0f);
+                    result.rgb += DrawCharacter('e', unormCoord2d, textCoord, 1.0f);
+                    result.rgb += DrawCharacter('s', unormCoord2d, textCoord, 1.0f);
+                    result.rgb += DrawCharacter('t', unormCoord2d, textCoord, 1.0f);
+                }
+
+                return result;
             }
 
             ENDHLSL

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugViewTiles.shader

 
             uint _ViewTilesFlags;
             uint _NumTiles;
-            float2 _MousePixelCoord;
+            float4 _MousePixelCoord; // xy unorm, zw norm
 
             StructuredBuffer<uint> g_TileList;
             Buffer<uint> g_DispatchIndirectBuffer;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDAssetFactory.cs

                 newAsset.defaultDiffuseMaterial = Load<Material>(HDRenderPipelinePath + "RenderPipelineResources/DefaultHDMaterial.mat");
                 newAsset.defaultShader = Load<Shader>(HDRenderPipelinePath + "Material/Lit/Lit.shader");
 
+                newAsset.debugFontTexture = Load<Texture2D>(HDRenderPipelinePath + "RenderPipelineResources/DebugFont.tga");
                 newAsset.debugDisplayLatlongShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugDisplayLatlong.Shader");
                 newAsset.debugViewMaterialGBufferShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugViewMaterialGBuffer.Shader");
                 newAsset.debugViewTilesShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugViewTiles.Shader");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

 using System.Collections.Generic;
 using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering;
 using System;
 using System.Diagnostics;
 using UnityEngine.Rendering.PostProcessing;
             FrameSettings.RegisterDebug("Default Camera", m_Asset.GetFrameSettings());
             m_DebugFullScreenTempRT = HDShaderIDs._DebugFullScreenTexture;
 
+            // For debugging
+            MousePositionDebug.instance.Build();
+
             InitializeRenderStateBlocks();
         }
 
             base.Dispose();
 
             m_LightLoop.Cleanup();
+
+            // For debugging
+            MousePositionDebug.instance.Cleanup();
 
             m_MaterialList.ForEach(material => material.Cleanup());
 
                         }
                     }
 
-                    ApplyDebugDisplaySettings(cmd);
+                    var postProcessLayer = camera.GetComponent<PostProcessLayer>();
+                    var hdCamera = HDCamera.Get(camera, postProcessLayer, m_FrameSettings);
+
+                    Resize(hdCamera);
+
+                    if (m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled() || m_CurrentDebugDisplaySettings.fullScreenDebugMode != FullScreenDebugMode.None)
+                    {
+                        ApplyDebugDisplaySettings(hdCamera, cmd);
+                    }
                     UpdateShadowSettings();
 
                     // TODO: Float HDCamera setup higher in order to pass stereo into GetCullingParameters
                         m_DbufferManager.vsibleDecalCount = DecalSystem.instance.QueryCullResults();
                         DecalSystem.instance.EndCull();
                     }
-
-                    var postProcessLayer = camera.GetComponent<PostProcessLayer>();
-                    var hdCamera = HDCamera.Get(camera, postProcessLayer, m_FrameSettings);
-
-                    Resize(hdCamera);
 
                     if (m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled())
                     {
                 }
             }
 
-        public void ApplyDebugDisplaySettings(CommandBuffer cmd)
+        public void ApplyDebugDisplaySettings(HDCamera hdCamera, CommandBuffer cmd)
         {
             m_ShadowSettings.enabled = m_FrameSettings.enableShadow;
 
             cmd.SetGlobalVector(HDShaderIDs._DebugLightingAlbedo, debugAlbedo);
             cmd.SetGlobalVector(HDShaderIDs._DebugLuxMeterParam, luxMeterParam);
             cmd.SetGlobalVector(HDShaderIDs._DebugLightingSmoothness, debugSmoothness);
+
+            Vector2 mousePixelCoord = MousePositionDebug.instance.GetMousePosition(hdCamera.screenSize.y);
+            var mouseParam = new Vector4(mousePixelCoord.x, mousePixelCoord.y, mousePixelCoord.x / hdCamera.screenSize.x, mousePixelCoord.y / hdCamera.screenSize.y);
+            cmd.SetGlobalVector(HDShaderIDs._MousePixelCoord, mouseParam);
+
+            cmd.SetGlobalTexture(HDShaderIDs._DebugFont, m_Asset.renderPipelineResources.debugFontTexture);
         }
 
         public void PushFullScreenDebugTexture(CommandBuffer cb, RenderTargetIdentifier textureID, HDCamera hdCamera, ScriptableRenderContext renderContext, FullScreenDebugMode debugMode)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDStringConstants.cs

 
         public static readonly int _ViewTilesFlags = Shader.PropertyToID("_ViewTilesFlags");
         public static readonly int _MousePixelCoord = Shader.PropertyToID("_MousePixelCoord");
+        public static readonly int _DebugFont = Shader.PropertyToID("_DebugMipMapMode");
 
         public static readonly int _DebugViewMaterial = Shader.PropertyToID("_DebugViewMaterial");
         public static readonly int _DebugLightingMode = Shader.PropertyToID("_DebugLightingMode");
         public static readonly int _AmbientOcclusionTexture = Shader.PropertyToID("_AmbientOcclusionTexture");
         public static readonly int _DebugMipMapMode = Shader.PropertyToID("_DebugMipMapMode");
+
+
 
         public static readonly int _UseTileLightList = Shader.PropertyToID("_UseTileLightList");
         public static readonly int _Time = Shader.PropertyToID("_Time");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Deferred.shader

             #define SHADERPASS SHADERPASS_DEFERRED_LIGHTING
 
             #include "CoreRP/ShaderLibrary/Common.hlsl"
-            #include "../Debug/DebugDisplay.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),
+            #include "../Debug/DebugDisplay.hlsl"
             #include "../Lighting/Lighting.hlsl" // This include Material.hlsl
 
             //-------------------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/Deferred.compute

 #define SHADERPASS SHADERPASS_DEFERRED_LIGHTING
 
 #include "CoreRP/ShaderLibrary/Common.hlsl"
-#include "../../Debug/DebugDisplay.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),
+#include "../../Debug/DebugDisplay.hlsl"
 #include "../../Lighting/Lighting.hlsl" // This include Material.hlsl
 
 //-------------------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoop.cs

-using UnityEngine.Rendering;
+using System;
-using System;
+using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
             s_DefaultTextureCube = new Cubemap(16, TextureFormat.ARGB32, false);
             s_DefaultTextureCube.Apply();
 
-#if UNITY_EDITOR
-            UnityEditor.SceneView.onSceneGUIDelegate -= OnSceneGUI;
-            UnityEditor.SceneView.onSceneGUIDelegate += OnSceneGUI;
-#endif
-
             InitShadowSystem(hdAsset.GetRenderPipelineSettings().shadowInitParams, shadowSettings);
         }
 
-
-#if UNITY_EDITOR
-            UnityEditor.SceneView.onSceneGUIDelegate -= OnSceneGUI;
-#endif
 
             CoreUtils.SafeRelease(s_DirectionalLightDatas);
             CoreUtils.SafeRelease(s_LightDatas);
             }
         }
 
-#if UNITY_EDITOR
-        private Vector2 m_mousePosition = Vector2.zero;
-
-        private void OnSceneGUI(UnityEditor.SceneView sceneview)
-        {
-            m_mousePosition = Event.current.mousePosition;
-        }
-
-#endif
-
         public void RenderShadows(ScriptableRenderContext renderContext, CommandBuffer cmd, CullResults cullResults)
         {
             // kick off the shadow jobs here
                     int numTilesY = (h + 15) / 16;
                     int numTiles = numTilesX * numTilesY;
 
-                    Vector2 mousePixelCoord = Input.mousePosition;
-#if UNITY_EDITOR
-                    if (!UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode)
-                    {
-                        mousePixelCoord = m_mousePosition;
-                        mousePixelCoord.y = (hdCamera.screenSize.y - 1.0f) - mousePixelCoord.y;
-                    }
-#endif
+                    Vector2 mousePixelCoord = MousePositionDebug.instance.GetMousePosition(hdCamera.screenSize.y);
 
                     // Debug tiles
                     if (lightingDebug.tileClusterDebug == LightLoop.TileClusterDebug.MaterialFeatureVariants)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/RenderPipelineResources.cs

         public Shader defaultShader;
 
         // Debug
+        public Texture2D debugFontTexture;
         public Shader debugDisplayLatlongShader;
         public Shader debugViewMaterialGBufferShader;
         public Shader debugViewTilesShader;

ScriptableRenderPipeline/Core/CoreRP/MousePositionDebug.cs

+using System;
+
+namespace UnityEngine.Experimental.Rendering
+{
+    public class MousePositionDebug
+    {
+        // Singleton
+        private static MousePositionDebug s_Instance = null;
+
+        static public MousePositionDebug instance
+        {
+            get
+            {
+                if (s_Instance == null)
+                {
+                    s_Instance = new MousePositionDebug();
+                }
+
+                return s_Instance;
+            }
+        }
+
+        private Vector2 m_mousePosition = Vector2.zero;
+
+        private void OnSceneGUI(UnityEditor.SceneView sceneview)
+        {
+            m_mousePosition = Event.current.mousePosition;
+        }
+
+        public void Build()
+        {
+#if UNITY_EDITOR
+            UnityEditor.SceneView.onSceneGUIDelegate -= OnSceneGUI;
+            UnityEditor.SceneView.onSceneGUIDelegate += OnSceneGUI;
+#endif
+        }
+
+        public void Cleanup()
+        {
+#if UNITY_EDITOR
+            UnityEditor.SceneView.onSceneGUIDelegate -= OnSceneGUI;
+#endif
+        }
+
+        public Vector2 GetMousePosition(float ScreenHeight)
+        {
+            Vector2 mousePixelCoord = Input.mousePosition;
+#if UNITY_EDITOR
+            if (!UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode)
+            {
+                mousePixelCoord = m_mousePosition;
+                mousePixelCoord.y = (ScreenHeight - 1.0f) - mousePixelCoord.y;
+            }
+#endif
+            return mousePixelCoord;
+        }
+    }
+}

ScriptableRenderPipeline/Core/CoreRP/MousePositionDebug.cs.meta

+fileFormatVersion: 2
+guid: 16870bb28557a8f4182d1c8191e951a5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/DebugFont.tga.meta

+fileFormatVersion: 2
+guid: a3ad2df0e49aaa341a3b3a80f93b3f66
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Windows Store Apps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: