Ui 쉐이더 및 애니메이션 쉐이더 파라미터 에셋 추가

# Conflicts:
#	Assets/_DDD/Restaurant/Environments/Props/_old/Spines/Coral/Coral_SkeletonData.asset
#	Assets/_DDD/Restaurant/Environments/Props/_old/Spines/Coral/Coral_SkeletonData.asset.meta
#	Assets/_DDD/Restaurant/Environments/Props/_old/Spines/SummerGrass01/SummerGrass01_SkeletonData.asset
#	Assets/_DDD/Restaurant/Environments/Props/_old/Spines/SummerGrass01/SummerGrass01_SkeletonData.asset.meta

Assets/AddressableAssetsData/AddressableAssetSettings.asset

@@ -15,7 +15,7 @@ MonoBehaviour:
   m_DefaultGroup: 30e7f67fe9aaa7849a34c9b6e2bc53ae
   m_currentHash:
     serializedVersion: 2
-    Hash: 00000000000000000000000000000000
+    Hash: 80877e8797db36365aab79401e568f96
   m_OptimizeCatalogSize: 0
   m_BuildRemoteCatalog: 1
   m_CatalogRequestsTimeout: 0

Assets/Plugins/AllIn1SpriteShader/Scripts/Editor/AllIn1SpriteShaderUiMask2MaterialInspector.cs

@@ -0,0 +1,759 @@
+#if UNITY_EDITOR
+using System.Linq;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+[CanEditMultipleObjects]
+public class AllIn1SpriteShaderUiMask2MaterialInspector : ShaderGUI
+{
+    private Material targetMat;
+    private BlendMode srcMode, dstMode;
+
+    private GUIStyle propertiesStyle, bigLabelStyle, smallLabelStyle, toggleButtonStyle;
+    private const int bigFontSize = 16, smallFontSize = 11;
+    private string[] oldKeyWords;
+    private int effectCount = 1;
+    private Material originalMaterialCopy;
+    private MaterialEditor matEditor;
+    private MaterialProperty[] matProperties;
+    private uint[] materialDrawers = new uint[] { 1, 2, 4 };
+    bool[] currEnabledDrawers;
+    private const uint advancedConfigDrawer = 0;
+    private const uint colorFxShapeDrawer = 1;
+    private const uint uvFxShapeDrawer = 2;
+
+    public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] properties)
+    {
+        matEditor = materialEditor;
+        matProperties = properties;
+        targetMat = materialEditor.target as Material;
+        effectCount = 1;
+        oldKeyWords = targetMat.shaderKeywords;
+        propertiesStyle = new GUIStyle(EditorStyles.helpBox);
+        propertiesStyle.margin = new RectOffset(0, 0, 0, 0);
+        bigLabelStyle = new GUIStyle(EditorStyles.boldLabel);
+        bigLabelStyle.fontSize = bigFontSize;
+        smallLabelStyle = new GUIStyle(EditorStyles.boldLabel);
+        smallLabelStyle.fontSize = smallFontSize;
+        toggleButtonStyle = new GUIStyle(GUI.skin.button) { alignment = TextAnchor.MiddleCenter, richText = true };
+        currEnabledDrawers = new bool[materialDrawers.Length];
+        uint iniDrawers = (uint)ShaderGUI.FindProperty("_EditorDrawers", matProperties).floatValue;
+        for(int i = 0; i < materialDrawers.Length; i++) currEnabledDrawers[i] = (materialDrawers[i] & iniDrawers) > 0;
+
+        GUILayout.Label("General Properties", bigLabelStyle);
+        DrawProperty(0);
+        DrawProperty(1);
+        DrawProperty(2);
+        
+        
+        currEnabledDrawers[advancedConfigDrawer] = GUILayout.Toggle(currEnabledDrawers[advancedConfigDrawer], new GUIContent("<size=12>Show Advanced Configuration</size>"), toggleButtonStyle);
+        if(currEnabledDrawers[advancedConfigDrawer])
+        {
+            
+            EditorGUILayout.BeginVertical(propertiesStyle);
+            Blending();
+            DrawLine(Color.grey, 1, 3);
+            SpriteAtlas("Sprite inside an atlas?", "ATLAS_ON");
+            DrawLine(Color.grey, 1, 3);
+            materialEditor.EnableInstancingField();
+            DrawLine(Color.grey, 1, 3);
+            materialEditor.RenderQueueField();
+            EditorGUILayout.EndVertical();
+        }
+
+        EditorGUILayout.Separator();
+        DrawLine(Color.grey, 1, 3);
+        GUILayout.Label("Color Effects", bigLabelStyle);
+
+        currEnabledDrawers[colorFxShapeDrawer] = GUILayout.Toggle(currEnabledDrawers[colorFxShapeDrawer], new GUIContent("Show Color Effects"), toggleButtonStyle);
+        if(currEnabledDrawers[colorFxShapeDrawer])
+        {
+            Glow("Glow", "GLOW_ON");
+            GenericEffect("Fade", "FADE_ON", 7, 13);
+            Outline("Outline", "OUTBASE_ON");
+            GenericEffect("Alpha Outline", "ALPHAOUTLINE_ON", 26, 30, true, "A more performant but less flexible outline");
+            InnerOutline("Inner Outline", "INNEROUTLINE_ON", 66, 69);
+            Gradient("Gradient & Radial Gradient", "GRADIENT_ON");
+            GenericEffect("Color Swap", "COLORSWAP_ON", 36, 42, true, "You will need a mask texture (see Documentation)", new int[] { 154 });
+            GenericEffect("Hue Shift", "HSV_ON", 43, 45);
+            ColorChange("Change 1 Color", "CHANGECOLOR_ON");
+            ColorRamp("Color Ramp", "COLORRAMP_ON");
+            GenericEffect("Hit Effect", "HITEFFECT_ON", 46, 48);
+            GenericEffect("Negative", "NEGATIVE_ON", 49, 49);
+            GenericEffect("Pixelate", "PIXELATE_ON", 50, 50, true, "Looks bad with distorition effects");
+            GreyScale("GreyScale", "GREYSCALE_ON");
+            Posterize("Posterize", "POSTERIZE_ON");
+            Blur("Blur", "BLUR_ON");
+            GenericEffect("Motion Blur", "MOTIONBLUR_ON", 62, 63);
+            GenericEffect("Ghost", "GHOST_ON", 64, 65, true, "This effect will not affect the outline", new int[] { 157 });
+            GenericEffect("Hologram", "HOLOGRAM_ON", 73, 77, true, null, new int[] { 140, 158 });
+            GenericEffect("Chromatic Aberration", "CHROMABERR_ON", 78, 79);
+            GenericEffect("Glitch", "GLITCH_ON", 80, 80, true, null, new int[] { 139 });
+            GenericEffect("Flicker", "FLICKER_ON", 81, 83);
+            GenericEffect("Shadow", "SHADOW_ON", 84, 87);
+            GenericEffect("Shine", "SHINE_ON", 133, 138);
+            GenericEffect("Contrast & Brightness", "CONTRAST_ON", 152, 153);
+            Overlay("Overlay Texture", "OVERLAY_ON");
+            GenericEffect("Alpha Cutoff", "ALPHACUTOFF_ON", 70, 70);
+            GenericEffect("Alpha Round", "ALPHAROUND_ON", 144, 144);
+        }
+
+        DrawLine(Color.grey, 1, 3);
+        GUILayout.Label("UV Effects", bigLabelStyle);
+
+        currEnabledDrawers[uvFxShapeDrawer] = GUILayout.Toggle(currEnabledDrawers[uvFxShapeDrawer], new GUIContent("Show Alpha Effects"), toggleButtonStyle);
+        if(currEnabledDrawers[uvFxShapeDrawer])
+        {
+            GenericEffect("Hand Drawn", "DOODLE_ON", 88, 89);
+            Grass("Grass Movement / Wind", "WIND_ON");
+            GenericEffect("Wave", "WAVEUV_ON", 94, 98);
+            GenericEffect("Round Wave", "ROUNDWAVEUV_ON", 127, 128);
+            GenericEffect("Rect Size (Enable wireframe to see result)", "RECTSIZE_ON", 99, 99, true, "Only on single sprites spritesheets NOT supported");
+            GenericEffect("Offset", "OFFSETUV_ON", 100, 101);
+            GenericEffect("Clipping / Fill Amount", "CLIPPING_ON", 102, 105);
+            GenericEffect("Radial Clipping / Radial Fill", "RADIALCLIPPING_ON", 164, 166);
+            GenericEffect("Texture Scroll", "TEXTURESCROLL_ON", 106, 107, true, "Set Texture Wrap Mode to Repeat");
+            GenericEffect("Zoom", "ZOOMUV_ON", 108, 108);
+            GenericEffect("Distortion", "DISTORT_ON", 109, 112);
+            GenericEffect("Warp Distortion", "WARP_ON", 167, 169);
+            GenericEffect("Twist", "TWISTUV_ON", 113, 116);
+            GenericEffect("Rotate", "ROTATEUV_ON", 117, 117, true, "_Tip_ Use Clipping effect to avoid possible undesired parts");
+            GenericEffect("Polar Coordinates (Tile texture for good results)", "POLARUV_ON", -1, -1);
+            GenericEffect("Fish Eye", "FISHEYE_ON", 118, 118);
+            GenericEffect("Pinch", "PINCH_ON", 119, 119);
+            GenericEffect("Shake", "SHAKEUV_ON", 120, 122);
+        }
+
+        SetAndSaveEnabledDrawers(iniDrawers);
+    }
+    
+    private void SetAndSaveEnabledDrawers(uint iniDrawers)
+    {
+        uint currDrawers = 0;
+        for(int i = 0; i < currEnabledDrawers.Length; i++)
+        {
+            if(currEnabledDrawers[i]) currDrawers |= materialDrawers[i];
+        }
+
+        if(iniDrawers != currDrawers) ShaderGUI.FindProperty("_EditorDrawers", matProperties).floatValue = currDrawers;
+    }
+
+    private void Blending()
+    {
+        MaterialProperty srcM = ShaderGUI.FindProperty("_MySrcMode", matProperties);
+        MaterialProperty dstM = ShaderGUI.FindProperty("_MyDstMode", matProperties);
+        if(srcM.floatValue == 0 && dstM.floatValue == 0)
+        {
+            srcM.floatValue = 5;
+            dstM.floatValue = 10;
+        }
+
+        GUILayout.Label("Look for 'ShaderLab: Blending' if you don't know what this is", smallLabelStyle);
+        if(GUILayout.Button("Back To Default Blending"))
+        {
+            srcM.floatValue = 5;
+            dstM.floatValue = 10;
+            targetMat.DisableKeyword("PREMULTIPLYALPHA_ON");
+        }
+
+        srcMode = (BlendMode)srcM.floatValue;
+        dstMode = (BlendMode)dstM.floatValue;
+        srcMode = (BlendMode)EditorGUILayout.EnumPopup("SrcMode", srcMode);
+        dstMode = (BlendMode)EditorGUILayout.EnumPopup("DstMode", dstMode);
+        srcM.floatValue = (float)(srcMode);
+        dstM.floatValue = (float)(dstMode);
+
+        bool ini = oldKeyWords.Contains("PREMULTIPLYALPHA_ON");
+        bool toggle = EditorGUILayout.Toggle("Premultiply Alpha?", ini);
+        if(ini != toggle) Save();
+        if(toggle) targetMat.EnableKeyword("PREMULTIPLYALPHA_ON");
+        else targetMat.DisableKeyword("PREMULTIPLYALPHA_ON");
+    }
+
+    private void SpriteAtlas(string inspector, string keyword)
+    {
+        bool toggle = oldKeyWords.Contains(keyword);
+        bool ini = toggle;
+        toggle = GUILayout.Toggle(toggle, inspector);
+        if(ini != toggle) Save();
+        if(toggle)
+        {
+            targetMat.EnableKeyword(keyword);
+            EditorGUILayout.BeginVertical(propertiesStyle);
+            {
+                GUILayout.Label("Make sure SpriteAtlasUV component is added \n " +
+                                "*Check documentation if unsure what this does or how it works", smallLabelStyle);
+            }
+            EditorGUILayout.EndVertical();
+        }
+        else targetMat.DisableKeyword(keyword);
+    }
+
+    private void Outline(string inspector, string keyword)
+    {
+        bool toggle = oldKeyWords.Contains(keyword);
+        bool ini = toggle;
+
+        GUIContent effectNameLabel = new GUIContent();
+        effectNameLabel.tooltip = keyword + " (C#)";
+        effectNameLabel.text = effectCount + ".Outline";
+        toggle = EditorGUILayout.BeginToggleGroup(effectNameLabel, toggle);
+
+        effectCount++;
+        if(ini != toggle) Save();
+        if(toggle)
+        {
+            targetMat.EnableKeyword("OUTBASE_ON");
+            EditorGUILayout.BeginVertical(propertiesStyle);
+            {
+                DrawProperty(14);
+                DrawProperty(15);
+                DrawProperty(16);
+                DrawEffectSubKeywordToggle("Outline High Resolution?", "OUTBASE8DIR_ON");
+
+                DrawLine(Color.grey, 1, 3);
+                bool outlinePixelPerf = DrawEffectSubKeywordToggle("Outline is Pixel Perfect?", "OUTBASEPIXELPERF_ON");
+                if(outlinePixelPerf) DrawProperty(18);
+                else DrawProperty(17);
+
+                DrawLine(Color.grey, 1, 3);
+                bool outlineTexture = DrawEffectSubKeywordToggle("Outline uses texture?", "OUTTEX_ON");
+                if(outlineTexture)
+                {
+                    DrawProperty(19);
+                    DrawProperty(20);
+                    DrawProperty(21);
+                    DrawProperty(172);
+                }
+
+                DrawLine(Color.grey, 1, 3);
+                bool outlineDistort = DrawEffectSubKeywordToggle("Outline uses distortion?", "OUTDIST_ON");
+                if(outlineDistort)
+                {
+                    DrawProperty(22);
+                    DrawProperty(23);
+                    DrawProperty(24);
+                    DrawProperty(25);
+                }
+
+                DrawLine(Color.grey, 1, 3);
+                DrawEffectSubKeywordToggle("Only render outline?", "ONLYOUTLINE_ON");
+            }
+            EditorGUILayout.EndVertical();
+        }
+        else targetMat.DisableKeyword("OUTBASE_ON");
+
+        EditorGUILayout.EndToggleGroup();
+    }
+
+    private void GenericEffect(string inspector, string keyword, int first, int last, bool effectCounter = true, string preMessage = null, int[] extraProperties = null, bool boldToggleLetters = true)
+    {
+        bool toggle = oldKeyWords.Contains(keyword);
+        bool ini = toggle;
+
+        GUIContent effectNameLabel = new GUIContent();
+        effectNameLabel.tooltip = keyword + " (C#)";
+        if(effectCounter)
+        {
+            effectNameLabel.text = effectCount + "." + inspector;
+            effectCount++;
+        }
+        else effectNameLabel.text = inspector;
+        if(boldToggleLetters) toggle = EditorGUILayout.BeginToggleGroup(effectNameLabel, toggle);
+        else toggle = GUILayout.Toggle(toggle, effectNameLabel);
+
+        if(ini != toggle) Save();
+        if(toggle)
+        {
+            targetMat.EnableKeyword(keyword);
+            if(first > 0)
+            {
+                EditorGUILayout.BeginVertical(propertiesStyle);
+                {
+                    if(preMessage != null) GUILayout.Label(preMessage, smallLabelStyle);
+                    for(int i = first; i <= last; i++) DrawProperty(i);
+                    if(extraProperties != null)
+                        foreach(int i in extraProperties)
+                            DrawProperty(i);
+                }
+                EditorGUILayout.EndVertical();
+            }
+        }
+        else targetMat.DisableKeyword(keyword);
+
+        if(boldToggleLetters) EditorGUILayout.EndToggleGroup();
+    }
+
+    private void Glow(string inspector, string keyword)
+    {
+        bool toggle = oldKeyWords.Contains(keyword);
+        bool ini = toggle;
+
+        GUIContent effectNameLabel = new GUIContent();
+        effectNameLabel.tooltip = keyword + " (C#)";
+        effectNameLabel.text = effectCount + "." + inspector;
+        toggle = EditorGUILayout.BeginToggleGroup(effectNameLabel, toggle);
+
+        effectCount++;
+        if(ini != toggle) Save();
+        if(toggle)
+        {
+            targetMat.EnableKeyword("GLOW_ON");
+            EditorGUILayout.BeginVertical(propertiesStyle);
+            {
+                bool useGlowTex = DrawEffectSubKeywordToggle("Use Glow Texture?", "GLOWTEX_ON");
+                if(useGlowTex) DrawProperty(6);
+
+                DrawProperty(3);
+                DrawProperty(4);
+                DrawProperty(5, true);
+            }
+            EditorGUILayout.EndVertical();
+        }
+        else targetMat.DisableKeyword("GLOW_ON");
+
+        EditorGUILayout.EndToggleGroup();
+    }
+
+    private void ColorRamp(string inspector, string keyword)
+    {
+        bool toggle = oldKeyWords.Contains(keyword);
+        bool ini = toggle;
+
+        GUIContent effectNameLabel = new GUIContent();
+        effectNameLabel.tooltip = keyword + " (C#)";
+        effectNameLabel.text = effectCount + "." + inspector;
+        toggle = EditorGUILayout.BeginToggleGroup(effectNameLabel, toggle);
+
+        effectCount++;
+        if(ini != toggle) Save();
+        if(toggle)
+        {
+            targetMat.EnableKeyword("COLORRAMP_ON");
+            EditorGUILayout.BeginVertical(propertiesStyle);
+            {
+                bool useEditableGradient = false;
+                if(AssetDatabase.Contains(targetMat))
+                {
+                    useEditableGradient = oldKeyWords.Contains("GRADIENTCOLORRAMP_ON");
+                    bool gradientTex = useEditableGradient;
+                    gradientTex = GUILayout.Toggle(gradientTex, new GUIContent("Use Editable Gradient?"));
+                    if(useEditableGradient != gradientTex)
+                    {
+                        Save();
+                        if(gradientTex)
+                        {
+                            useEditableGradient = true;
+                            targetMat.EnableKeyword("GRADIENTCOLORRAMP_ON");
+                        }
+                        else targetMat.DisableKeyword("GRADIENTCOLORRAMP_ON");
+                    }
+
+                    if(useEditableGradient) matEditor.ShaderProperty(matProperties[159], matProperties[159].displayName);
+                }
+                else GUILayout.Label("*Save to folder to allow for dynamic Gradient property", smallLabelStyle);
+
+                if(!useEditableGradient) DrawProperty(51);
+
+                DrawProperty(52);
+                DrawProperty(53, true);
+                MaterialProperty colorRampOut = matProperties[53];
+                if(colorRampOut.floatValue == 1) targetMat.EnableKeyword("COLORRAMPOUTLINE_ON");
+                else targetMat.DisableKeyword("COLORRAMPOUTLINE_ON");
+                DrawProperty(155);
+            }
+            EditorGUILayout.EndVertical();
+        }
+        else targetMat.DisableKeyword("COLORRAMP_ON");
+
+        EditorGUILayout.EndToggleGroup();
+    }
+
+    private void ColorChange(string inspector, string keyword)
+    {
+        bool toggle = oldKeyWords.Contains(keyword);
+        bool ini = toggle;
+
+        GUIContent effectNameLabel = new GUIContent();
+        effectNameLabel.tooltip = keyword + " (C#)";
+        effectNameLabel.text = effectCount + "." + inspector;
+        toggle = EditorGUILayout.BeginToggleGroup(effectNameLabel, toggle);
+
+        effectCount++;
+        if(ini != toggle) Save();
+        if(toggle)
+        {
+            targetMat.EnableKeyword("CHANGECOLOR_ON");
+            EditorGUILayout.BeginVertical(propertiesStyle);
+            {
+                for(int i = 123; i < 127; i++) DrawProperty(i);
+
+                DrawLine(Color.grey, 1, 3);
+                ini = oldKeyWords.Contains("CHANGECOLOR2_ON");
+                bool toggle2 = ini;
+                toggle2 = EditorGUILayout.Toggle("Use Color 2", ini);
+                if(ini != toggle2) Save();
+                if(toggle2)
+                {
+                    targetMat.EnableKeyword("CHANGECOLOR2_ON");
+                    for(int i = 146; i < 149; i++) DrawProperty(i);
+                }
+                else targetMat.DisableKeyword("CHANGECOLOR2_ON");
+
+                DrawLine(Color.grey, 1, 3);
+                ini = oldKeyWords.Contains("CHANGECOLOR3_ON");
+                toggle2 = ini;
+                toggle2 = EditorGUILayout.Toggle("Use Color 3", toggle2);
+                if(ini != toggle2) Save();
+                if(toggle2)
+                {
+                    targetMat.EnableKeyword("CHANGECOLOR3_ON");
+                    for(int i = 149; i < 152; i++) DrawProperty(i);
+                }
+                else targetMat.DisableKeyword("CHANGECOLOR3_ON");
+            }
+            EditorGUILayout.EndVertical();
+        }
+        else targetMat.DisableKeyword("CHANGECOLOR_ON");
+
+        EditorGUILayout.EndToggleGroup();
+    }
+
+    private void GreyScale(string inspector, string keyword)
+    {
+        bool toggle = oldKeyWords.Contains(keyword);
+        bool ini = toggle;
+
+        GUIContent effectNameLabel = new GUIContent();
+        effectNameLabel.tooltip = keyword + " (C#)";
+        effectNameLabel.text = effectCount + "." + inspector;
+        toggle = EditorGUILayout.BeginToggleGroup(effectNameLabel, toggle);
+
+        effectCount++;
+        if(ini != toggle) Save();
+        if(toggle)
+        {
+            targetMat.EnableKeyword("GREYSCALE_ON");
+            EditorGUILayout.BeginVertical(propertiesStyle);
+            {
+                DrawProperty(54);
+                DrawProperty(56);
+                DrawProperty(55, true);
+                MaterialProperty greyScaleOut = matProperties[55];
+                if(greyScaleOut.floatValue == 1) targetMat.EnableKeyword("GREYSCALEOUTLINE_ON");
+                else targetMat.DisableKeyword("GREYSCALEOUTLINE_ON");
+                DrawProperty(156);
+            }
+            EditorGUILayout.EndVertical();
+        }
+        else targetMat.DisableKeyword("GREYSCALE_ON");
+
+        EditorGUILayout.EndToggleGroup();
+    }
+
+    private void Posterize(string inspector, string keyword)
+    {
+        bool toggle = oldKeyWords.Contains(keyword);
+        bool ini = toggle;
+
+        GUIContent effectNameLabel = new GUIContent();
+        effectNameLabel.tooltip = keyword + " (C#)";
+        effectNameLabel.text = effectCount + "." + inspector;
+        toggle = EditorGUILayout.BeginToggleGroup(effectNameLabel, toggle);
+
+        effectCount++;
+        if(ini != toggle) Save();
+        if(toggle)
+        {
+            targetMat.EnableKeyword("POSTERIZE_ON");
+            EditorGUILayout.BeginVertical(propertiesStyle);
+            {
+                DrawProperty(57);
+                DrawProperty(58);
+                DrawProperty(59, true);
+                MaterialProperty posterizeOut = matProperties[59];
+                if(posterizeOut.floatValue == 1) targetMat.EnableKeyword("POSTERIZEOUTLINE_ON");
+                else targetMat.DisableKeyword("POSTERIZEOUTLINE_ON");
+            }
+            EditorGUILayout.EndVertical();
+        }
+        else targetMat.DisableKeyword("POSTERIZE_ON");
+
+        EditorGUILayout.EndToggleGroup();
+    }
+
+    private void Blur(string inspector, string keyword)
+    {
+        bool toggle = oldKeyWords.Contains(keyword);
+        bool ini = toggle;
+
+        GUIContent effectNameLabel = new GUIContent();
+        effectNameLabel.tooltip = keyword + " (C#)";
+        effectNameLabel.text = effectCount + "." + inspector;
+        toggle = EditorGUILayout.BeginToggleGroup(effectNameLabel, toggle);
+
+        effectCount++;
+        if(ini != toggle) Save();
+        if(toggle)
+        {
+            targetMat.EnableKeyword("BLUR_ON");
+            EditorGUILayout.BeginVertical(propertiesStyle);
+            {
+                GUILayout.Label("This effect will not affect the outline", smallLabelStyle);
+                DrawProperty(60);
+                DrawProperty(61, true);
+                MaterialProperty blurIsHd = matProperties[61];
+                if(blurIsHd.floatValue == 1) targetMat.EnableKeyword("BLURISHD_ON");
+                else targetMat.DisableKeyword("BLURISHD_ON");
+            }
+            EditorGUILayout.EndVertical();
+        }
+        else targetMat.DisableKeyword("BLUR_ON");
+
+        EditorGUILayout.EndToggleGroup();
+    }
+
+    private void Grass(string inspector, string keyword)
+    {
+        bool toggle = oldKeyWords.Contains(keyword);
+        bool ini = toggle;
+
+        GUIContent effectNameLabel = new GUIContent();
+        effectNameLabel.tooltip = keyword + " (C#)";
+        effectNameLabel.text = effectCount + "." + inspector;
+        toggle = EditorGUILayout.BeginToggleGroup(effectNameLabel, toggle);
+
+        effectCount++;
+        if(ini != toggle) Save();
+        if(toggle)
+        {
+            targetMat.EnableKeyword("WIND_ON");
+            EditorGUILayout.BeginVertical(propertiesStyle);
+            {
+                DrawProperty(90);
+                DrawProperty(91);
+                DrawProperty(145);
+                DrawProperty(92);
+                DrawProperty(93, true);
+                MaterialProperty grassManual = matProperties[92];
+                if(grassManual.floatValue == 1) targetMat.EnableKeyword("MANUALWIND_ON");
+                else targetMat.DisableKeyword("MANUALWIND_ON");
+            }
+            EditorGUILayout.EndVertical();
+        }
+        else targetMat.DisableKeyword("WIND_ON");
+
+        EditorGUILayout.EndToggleGroup();
+    }
+
+    private void InnerOutline(string inspector, string keyword, int first, int last)
+    {
+        bool toggle = oldKeyWords.Contains(keyword);
+        bool ini = toggle;
+
+        GUIContent effectNameLabel = new GUIContent();
+        effectNameLabel.tooltip = keyword + " (C#)";
+        effectNameLabel.text = effectCount + "." + inspector;
+        toggle = EditorGUILayout.BeginToggleGroup(effectNameLabel, toggle);
+
+        effectCount++;
+        if(ini != toggle) Save();
+        if(toggle)
+        {
+            targetMat.EnableKeyword(keyword);
+            if(first > 0)
+            {
+                EditorGUILayout.BeginVertical(propertiesStyle);
+                {
+                    for(int i = first; i <= last; i++) DrawProperty(i);
+
+                    EditorGUILayout.Separator();
+                    DrawProperty(72, true);
+                    MaterialProperty onlyInOutline = matProperties[72];
+                    if(onlyInOutline.floatValue == 1) targetMat.EnableKeyword("ONLYINNEROUTLINE_ON");
+                    else targetMat.DisableKeyword("ONLYINNEROUTLINE_ON");
+                }
+                EditorGUILayout.EndVertical();
+            }
+        }
+        else targetMat.DisableKeyword(keyword);
+
+        EditorGUILayout.EndToggleGroup();
+    }
+
+    private void Gradient(string inspector, string keyword)
+    {
+        bool toggle = oldKeyWords.Contains(keyword);
+        bool ini = toggle;
+
+        GUIContent effectNameLabel = new GUIContent();
+        effectNameLabel.tooltip = keyword + " (C#)";
+        effectNameLabel.text = effectCount + "." + inspector;
+        toggle = EditorGUILayout.BeginToggleGroup(effectNameLabel, toggle);
+
+        effectCount++;
+        if(ini != toggle) Save();
+        if(toggle)
+        {
+            targetMat.EnableKeyword(keyword);
+
+            EditorGUILayout.BeginVertical(propertiesStyle);
+            {
+                DrawProperty(143, true);
+                MaterialProperty gradIsRadial = matProperties[143];
+                if(gradIsRadial.floatValue == 1)
+                {
+                    targetMat.EnableKeyword("RADIALGRADIENT_ON");
+                    DrawProperty(31);
+                    DrawProperty(32);
+                    DrawProperty(34);
+                    DrawProperty(141);
+                }
+                else
+                {
+                    targetMat.DisableKeyword("RADIALGRADIENT_ON");
+                    bool simpleGradient = oldKeyWords.Contains("GRADIENT2COL_ON");
+                    bool simpleGradToggle = EditorGUILayout.Toggle("2 Color Gradient?", simpleGradient);
+                    if(simpleGradient && !simpleGradToggle) targetMat.DisableKeyword("GRADIENT2COL_ON");
+                    else if(!simpleGradient && simpleGradToggle) targetMat.EnableKeyword("GRADIENT2COL_ON");
+                    DrawProperty(31);
+                    DrawProperty(32);
+                    if(!simpleGradToggle) DrawProperty(33);
+                    DrawProperty(34);
+                    if(!simpleGradToggle) DrawProperty(35);
+                    if(!simpleGradToggle) DrawProperty(141);
+                    DrawProperty(142);
+                }
+            }
+            EditorGUILayout.EndVertical();
+        }
+        else targetMat.DisableKeyword(keyword);
+
+        EditorGUILayout.EndToggleGroup();
+    }
+
+    private void Overlay(string inspector, string keyword)
+    {
+        bool toggle = oldKeyWords.Contains(keyword);
+        bool ini = toggle;
+
+        GUIContent effectNameLabel = new GUIContent();
+        effectNameLabel.tooltip = keyword + " (C#)";
+        effectNameLabel.text = effectCount + "." + inspector;
+        toggle = EditorGUILayout.BeginToggleGroup(effectNameLabel, toggle);
+
+        effectCount++;
+        if(ini != toggle) Save();
+        if(toggle)
+        {
+            targetMat.EnableKeyword(keyword);
+            EditorGUILayout.BeginVertical(propertiesStyle);
+            {
+                bool multModeOn = oldKeyWords.Contains("OVERLAYMULT_ON");
+                bool isMultMode = multModeOn;
+                isMultMode = GUILayout.Toggle(isMultMode, new GUIContent("Is overlay multiplicative?"));
+                if(multModeOn != isMultMode)
+                {
+                    Save();
+                    if(isMultMode)
+                    {
+                        multModeOn = true;
+                        targetMat.EnableKeyword("OVERLAYMULT_ON");
+                    }
+                    else targetMat.DisableKeyword("OVERLAYMULT_ON");
+                }
+
+                if(multModeOn) GUILayout.Label("Overlay is set to multiplicative mode", smallLabelStyle);
+                else GUILayout.Label("Overlay is set to additive mode", smallLabelStyle);
+
+                for(int i = 160; i <= 163; i++) DrawProperty(i);
+                for(int i = 170; i <= 171; i++) DrawProperty(i);
+            }
+            EditorGUILayout.EndVertical();
+        }
+        else targetMat.DisableKeyword(keyword);
+
+        EditorGUILayout.EndToggleGroup();
+    }
+
+    private void DrawProperty(int index, bool noReset = false)
+    {
+        MaterialProperty targetProperty = matProperties[index];
+
+        EditorGUILayout.BeginHorizontal();
+        {
+            GUIContent propertyLabel = new GUIContent();
+            propertyLabel.text = targetProperty.displayName;
+            propertyLabel.tooltip = targetProperty.name + " (C#)";
+
+            matEditor.ShaderProperty(targetProperty, propertyLabel);
+
+            if(!noReset)
+            {
+                GUIContent resetButtonLabel = new GUIContent();
+                resetButtonLabel.text = "R";
+                resetButtonLabel.tooltip = "Resets to default value";
+                if(GUILayout.Button(resetButtonLabel, GUILayout.Width(20))) ResetProperty(targetProperty);
+            }
+        }
+        EditorGUILayout.EndHorizontal();
+    }
+
+    private void ResetProperty(MaterialProperty targetProperty)
+    {
+        if(originalMaterialCopy == null) originalMaterialCopy = new Material(targetMat.shader);
+        if(targetProperty.type == MaterialProperty.PropType.Float || targetProperty.type == MaterialProperty.PropType.Range)
+        {
+            targetProperty.floatValue = originalMaterialCopy.GetFloat(targetProperty.name);
+        }
+        else if(targetProperty.type == MaterialProperty.PropType.Vector)
+        {
+            targetProperty.vectorValue = originalMaterialCopy.GetVector(targetProperty.name);
+        }
+        else if(targetProperty.type == MaterialProperty.PropType.Color)
+        {
+            targetProperty.colorValue = originalMaterialCopy.GetColor(targetProperty.name);
+        }
+        else if(targetProperty.type == MaterialProperty.PropType.Texture)
+        {
+            targetProperty.textureValue = originalMaterialCopy.GetTexture(targetProperty.name);
+        }
+    }
+
+    private bool DrawEffectSubKeywordToggle(string inspector, string keyword, bool setCustomConfigAfter = false)
+    {
+        GUIContent propertyLabel = new GUIContent();
+        propertyLabel.text = inspector;
+        propertyLabel.tooltip = keyword + " (C#)";
+
+        bool ini = oldKeyWords.Contains(keyword);
+        bool toggle = ini;
+        toggle = GUILayout.Toggle(toggle, propertyLabel);
+        if(ini != toggle)
+        {
+            if(toggle) targetMat.EnableKeyword(keyword);
+            else targetMat.DisableKeyword(keyword);
+        }
+
+        return toggle;
+    }
+
+    private void Save()
+    {
+        if(!Application.isPlaying) EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
+        EditorUtility.SetDirty(targetMat);
+    }
+
+    private void DrawLine(Color color, int thickness = 2, int padding = 10)
+    {
+        Rect r = EditorGUILayout.GetControlRect(GUILayout.Height(padding + thickness));
+        r.height = thickness;
+        r.y += (padding / 2);
+        r.x -= 2;
+        r.width += 6;
+        EditorGUI.DrawRect(r, color);
+    }
+}
+#endif

Assets/Plugins/AllIn1SpriteShader/Scripts/Editor/AllIn1SpriteShaderUiMask2MaterialInspector.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2634386595cc60d40ae4e46b9ae970c0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/AllIn1SpriteShader/Shaders/AllIn1SpriteShaderUiMask2.shader.meta

@@ -0,0 +1,22 @@
+fileFormatVersion: 2
+guid: e320962886da01749b5c68627fde4db9
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures:
+  - _MainTex: {instanceID: 0}
+  - _GlowTex: {instanceID: 0}
+  - _FadeTex: {fileID: 2800000, guid: 7aad8c583ef292e48b06af0d1f2fab97, type: 3}
+  - _FadeBurnTex: {fileID: 2800000, guid: 677cca399782dea41aedc1d292ecb67d, type: 3}
+  - _OutlineTex: {fileID: 2800000, guid: 74087f6d03f233e4a8a142fa01f9e5cf, type: 3}
+  - _OutlineDistortTex: {fileID: 2800000, guid: 7aad8c583ef292e48b06af0d1f2fab97,
+      type: 3}
+  - _ColorSwapTex: {instanceID: 0}
+  - _ColorRampTex: {fileID: 2800000, guid: 279657edc397ece4b8029c727adf6ddc, type: 3}
+  - _DistortTex: {fileID: 2800000, guid: 7aad8c583ef292e48b06af0d1f2fab97, type: 3}
+  - _ShineMask: {instanceID: 0}
+  - _ColorRampTexGradient: {instanceID: 0}
+  - _OverlayTex: {fileID: 2800000, guid: 677cca399782dea41aedc1d292ecb67d, type: 3}
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Animate UI Materials.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 625ba2096e714466b6d44ccb456bd731
+timeCreated: 1682058264

Assets/Plugins/Animate UI Materials/Assembly-AnimateUIMaterials.asmdef

@@ -0,0 +1,3 @@
+{
+	"name": "Assembly-GraphicMaterialOverride"
+}

Assets/Plugins/Animate UI Materials/Assembly-AnimateUIMaterials.asmdef.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 0e6c16ac130388f4493d7bf4eff725f1
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/Assembly-AnimateUIMaterials.asmdef
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/BufferedMaterialModifier.cs

@@ -0,0 +1,131 @@
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Plugins.Animate_UI_Materials
+{
+  /// <summary>
+  /// Implements IMaterialModifier while avoiding the creation of too many garbage materials
+  /// WARNING: will destroy the modified material if the source material changes shader or on its own destruction
+  /// </summary>
+  public abstract class BufferedMaterialModifier : MonoBehaviour, IMaterialModifier
+  {
+    private static readonly int Stencil = Shader.PropertyToID("_Stencil");
+
+    /// <summary>
+    /// Hold the last modified material, to be re-used if possible
+    /// </summary>
+    Material _bufferedMaterial;
+
+    /// <summary>
+    /// Holds the base material used to create _bufferedMaterial
+    /// </summary>
+    Material _bufferedMaterialSource;
+
+    /// <summary>
+    /// From IMaterialModifier
+    /// Receives a material to be modified before display, and returns a new material
+    /// Only called once per frame per Graphic if changed, as Graphic is well optimized
+    /// </summary>
+    /// <param name="baseMaterial"></param>
+    /// <returns>A new material object, or the reset previous return value if possible</returns>
+    public Material GetModifiedMaterial(Material baseMaterial)
+    {
+      // Return the base material if invalid or if this component is disabled
+      if (!enabled || baseMaterial == null) return baseMaterial;
+
+      if (!_bufferedMaterial || _bufferedMaterial.shader != baseMaterial.shader || baseMaterial != _bufferedMaterialSource)
+      {
+        DestroyBuffer();
+
+        // Create a child material of the original
+        _bufferedMaterial = CreateNewMaterial(baseMaterial, "OVERRIDE");
+        _bufferedMaterialSource = baseMaterial;
+      }
+
+      _bufferedMaterial.CopyPropertiesFromMaterial(baseMaterial);
+      ModifyMaterial(_bufferedMaterial);
+      return _bufferedMaterial;
+    }
+
+    private int? GetStencilId(Material baseMaterial)
+    {
+      if (baseMaterial == null) return null;
+
+      // Check if material has stencil prop to avoid warning
+      if (!baseMaterial.HasInt(Stencil)) return null;
+      int id = baseMaterial.GetInt(Stencil);
+      return id > 0 ? id : null;
+    }
+
+    /// <summary>
+    /// Create a new material variant of the base material.
+    /// Tries to set parent value from the source material for prettier editing.
+    /// Sets flags to avoid saving the material in assets.
+    /// Used for creating new buffered material or for the fake editor screen.
+    /// </summary>
+    /// <param name="baseMaterial">IMaterialModifier argument</param>
+    /// <param name="suffix">Suffix to append to the original material name</param>
+    /// <returns></returns>
+    private Material CreateNewMaterial(Material baseMaterial, string suffix)
+    {
+      Material realSource;
+      // Try to retrieve real base Material
+      if (TryGetComponent(out Graphic graphic))
+      {
+        realSource = graphic.material ? graphic.material : Canvas.GetDefaultCanvasMaterial();
+      }
+      else
+      {
+        Debug.LogWarning("No graphic found");
+        realSource = baseMaterial;
+      }
+
+      // Add mask info to the Material
+      if (GetStencilId(baseMaterial) is {} stencilId)
+      {
+        suffix = $"{suffix} MASKED {stencilId}";
+      }
+
+      Material modifiedMaterial = new (baseMaterial.shader)
+      {
+        // Set a new name, to warn about editor modifications
+        name = $"{realSource.name} {suffix}",
+        hideFlags = HideFlags.DontSaveInBuild | HideFlags.DontSaveInEditor,
+      };
+      // Set parent if supported
+#if UNITY_2022_1_OR_NEWER && UNITY_EDITOR
+      modifiedMaterial.parent = realSource;
+#endif
+      return modifiedMaterial;
+    }
+
+    void DestroyBuffer()
+    {
+      if (Application.isPlaying) Destroy(_bufferedMaterial);
+      else DestroyImmediate(_bufferedMaterial);
+    }
+
+    /// <summary>
+    /// Child class implement this class, modifying directly the buffered material
+    /// </summary>
+    /// <param name="modifiedMaterial"></param>
+    protected abstract void ModifyMaterial(Material modifiedMaterial);
+
+    /// <summary>
+    /// Destroy the buffered material
+    /// </summary>
+    void OnDestroy()
+    {
+      DestroyBuffer();
+    }
+
+    public Material GetEditorMaterial(Material baseMaterial)
+    {
+      // Create a child material of the original
+      Material modifiedMaterial = CreateNewMaterial(baseMaterial, "EDITOR");
+      modifiedMaterial.CopyPropertiesFromMaterial(baseMaterial);
+      ModifyMaterial(modifiedMaterial);
+      return modifiedMaterial;
+    }
+  }
+}

Assets/Plugins/Animate UI Materials/BufferedMaterialModifier.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 32c21f564129429aa7afa1c3fbb90d85
+timeCreated: 1699906395
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/BufferedMaterialModifier.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/Docs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 94c69a3c49225fd4e8fc7eb449623d14
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Animate UI Materials/Docs/Animate UI Materials - Readme.pdf.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 91b66ac0a1f9e5f48a4a1ffaefef1a01
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/Docs/Animate UI Materials - Readme.pdf
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/Editor.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6f6208cdf31d456cbbfb65574612dae0
+timeCreated: 1681720611

Assets/Plugins/Animate UI Materials/Editor/Assembly-AnimateUIMaterials-Editor.asmdef

@@ -0,0 +1,18 @@
+{
+  "name": "Assembly-AnimateGraphicMaterials-Editor",
+  "rootNamespace": "",
+  "references": [
+    "GUID:0e6c16ac130388f4493d7bf4eff725f1"
+  ],
+  "includePlatforms": [
+    "Editor"
+  ],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": false,
+  "precompiledReferences": [],
+  "autoReferenced": true,
+  "defineConstraints": [],
+  "versionDefines": [],
+  "noEngineReferences": false
+}

Assets/Plugins/Animate UI Materials/Editor/Assembly-AnimateUIMaterials-Editor.asmdef.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 4cc83c889fcb65645bc6aae95a9ff24e
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/Editor/Assembly-AnimateUIMaterials-Editor.asmdef
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/Editor/CustomMaterialEditor.cs

@@ -0,0 +1,34 @@
+namespace UnityEditor
+{
+ /// <summary>
+ /// Broken implementation of MaterialEditor meant to be injected in a standard Editor
+ /// Hacky, but only way to get custom shader editors to work with this packages
+ /// </summary>
+  public class CustomMaterialEditor: MaterialEditor
+  {
+    public override void OnInspectorGUI()
+    {
+      // Commented lines are those removed from the base implementation
+      serializedObject.Update();
+      // Remove most checks
+      // this.CheckSetup();
+      // this.DetectShaderEditorNeedsUpdate();
+      // this.isVisible && (UnityEngine.Object) this.m_Shader != (UnityEngine.Object) null && !this.HasMultipleMixedShaderValues() && this.
+      // Draw properties
+      if (PropertiesGUI())
+      {
+        // Do not validate materials since we don't have access to their editor scripts
+        // foreach (Material target in this.targets)
+        // {
+        //   if (this.m_CustomShaderGUI != null)
+        //     this.m_CustomShaderGUI.ValidateMaterial(target);
+        // }
+        //
+        PropertiesChanged();
+      }
+      // this.DetectTextureStackValidationIssues();
+    }
+
+
+  }
+}

Assets/Plugins/Animate UI Materials/Editor/CustomMaterialEditor.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 39cd41d8ca92456dbb37f87b7de14c4e
+timeCreated: 1701269432
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/Editor/CustomMaterialEditor.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/Editor/GraphicMaterialOverrideEditor.cs

@@ -0,0 +1,644 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using Plugins.Animate_UI_Materials.EditorExtensions;
+using UnityEditor;
+using UnityEditorInternal;
+using UnityEngine;
+using UnityEngine.UI;
+using Object = UnityEngine.Object;
+
+namespace Plugins.Animate_UI_Materials.Editor
+{
+  using PropertyType = ShaderUtil.ShaderPropertyType;
+
+  [CustomEditor(typeof(GraphicMaterialOverride), true)]
+  public class GraphicMaterialOverrideEditor : UnityEditor.Editor
+  {
+    /// <summary>
+    ///   The scroll position in the modifiers ScrollView
+    ///   Usually not needed, but good to have
+    /// </summary>
+    Vector2 _scrollPosition;
+
+    /// <summary>
+    /// A fake material used to create an inspector
+    /// </summary>
+    Material _editorMaterial;
+
+    Object[] _editorMaterialArray;
+
+    /// <summary>
+    /// The editor of the fake material
+    /// </summary>
+    MaterialEditor _editorMaterialEditor;
+
+    /// <summary>
+    ///   Override the reset context menu to implement the reset function
+    ///   Needed instead of "MonoBehavior.Reset" on GraphicMaterialOverride because we need to record an Undo
+    /// </summary>
+    [MenuItem("CONTEXT/GraphicMaterialOverride/Reset")]
+    static void ResetMaterialModifiers(MenuCommand b)
+    {
+      GraphicMaterialOverride materialOverride = (GraphicMaterialOverride)b.context;
+      if (!materialOverride) return;
+
+      List<IMaterialPropertyModifier> modifiers = materialOverride.GetModifiers().ToList();
+
+      Object[] modifiersAsObjects = modifiers.Select(m => (Object)m).ToArray();
+      Undo.RecordObjects(modifiersAsObjects, "Reset material modifiers");
+
+      foreach (IMaterialPropertyModifier modifier in modifiers)
+      {
+        modifier.ResetPropertyToDefault();
+        PrefabUtility.RecordPrefabInstancePropertyModifications((Object)modifier);
+      }
+    }
+
+    /// <summary>
+    /// Ask the Graphic component to reload the modified material
+    /// </summary>
+    [MenuItem("CONTEXT/GraphicMaterialOverride/Reload Source Material")]
+    static void ReloadSourceMaterial(MenuCommand b)
+    {
+      if (b.context is not GraphicMaterialOverride materialOverride) return;
+      materialOverride.SetMaterialDirty();
+      EditorUtility.SetDirty(materialOverride);
+    }
+
+    [MenuItem("CONTEXT/MonoBehaviour/Bake Material Variant", true)]
+    static bool BakeMaterialVariantValidator(MenuCommand b)
+    {
+      return b.context is IMaterialModifier;
+    }
+
+    /// <summary>
+    /// Ask the Graphic component to reload the modified material
+    /// </summary>
+    [MenuItem("CONTEXT/MonoBehaviour/Bake Material Variant")]
+    static void BakeMaterialVariant(MenuCommand b)
+    {
+      if (b.context is not IMaterialModifier) return;
+      if (b.context is not Component materialModifier) return;
+
+      if (materialModifier.TryGetComponent(out Graphic materialSource) == false)
+      {
+        Debug.LogWarning("Cannot find associated Graphic");
+        return;
+      }
+
+      Material original = materialSource.material;
+      Material modified = materialSource.materialForRendering;
+
+      Material asset = new(modified);
+
+  #if UNITY_2022_1_OR_NEWER && UNITY_EDITOR
+        asset.parent = original;
+  #endif
+      asset.hideFlags = HideFlags.None;
+
+      string path = GetMaterialVariantPath(original);
+
+      AssetDatabase.CreateAsset(asset, path);
+      EditorGUIUtility.PingObject(AssetDatabase.LoadAssetAtPath<Material>(path));
+    }
+
+    static string GetMaterialVariantPath(Material original)
+    {
+      string path = null;
+      string name = original ? original.name : "Material";
+
+  #if UNITY_2022_1_OR_NEWER && UNITY_EDITOR
+        {
+
+          Material current = original;
+          while (path == null && current)
+          {
+            path = AssetDatabase.GetAssetPath(current);
+            current = current.parent;
+          }
+        }
+  #else
+      if (original != null) path = AssetDatabase.GetAssetPath(original);
+  #endif
+      path = Path.GetDirectoryName(path);
+      path ??= Application.dataPath;
+
+      path += $"/{name} Override.asset";
+
+      return AssetDatabase.GenerateUniqueAssetPath(path);
+    }
+
+    public override void OnInspectorGUI()
+    {
+      DrawDefaultInspector();
+
+      // Get the materialOverride component
+      GraphicMaterialOverride materialOverride = (GraphicMaterialOverride)target;
+
+      if (materialOverride.GetComponent<Graphic>() == null)
+        EditorGUILayout.HelpBox(
+          "Cannot find any sibling UI element. Add a UI element to use this component",
+          MessageType.Warning);
+      else if (GetTargetMaterial() == null)
+        EditorGUILayout.HelpBox(
+          "Cannot find any material. Add a material to the UI element to use this component",
+          MessageType.Warning);
+
+      Material baseMaterial = GetTargetMaterial();
+      if (baseMaterial == null) return;
+
+      if (!_editorMaterial)
+      {
+        _editorMaterial = materialOverride.GetEditorMaterial(GetTargetMaterial());
+        _editorMaterialArray = new Object[] { _editorMaterial };
+      }
+
+      InternalEditorUtility.SetIsInspectorExpanded(_editorMaterial, true);
+
+      if (!_editorMaterialEditor || _editorMaterialEditor.target != _editorMaterial)
+        _editorMaterialEditor = CreateEditor(_editorMaterial) as MaterialEditor;
+
+      var properties = ShaderPropertyInfo.GetMaterialProperties(baseMaterial);
+      var names = properties.Select(p => p.name).ToList();
+
+      // Get the active modifiers
+      List<IMaterialPropertyModifier> modifiers = materialOverride
+                                                 .GetModifiers(true)
+                                                 .OrderBy(m => names.IndexOf(m.PropertyName))
+                                                 .ToList();
+
+      // Display the current modifier values
+      DisplayModifiers(modifiers);
+      // Use a popup to create new modifiers
+
+      if (DisplayCreationPopup(modifiers, properties) is { } toCreate)
+        CreateNewModifier(materialOverride.transform, toCreate);
+    }
+
+    /// <summary>
+    ///   Display all added modifiers and their value
+    /// </summary>
+    /// <param name="modifiers"></param>
+    void DisplayModifiers(List<IMaterialPropertyModifier> modifiers)
+    {
+      EditorGUILayout.LabelField("Modifiers");
+
+      if (modifiers.Count == 0)
+        EditorGUILayout.HelpBox("Select a value from the dropdown to add a property modifier", MessageType.Info);
+
+      using GUILayout.ScrollViewScope scrollViewScope = new(_scrollPosition);
+      using GUILayout.HorizontalScope horizontalScope = new();
+
+      ForEachParameterVertical(modifiers, DrawModifier);
+    }
+
+    /// <summary>
+    /// Returns the heights of each modifiers as a list
+    /// </summary>
+    /// <param name="modifiers"> The modifiers to get the heights of</param>
+    /// <returns></returns>
+    List<float> GetModifiersHeights(List<IMaterialPropertyModifier> modifiers)
+    {
+      Object[] targetMat = _editorMaterialArray;
+
+      return modifiers.Select(m => m.PropertyName)
+                      .Select(n => MaterialEditor.GetMaterialProperty(targetMat, n))
+                      .Select(_editorMaterialEditor.GetPropertyHeight)
+                      .ToList();
+    }
+
+    /// <summary>
+    ///   Begin a vertical group, and call a draw function on each modifier
+    /// </summary>
+    /// <param name="modifiers">The modifiers to draw</param>
+    /// <param name="action">The draw function for a modifier property</param>
+    static void ForEachParameterVertical(
+      List<IMaterialPropertyModifier>   modifiers,
+      Action<IMaterialPropertyModifier> action
+    )
+    {
+      using EditorGUILayout.VerticalScope scope = new();
+      foreach (IMaterialPropertyModifier modifier in modifiers)
+      {
+        using GUILayout.HorizontalScope hScope = new();
+        action(modifier);
+      }
+    }
+
+    void DrawModifier(IMaterialPropertyModifier modifier)
+    {
+      DrawModifierToggle(modifier);
+      DrawModifierKebabMenu(modifier);
+      DrawModifierValue(modifier);
+    }
+
+    // The cached style of the kebab menu button
+    GUIStyle _kebabMenuStyle;
+
+    /// <summary>
+    ///   Draw a button that activate the context menu
+    /// </summary>
+    /// <param name="modifier"></param>
+    void DrawModifierKebabMenu(IMaterialPropertyModifier modifier)
+    {
+      if (_kebabMenuStyle == null)
+      {
+        _kebabMenuStyle = new GUIStyle(GUI.skin.GetStyle("PaneOptions"));
+        // Force the height of the button
+        _kebabMenuStyle.fixedHeight = EditorGUIUtility.singleLineHeight;
+        _kebabMenuStyle.margin = new RectOffset(0, 0, 3, 0);
+      }
+
+      if (GUILayout.Button("", _kebabMenuStyle)) DrawModifierContextMenu(modifier);
+    }
+
+    /// <summary>
+    ///   Draw a toggle to enable or disable the target modifier component
+    /// </summary>
+    /// <param name="modifier">The modifier component</param>
+    void DrawModifierToggle(IMaterialPropertyModifier modifier)
+    {
+      GameObject targetObject = modifier.gameObject;
+      SerializedObject targetSO = new(targetObject);
+      SerializedProperty activeProp = targetSO.FindProperty("m_IsActive");
+      EditorGUI.ChangeCheckScope scope = new();
+      EditorGUILayout.PropertyField(activeProp, GUIContent.none, false, GUILayout.MaxWidth(16f));
+      if (scope.changed) targetSO.ApplyModifiedProperties();
+    }
+
+    /// <summary>
+    ///   Draw the value field from the property modifier
+    /// </summary>
+    /// <param name="modifier">The target IMaterialPropertyModifier</param>
+    protected virtual void DrawModifierValue(IMaterialPropertyModifier modifier)
+    {
+      MonoBehaviour modifierComponent = (MonoBehaviour)modifier;
+      // Add change checks to the property field
+      EditorGUI.BeginChangeCheck();
+      // Create a serialized object on the modifier, to display it properly
+      SerializedObject obj = new(modifierComponent);
+      // Get the serialized property
+      SerializedProperty property = obj.FindProperty("propertyValue");
+
+      try
+      {
+        EditorGUIUtility.fieldWidth = 64f;
+        DrawMaterialProperty(modifier, property);
+        EditorGUIUtility.fieldWidth = -1;
+      }
+      catch (ExitGUIException e)
+      {
+        throw;
+      }
+      // e is used for debugging purposes
+#pragma warning disable CS0168 // Variable is declared but never used
+      catch (Exception e)
+#pragma warning restore CS0168 // Variable is declared but never used
+      {
+        // Put breakpoint here
+        EditorGUIUtility.fieldWidth = -1;
+        DrawFallbackProperty(modifier, property);
+      }
+
+      // If no change was applied, ignore storage
+      if (!EditorGUI.EndChangeCheck()) return;
+      // Set the serialized property from the current prop
+      // Record an undo
+      Undo.RecordObject(modifierComponent, $"Modified property override {modifier.PropertyName}");
+      // If we are in a prefab, ensure unity knows about the modification
+      PrefabUtility.RecordPrefabInstancePropertyModifications(modifierComponent);
+      // Apply the modified property
+      obj.ApplyModifiedProperties();
+    }
+
+    void DrawFallbackProperty(IMaterialPropertyModifier modifier, SerializedProperty property)
+    {
+      GUI.backgroundColor = new Color(1, 0.5f, 0);
+      EditorGUILayout.PropertyField(property, new GUIContent(modifier.PropertyName));
+      GUI.backgroundColor = Color.white;
+    }
+
+    FieldInfo _materialPropertyFlagsField =
+      typeof(MaterialProperty).GetField("m_Flags", BindingFlags.NonPublic | BindingFlags.Instance);
+
+    void DrawMaterialProperty(
+      IMaterialPropertyModifier modifier,
+      SerializedProperty        property
+    )
+    {
+      // Get the actual Shader Property
+      MaterialProperty materialProperty = MaterialEditor.GetMaterialProperty(_editorMaterialArray, modifier.PropertyName);
+
+      MaterialProperty.PropFlags oldFlags = materialProperty.flags;
+      MaterialProperty.PropFlags flags = oldFlags;
+
+      // Hide the scale offset in the texture property drawer
+      if (modifier is GraphicPropertyOverrideTexture or GraphicPropertyOverrideScaleAndOffset)
+      {
+        bool wantsScaleOffset = modifier is GraphicPropertyOverrideScaleAndOffset;
+
+        flags &= ~MaterialProperty.PropFlags.NoScaleOffset;
+
+        if (!wantsScaleOffset)
+          flags |= MaterialProperty.PropFlags.NoScaleOffset;
+      }
+
+      flags &= ~MaterialProperty.PropFlags.PerRendererData;
+
+      if (oldFlags != flags)
+      {
+        _materialPropertyFlagsField.SetValue(materialProperty, (int)flags);
+      }
+
+      // Asset correct property type
+      SerializedMaterialPropertyUtility.AssertTypeEqual(property, materialProperty);
+      // Set the buffer shader property to our current value
+      SerializedMaterialPropertyUtility.CopyProperty(materialProperty, property);
+      // Get the height needed to render
+      float height = _editorMaterialEditor.GetPropertyHeight(materialProperty);
+
+      // Get the control rect
+      Rect rect = EditorGUILayout.GetControlRect(true, height);
+      using EditorGUI.PropertyScope scope = new(rect, new GUIContent(modifier.DisplayName), property);
+
+      // Set the animator colored backgrounds
+      if (GraphicMaterialOverrideHelper.OverridePropertyColor(materialProperty, (Object)modifier, out Color background))
+      {
+        GUI.backgroundColor = background;
+      }
+
+      using EditorGUI.ChangeCheckScope changes = new();
+      // Draw the property using the hidden editor
+      _editorMaterialEditor.ShaderProperty(rect, materialProperty, scope.content, 0);
+
+      // Reset the background color
+      GUI.backgroundColor = Color.white;
+
+      if (changes.changed)
+      {
+        // Place the result in the SerializedProperty
+        SerializedMaterialPropertyUtility.CopyProperty(property, materialProperty);
+      }
+    }
+
+    /// <summary>
+    ///   Draw the context menu for one modifier
+    /// </summary>
+    /// <param name="modifier"></param>
+    void DrawModifierContextMenu(IMaterialPropertyModifier modifier)
+    {
+      MonoBehaviour modifierComponent = (MonoBehaviour)modifier;
+      GenericMenu menu = new();
+      menu.AddItem(new GUIContent("Select"),      false, () => Selection.activeGameObject = modifierComponent.gameObject);
+      menu.AddItem(new GUIContent("Set Default"), false, () => ResetModifier(modifier));
+      if (modifierComponent.isActiveAndEnabled)
+        menu.AddItem(new GUIContent("Disable"), false, () => ModifierSetActive(modifier, false));
+      else
+        menu.AddItem(new GUIContent("Enable"), false, () => ModifierSetActive(modifier, true));
+
+      menu.AddItem(new GUIContent("Delete"), false, () => DeleteModifier(modifier));
+      menu.ShowAsContext();
+    }
+
+    /// <summary>
+    /// Reset a modifier object to the default material value and record an undo
+    /// </summary>
+    /// <param name="modifier"></param>
+    void ResetModifier(IMaterialPropertyModifier modifier)
+    {
+      Undo.RecordObject(modifier as Object, "Reset modifier component");
+
+      modifier.ResetPropertyToDefault();
+
+      PrefabUtility.RecordPrefabInstancePropertyModifications(modifier as Object);
+    }
+
+    /// <summary>
+    /// Delete the GameObject of a modifier and record an Undo
+    /// </summary>
+    /// <param name="modifier"></param>
+    void DeleteModifier(IMaterialPropertyModifier modifier)
+    {
+      Undo.DestroyObjectImmediate(modifier.gameObject);
+    }
+
+    /// <summary>
+    /// Set the active state of a modifier and its GameObject
+    /// Records an undo
+    /// </summary>
+    /// <param name="modifier"></param>
+    /// <param name="isActive"></param>
+    void ModifierSetActive(IMaterialPropertyModifier modifier, bool isActive)
+    {
+      // Make sure any modifications are properly propagated to unity
+      Undo.RecordObjects(
+        new[] { modifier as Object, modifier.gameObject },
+        "Toggled modifier component");
+      // If enabling, set the component and GameObject as active
+      if (isActive)
+      {
+        modifier.enabled = true;
+        modifier.gameObject.SetActive(true);
+      }
+      // If disabling, disable the GameObject only
+      else
+      {
+        modifier.gameObject.SetActive(false);
+      }
+
+      PrefabUtility.RecordPrefabInstancePropertyModifications(modifier as Object);
+      PrefabUtility.RecordPrefabInstancePropertyModifications(modifier.gameObject);
+    }
+
+    /// <summary>
+    ///   Try to draw a range field for a shader property
+    ///   If the information cannot be found, draw a float property
+    /// </summary>
+    /// <param name="material">The material holding the shader property</param>
+    /// <param name="propertyIndex">The index of the shader property</param>
+    /// <param name="property">The serialized property in the modifier</param>
+    /// <param name="label">The label of the property</param>
+    public static void DrawFloatPropertyAsRange(
+      Material           material,
+      int                propertyIndex,
+      SerializedProperty property,
+      GUIContent         label
+    )
+    {
+      if (!material || propertyIndex < 0)
+      {
+        EditorGUILayout.PropertyField(property);
+        return;
+      }
+
+      Rect rect = GUILayoutUtility.GetRect(
+        EditorGUIUtility.fieldWidth,
+        EditorGUIUtility.labelWidth + EditorGUIUtility.fieldWidth + 110f,
+        18f,
+        18f);
+
+      Shader shader = material.shader;
+      float min = ShaderUtil.GetRangeLimits(shader, propertyIndex, 1);
+      float max = ShaderUtil.GetRangeLimits(shader, propertyIndex, 2);
+
+      using EditorGUI.PropertyScope scope = new(rect, label, property);
+      EditorGUI.BeginChangeCheck();
+      float newValue = EditorGUI.Slider(rect, "⇔", property.floatValue, min, max);
+      // Only assign the value back if it was actually changed by the user.
+      // Otherwise a single value will be assigned to all objects when multi-object editing,
+      // even when the user didn't touch the control.
+      if (EditorGUI.EndChangeCheck())
+        property.floatValue = newValue;
+    }
+
+    /// <summary>
+    ///   Draw a color field for a shader property, hdr if required
+    ///   If the information cannot be found, draw a color property
+    /// </summary>
+    /// <param name="material">The material holding the shader property</param>
+    /// <param name="property">The serialized property in the modifier</param>
+    /// <param name="isHdr">If the property should be drawn as HDR</param>
+    /// <param name="label">The label of the property</param>
+    public static void DrawColorPropertyAsHdr(
+      Material           material,
+      SerializedProperty property,
+      bool               isHdr,
+      GUIContent         label
+    )
+    {
+      if (!material)
+      {
+        EditorGUILayout.PropertyField(property);
+        return;
+      }
+
+      property.colorValue = EditorGUILayout.ColorField(label, property.colorValue, true, true, isHdr);
+    }
+
+    static readonly (string, string)[] LowerPropertyStrings =
+    {
+      ("_StencilComp", "UI Hidden Properties/StencilComp"),
+      ("_Stencil", "UI Hidden Properties/Stencil"),
+      ("_StencilOp", "UI Hidden Properties/StencilOp"),
+      ("_StencilWriteMask", "UI Hidden Properties/StencilWriteMask"),
+      ("_StencilReadMask", "UI Hidden Properties/StencilReadMask"),
+      ("_ColorMask", "UI Hidden Properties/ColorMask"),
+      ("_UseUIAlphaClip", "UI Hidden Properties/UseUIAlphaClip"),
+    };
+
+    static string GetPropertyName(ShaderPropertyInfo prop)
+    {
+      foreach (var (lower, upper) in LowerPropertyStrings)
+      {
+        if (prop.name == lower) return upper;
+      }
+
+      return prop.name;
+    }
+
+    struct PropertyEntry
+    {
+      public string Name;
+      public string DisplayName;
+      public Type ComponentType;
+    }
+
+    /// <summary>
+    ///   Display a dropdown to select a modifier
+    ///   Filters out modifiers that are already added
+    /// </summary>
+    /// <returns></returns>
+    PropertyEntry? DisplayCreationPopup(List<IMaterialPropertyModifier> modifiers, List<ShaderPropertyInfo> properties)
+    {
+      // Create a set to filter out modifiers that are already added
+      HashSet<string> namesAlreadyUsed = modifiers
+                                        .Select(p => p.DisplayName)
+                                        .ToHashSet();
+
+      List<PropertyEntry> entries = new();
+
+      foreach (ShaderPropertyInfo info in properties)
+      {
+        if (!namesAlreadyUsed.Contains(info.name))
+        {
+          entries.Add(
+            new PropertyEntry
+            {
+              Name = info.name,
+              DisplayName = GetPropertyName(info),
+              ComponentType = info.type switch
+              {
+                PropertyType.Color  => typeof(GraphicPropertyOverrideColor),
+                PropertyType.Float  => typeof(GraphicPropertyOverrideFloat),
+                PropertyType.Range  => typeof(GraphicPropertyOverrideRange),
+                PropertyType.Vector => typeof(GraphicPropertyOverrideVector),
+                PropertyType.TexEnv => typeof(GraphicPropertyOverrideTexture),
+                _                   => throw new ArgumentOutOfRangeException(),
+              },
+            });
+        }
+
+        if (info.type == PropertyType.TexEnv)
+        {
+          string displayName = GetPropertyName(info) + " Scale Offset";
+          if (!namesAlreadyUsed.Contains(displayName))
+          {
+            entries.Add(
+              new PropertyEntry
+              {
+                Name = info.name,
+                DisplayName = displayName,
+                ComponentType = typeof(GraphicPropertyOverrideScaleAndOffset),
+              });
+          }
+        }
+      }
+
+      string[] propertyNames = entries.Select(e => e.DisplayName).ToArray();
+
+      int selectedIndex = EditorGUILayout.Popup(new GUIContent("Add Override"), -1, propertyNames);
+
+      if (selectedIndex >= 0) return entries[selectedIndex];
+      return null;
+    }
+
+    /// <summary>
+    ///   Create a new GraphicPropertyOverride in a new child GameObject
+    /// </summary>
+    /// <param name="parent">The transform of the GraphicMaterialOverride</param>
+    /// <param name="propertyInfo">The property to override</param>
+    /// <exception cref="ArgumentOutOfRangeException">thrown when ShaderPropertyType is invalid</exception>
+    void CreateNewModifier(Transform parent, PropertyEntry propertyInfo)
+    {
+      // Increment undo group
+      Undo.IncrementCurrentGroup();
+      GameObject child = new($"{propertyInfo.DisplayName} Override");
+
+      Undo.RegisterCreatedObjectUndo(child, $"Added override GameObject");
+      child.layer = parent.gameObject.layer;
+      Undo.SetTransformParent(child.transform, parent, false, "Moved override GameObject");
+
+      GraphicPropertyOverride propertyOverride =
+        Undo.AddComponent(child, propertyInfo.ComponentType) as GraphicPropertyOverride;
+      propertyOverride!.PropertyName = propertyInfo.Name;
+      propertyOverride.ResetPropertyToDefault();
+
+      Undo.RegisterCompleteObjectUndo(child, "Added override component");
+      Undo.SetCurrentGroupName($"Override ${propertyInfo.DisplayName}");
+    }
+
+    /// <summary>
+    ///   Try to get the material from the Graphic component
+    /// </summary>
+    /// <returns></returns>
+    Material GetTargetMaterial()
+    {
+      GraphicMaterialOverride graphicMaterialOverride = (GraphicMaterialOverride)target;
+
+      return graphicMaterialOverride.TryGetComponent(out Graphic graphic) ? graphic.material : null;
+    }
+  }
+}

Assets/Plugins/Animate UI Materials/Editor/GraphicMaterialOverrideEditor.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 2ea82f5a694c494db5eb813e0232cd6d
+timeCreated: 1682064216
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/Editor/GraphicMaterialOverrideEditor.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/Editor/GraphicPropertyOverrideColorEditor.cs

@@ -0,0 +1,33 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Plugins.Animate_UI_Materials.Editor
+{
+  using PropertyType = ShaderUtil.ShaderPropertyType;
+
+  /// <summary>
+  /// A special editor for Color properties
+  /// Retrieves the hdr flag from the property override
+  /// </summary>
+  [CustomEditor(typeof(GraphicPropertyOverrideColor), true)]
+  public class GraphicPropertyOverrideColorEditor : GraphicPropertyOverrideEditor
+  {
+    protected override void DrawValueProperty(SerializedProperty property)
+    {
+      // If in multi-edit mode, just display a color field
+      if (targets.Length > 1 || target is not GraphicPropertyOverrideColor propertyOverride)
+      {
+        base.DrawValueProperty(property);
+        return;
+      }
+
+      Material material = GetTargetMaterial();
+
+      GraphicMaterialOverrideEditor.DrawColorPropertyAsHdr(
+        material,
+        property,
+        propertyOverride.isHDR,
+        new GUIContent(""));
+    }
+  }
+}

Assets/Plugins/Animate UI Materials/Editor/GraphicPropertyOverrideColorEditor.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: ccb1a192bc074b67b10eca77f5af23d7
+timeCreated: 1686516497
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/Editor/GraphicPropertyOverrideColorEditor.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/Editor/GraphicPropertyOverrideEditor.cs

@@ -0,0 +1,164 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Plugins.Animate_UI_Materials.Editor
+{
+  using PropertyType = ShaderUtil.ShaderPropertyType;
+
+  [CustomEditor(typeof(GraphicPropertyOverride), true)]
+  [CanEditMultipleObjects]
+  public class GraphicPropertyOverrideEditor : UnityEditor.Editor
+  {
+    SerializedProperty _propertyName;
+    SerializedProperty _propertyValue;
+
+    void OnEnable()
+    {
+      // Get the serializedProperty of the shader property name
+      _propertyName = serializedObject.FindProperty("propertyName");
+      // Get the serializedProperty of the shader property propertyValue
+      _propertyValue = serializedObject.FindProperty("propertyValue");
+    }
+
+    public override void OnInspectorGUI()
+    {
+      serializedObject.Update();
+
+      // Draw the script header
+      using (new EditorGUI.DisabledScope(true))
+        EditorGUILayout.PropertyField(serializedObject.FindProperty("m_Script"));
+
+      // Start change check
+      using EditorGUI.ChangeCheckScope scope = new();
+
+      // If single target (not multi-editing)
+      if (targets.Length == 1)
+      {
+        // Draw a warning if the material cannot be found
+        if (!GetTargetMaterial())
+          EditorGUILayout.HelpBox(
+            "The parent doesn't contain a GraphicMaterialOverride. Add one to continue",
+            MessageType.Error);
+
+        string[] properties = GetPropertyNames().ToArray();
+        // Draw a dropdown list of float properties in the material
+        EditorGUI.BeginChangeCheck();
+
+        int currentIndex = GetPropertyIndexDropdown();
+        int index = EditorGUILayout.Popup("Property Name", currentIndex, properties);
+        if (EditorGUI.EndChangeCheck()) _propertyName.stringValue = properties[index];
+      }
+      else
+      {
+        EditorGUILayout.LabelField("Cannot multi-edit property name");
+      }
+      
+      DrawPropertiesExcluding(serializedObject, "m_Script", "propertyName", "propertyValue");
+      
+      DrawValueProperty(_propertyValue);
+
+      // If change happened, apply modified properties
+      if (scope.changed) serializedObject.ApplyModifiedProperties();
+    }
+
+    /// <summary>
+    /// Overridable method to draw the value property
+    /// Overriden by GraphicPropertyOverrideRange to display ranges
+    /// </summary>
+    protected virtual void DrawValueProperty(SerializedProperty property)
+    {
+      EditorGUILayout.PropertyField(property);
+    }
+
+    /// <summary>
+    /// Try to get the material of the associated Graphic object
+    /// </summary>
+    /// <returns>The material being overriden or null</returns>
+    protected Material GetTargetMaterial()
+    {
+      GraphicPropertyOverride animated = (GraphicPropertyOverride)target;
+
+      return animated.transform.parent.TryGetComponent(out Graphic graphic) ? graphic.material : null;
+    }
+
+    /// <summary>
+    /// Get the property type from the target object
+    /// </summary>
+    /// <returns></returns>
+    protected PropertyType GetPropertyType()
+    {
+      GraphicPropertyOverride animated = (GraphicPropertyOverride)target;
+
+      return animated switch
+      {
+        GraphicPropertyOverrideColor          => PropertyType.Color,
+        GraphicPropertyOverrideFloat          => PropertyType.Float,
+        GraphicPropertyOverrideVector         => PropertyType.Vector,
+        GraphicPropertyOverrideInt            => PropertyType.Int,
+        GraphicPropertyOverrideRange          => PropertyType.Range,
+        GraphicPropertyOverrideTexture        => PropertyType.TexEnv,
+        GraphicPropertyOverrideScaleAndOffset => PropertyType.TexEnv,
+        _ when target != null                 => throw new Exception($"Unknown type {target.GetType()}"),
+        _                                     => throw new Exception($"Target is null"),
+      };
+    }
+
+    /// <summary>
+    /// Get the index inside the filtered dropdown
+    /// </summary>
+    /// <returns>The index, or -1 in case of invalid property</returns>
+    int GetPropertyIndexDropdown()
+    {
+      string propertyName = _propertyName.stringValue;
+      return GetPropertyNames()
+        .FindIndex(dropdownOptionName => dropdownOptionName == propertyName);
+    }
+
+    /// <summary>
+    /// Get the index of the property in the shade
+    /// </summary>
+    /// <returns>The index of the property or -1 in vase of invalid property</returns>
+    protected int GetPropertyIndex()
+    {
+      Material material = GetTargetMaterial();
+      string propertyName = _propertyName.stringValue;
+      return ShaderPropertyInfo.GetMaterialProperties(material)
+                               .Find(p => p.name == propertyName)
+                               ?.index ??
+             -1;
+    }
+
+    /// <summary>
+    /// Get all matching properties from the shader
+    /// </summary>
+    /// <returns></returns>
+    List<string> GetPropertyNames()
+    {
+      Material material = GetTargetMaterial();
+      PropertyType type = GetPropertyType();
+
+      return ShaderPropertyInfo.GetMaterialProperties(material)
+                               .Where(p => p.type == type)
+                               .Select(p => p.name)
+                               .ToList();
+    }
+    
+    /// <summary>
+    ///   Override the reset context menu to implement the reset function
+    ///   Needed instead of "MonoBehavior.Reset" on GraphicMaterialOverride because Reset is called in other contexts
+    /// </summary>
+    [MenuItem("CONTEXT/GraphicPropertyOverride/Reset")]
+    static void ResetPropertyValue(MenuCommand b)
+    {
+      if (b.context is not GraphicPropertyOverride propertyOverride) return;
+
+      Undo.RecordObject(propertyOverride, "Reset material override");
+      propertyOverride.ResetPropertyToDefault(); 
+      PrefabUtility.RecordPrefabInstancePropertyModifications(propertyOverride);
+    }
+  }
+}

Assets/Plugins/Animate UI Materials/Editor/GraphicPropertyOverrideEditor.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: a8d03d3fad4347d09e530cd5a4590835
+timeCreated: 1681915604
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/Editor/GraphicPropertyOverrideEditor.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/Editor/GraphicPropertyOverrideRangeEditor.cs

@@ -0,0 +1,34 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Plugins.Animate_UI_Materials.Editor
+{
+  using PropertyType = ShaderUtil.ShaderPropertyType;
+
+  /// <summary>
+  /// A special editor for Range properties
+  /// Retrieves the range min and max from the shader, and draws the slider field
+  /// In case of failure to retrieve, it will simply display a float property
+  /// </summary>
+  [CustomEditor(typeof(GraphicPropertyOverrideRange), true)]
+  public class GraphicPropertyOverrideRangeEditor : GraphicPropertyOverrideEditor
+  {
+    protected override void DrawValueProperty(SerializedProperty property)
+    {
+      // If in multi-edit mode, just display a float field
+      if (targets.Length > 1)
+      {
+        base.DrawValueProperty(property);
+        return;
+      }
+
+      Material material = GetTargetMaterial();
+      int propertyIndex = GetPropertyIndex();
+
+      GraphicMaterialOverrideEditor.DrawFloatPropertyAsRange(material,
+        propertyIndex,
+        property,
+        new GUIContent(""));
+    }
+  }
+}

Assets/Plugins/Animate UI Materials/Editor/GraphicPropertyOverrideRangeEditor.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: c999cb1c916847bd8cc931d65f1b195f
+timeCreated: 1682061875
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/Editor/GraphicPropertyOverrideRangeEditor.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/Editor/SerializedMaterialPropertyUtility.cs

@@ -0,0 +1,93 @@
+using System;
+using UnityEditor;
+using UnityEngine;
+
+namespace Plugins.Animate_UI_Materials.Editor
+{
+  public static class SerializedMaterialPropertyUtility
+  {
+    public static void AssertTypeEqual(SerializedProperty a, MaterialProperty b)
+    {
+      AssertTypeEqual(b, a);
+    }
+
+    public static void AssertTypeEqual(MaterialProperty a, SerializedProperty b)
+    {
+      switch (a.type)
+      {
+        case MaterialProperty.PropType.Color when b.propertyType == SerializedPropertyType.Color: return;
+        case MaterialProperty.PropType.Float when b.propertyType == SerializedPropertyType.Float: return;
+        case MaterialProperty.PropType.Vector when b.propertyType == SerializedPropertyType.Vector4: return;
+        case MaterialProperty.PropType.Range when b.propertyType == SerializedPropertyType.Float: return;
+        case MaterialProperty.PropType.Int when b.propertyType == SerializedPropertyType.Integer: return;
+        case MaterialProperty.PropType.Texture when b.propertyType == SerializedPropertyType.ObjectReference: return;
+        case MaterialProperty.PropType.Texture when b.propertyType == SerializedPropertyType.Generic: return;
+        default: throw new Exception("Wrong Material Override Type");
+      }
+    }
+
+    public static void CopyProperty(SerializedProperty to, MaterialProperty from)
+    {
+      switch (from.type)
+      {
+        case MaterialProperty.PropType.Color:
+          to.colorValue = from.colorValue;
+          return;
+        case MaterialProperty.PropType.Float:
+          to.floatValue = from.floatValue;
+          return;
+        case MaterialProperty.PropType.Vector:
+          to.vector4Value = from.vectorValue;
+          return;
+        case MaterialProperty.PropType.Range:
+          to.floatValue = from.floatValue;
+          return;
+        case MaterialProperty.PropType.Int:
+          to.intValue = from.intValue;
+          return;
+        case MaterialProperty.PropType.Texture when to.propertyType == SerializedPropertyType.Generic:
+          to.FindPropertyRelative(nameof(TextureScaleOffset.ScaleOffset)).vector4Value = from.textureScaleAndOffset;
+          to.FindPropertyRelative(nameof(TextureScaleOffset.Texture)).objectReferenceValue = from.textureValue;
+          return;
+        case MaterialProperty.PropType.Texture when to.propertyType == SerializedPropertyType.ObjectReference:
+          to.objectReferenceValue = from.textureValue;
+          return;
+        default:
+          Debug.LogWarning($"WEIRD TYPES {to.type} {from.type}");
+          return;
+      }
+    }
+
+    public static void CopyProperty(MaterialProperty to, SerializedProperty from)
+    {
+      switch (to.type)
+      {
+        case MaterialProperty.PropType.Color:
+          to.colorValue = from.colorValue;
+          return;
+        case MaterialProperty.PropType.Float:
+          to.floatValue = from.floatValue;
+          return;
+        case MaterialProperty.PropType.Vector:
+          to.vectorValue = from.vector4Value;
+          return;
+        case MaterialProperty.PropType.Range:
+          to.floatValue = from.floatValue;
+          return;
+        case MaterialProperty.PropType.Int:
+          to.intValue = from.intValue;
+          return;
+        case MaterialProperty.PropType.Texture when from.propertyType == SerializedPropertyType.Generic:
+          to.textureScaleAndOffset = from.FindPropertyRelative(nameof(TextureScaleOffset.ScaleOffset)).vector4Value;
+          to.textureValue = from.FindPropertyRelative(nameof(TextureScaleOffset.Texture)).objectReferenceValue as Texture;
+          return;
+        case MaterialProperty.PropType.Texture when from.propertyType == SerializedPropertyType.ObjectReference:
+          to.textureValue = from.objectReferenceValue as Texture;
+          return;
+        default:
+          Debug.LogWarning("WEIRD TYPES");
+          return;
+      }
+    }
+  }
+}

Assets/Plugins/Animate UI Materials/Editor/SerializedMaterialPropertyUtility.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: c3a2b7d21ca74321a9fdd6f784784901
+timeCreated: 1701444411
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/Editor/SerializedMaterialPropertyUtility.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/Editor/ShaderPropertyInfo.cs

@@ -0,0 +1,60 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace Plugins.Animate_UI_Materials.Editor
+{
+  using PropertyType = ShaderUtil.ShaderPropertyType;
+
+  internal class ShaderPropertyInfo
+  {
+    /// <summary>
+    /// The index of the property inside the shader
+    /// </summary>
+    public int index;
+    /// <summary>
+    /// The name of the property inside the shader
+    /// </summary>
+    public string name;
+    /// <summary>
+    /// The type of the property, as defined by ShaderUtil
+    /// </summary>
+    public PropertyType type;
+
+    /// <summary>
+    ///   Get all properties from a shader, with their name, index, and type
+    /// </summary>
+    /// <param name="shader">The shader to get the properties from</param>
+    /// <param name="allowHidden">Include properties marked as hidden and _MainTex</param>
+    /// <returns></returns>
+    public static List<ShaderPropertyInfo> GetShaderProperties(Shader shader, bool allowHidden = false)
+    {
+      List<ShaderPropertyInfo> properties = new List<ShaderPropertyInfo>();
+      int propertyCount = ShaderUtil.GetPropertyCount(shader);
+
+      for (int i = 0; i < propertyCount; i++)
+        if (!ShaderUtil.IsShaderPropertyHidden(shader, i) || !allowHidden)
+          if (!ShaderUtil.IsShaderPropertyNonModifiableTexureProperty(shader, i) || allowHidden)
+            properties.Add(new ShaderPropertyInfo
+            {
+              index = i,
+              name = ShaderUtil.GetPropertyName(shader, i),
+              type = ShaderUtil.GetPropertyType(shader, i)
+            });
+
+      return properties;
+    }
+
+    /// <summary>
+    ///   Get all properties from a material, with their name, index, and type
+    /// </summary>
+    /// <param name="material">The material to get the properties from</param>
+    /// <param name="allowHidden">Include properties marked as hidden and _MainTex</param>
+    /// <returns></returns>
+    public static List<ShaderPropertyInfo> GetMaterialProperties(Material material, bool allowHidden = false)
+    {
+      if (!material) return new List<ShaderPropertyInfo>();
+      return GetShaderProperties(material.shader, allowHidden);
+    }
+  }
+}

Assets/Plugins/Animate UI Materials/Editor/ShaderPropertyInfo.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 36a87bf77f35458e8da8b3037e3b2321
+timeCreated: 1682088408
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/Editor/ShaderPropertyInfo.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/EditorExtensions.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d7ba558eff1e4d3189ce4b8dc9cd46cf
+timeCreated: 1701272938

Assets/Plugins/Animate UI Materials/EditorExtensions/AssemblyRef-EditorExtensions.asmref

@@ -0,0 +1,3 @@
+{
+    "reference": "GUID:343deaaf83e0cee4ca978e7df0b80d21"
+}

Assets/Plugins/Animate UI Materials/EditorExtensions/AssemblyRef-EditorExtensions.asmref.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 3426bd6b92ad21241be6117321949a82
+AssemblyDefinitionReferenceImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/EditorExtensions/AssemblyRef-EditorExtensions.asmref
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/EditorExtensions/GraphicMaterialOverrideHelper.cs

@@ -0,0 +1,79 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using Object = UnityEngine.Object;
+
+namespace Plugins.Animate_UI_Materials.EditorExtensions
+{
+  public static class GraphicMaterialOverrideHelper
+  {
+    public static bool OverridePropertyColor(
+      MaterialProperty materialProp,
+      Object           target,
+      out Color        color)
+    {
+      List<string> stringList = new();
+      string str = "propertyValue";
+      if (materialProp.type == MaterialProperty.PropType.Texture)
+      {
+        stringList.Add(str);
+        stringList.Add(str + "_ST.x");
+        stringList.Add(str + "_ST.y");
+        stringList.Add(str + "_ST.z");
+        stringList.Add(str + "_ST.w");
+      }
+      else if (materialProp.type == MaterialProperty.PropType.Color)
+      {
+        stringList.Add(str + ".r");
+        stringList.Add(str + ".g");
+        stringList.Add(str + ".b");
+        stringList.Add(str + ".a");
+      }
+      else if (materialProp.type == MaterialProperty.PropType.Vector)
+      {
+        stringList.Add(str + ".x");
+        stringList.Add(str + ".y");
+        stringList.Add(str + ".z");
+        stringList.Add(str + ".w");
+      }
+      else
+      {
+        stringList.Add(str);
+      }
+
+      bool found = false;
+      foreach (string propName in stringList)
+      {
+        if (AnimationMode.IsPropertyAnimated(target, propName))
+        {
+          found = true;
+          break;
+        }
+      }
+
+      if (!found)
+      {
+        color = Color.white;
+        return false;
+      }
+
+      if (AnimationMode.InAnimationRecording())
+      {
+        color = AnimationMode.recordedPropertyColor;
+        return true;
+      }
+
+      foreach (string propName in stringList)
+      {
+        if (AnimationMode.IsPropertyCandidate(target, propName))
+        {
+          color = AnimationMode.candidatePropertyColor;
+          return true;
+        }
+      }
+
+      color = AnimationMode.animatedPropertyColor;
+      return true;
+    }
+  }
+}

Assets/Plugins/Animate UI Materials/EditorExtensions/GraphicMaterialOverrideHelper.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: fe7b10245245441ba4ac6ff89dd23ab3
+timeCreated: 1701273095
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/EditorExtensions/GraphicMaterialOverrideHelper.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/Examples.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: bc85c94df8771d44788e610e60a1958f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Animate UI Materials/Examples/Example Animation.anim.meta

@@ -0,0 +1,15 @@
+fileFormatVersion: 2
+guid: 196814563dea2d7469ff1de55d0d3815
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 7400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/Examples/Example Animation.anim
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/Examples/Example Scene.unity.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 404da49678522824d82c5911593942ce
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/Examples/Example Scene.unity
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/Examples/ExampleUIShader.shader

@@ -0,0 +1,144 @@
+// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
+// Modified with rights for use in demonstration by Lou Garczynski
+
+Shader "Animate UI Material/Example"
+{
+    Properties
+    {
+        [PerRendererData] _MainTex ("Sprite Texture", 2D) = "white" {}
+        _Color ("Tint", Color) = (1,1,1,1)
+
+        _OverlayTex ("Overlay", 2D) = "white" {}
+        [HDR]_OverlayColor ("Overlay Color", Color) = (1, 1, 1, 1)
+        _Scale ("Scale", Range(0, 2)) = 1
+        _Rotation ("Rotation", Range(0, 360)) = 0
+        _Offset ("Offset", Vector) = (0, 0, 0, 0)
+
+        _StencilComp ("Stencil Comparison", Float) = 8
+        _Stencil ("Stencil ID", Float) = 0
+        _StencilOp ("Stencil Operation", Float) = 0
+        _StencilWriteMask ("Stencil Write Mask", Float) = 255
+        _StencilReadMask ("Stencil Read Mask", Float) = 255
+
+        _ColorMask ("Color Mask", Float) = 15
+
+        [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
+    }
+
+    SubShader
+    {
+        Tags
+        {
+            "Queue"="Transparent"
+            "IgnoreProjector"="True"
+            "RenderType"="Transparent"
+            "PreviewType"="Plane"
+            "CanUseSpriteAtlas"="True"
+        }
+
+        Stencil
+        {
+            Ref [_Stencil]
+            Comp [_StencilComp]
+            Pass [_StencilOp]
+            ReadMask [_StencilReadMask]
+            WriteMask [_StencilWriteMask]
+        }
+
+        Cull Off
+        Lighting Off
+        ZWrite Off
+        ZTest [unity_GUIZTestMode]
+        Blend SrcAlpha OneMinusSrcAlpha
+        ColorMask [_ColorMask]
+
+        Pass
+        {
+            Name "Default"
+        CGPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #pragma target 2.0
+
+            #include "UnityCG.cginc"
+            #include "UnityUI.cginc"
+
+            #pragma multi_compile_local _ UNITY_UI_CLIP_RECT
+            #pragma multi_compile_local _ UNITY_UI_ALPHACLIP
+
+            struct appdata_t
+            {
+                float4 vertex   : POSITION;
+                float4 color    : COLOR;
+                float2 texcoord : TEXCOORD0;
+                UNITY_VERTEX_INPUT_INSTANCE_ID
+            };
+
+            struct v2f
+            {
+                float4 vertex   : SV_POSITION;
+                fixed4 color    : COLOR;
+                float2 texcoord  : TEXCOORD0;
+                float4 worldPosition : TEXCOORD1;
+                UNITY_VERTEX_OUTPUT_STEREO
+            };
+
+            sampler2D _MainTex;
+            fixed4 _Color;
+            fixed4 _TextureSampleAdd;
+            float4 _ClipRect;
+            float4 _MainTex_ST;
+ 
+            sampler2D _OverlayTex;
+            float4 _OverlayColor;
+            float _Scale;
+            float _Rotation;
+            float2 _Offset;
+
+            v2f vert(appdata_t v)
+            {
+                v2f OUT;
+                UNITY_SETUP_INSTANCE_ID(v);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(OUT);
+                OUT.worldPosition = v.vertex;
+                OUT.vertex = UnityObjectToClipPos(OUT.worldPosition);
+
+                OUT.texcoord = TRANSFORM_TEX(v.texcoord, _MainTex);
+
+                OUT.color = v.color * _Color;
+                return OUT;
+            }
+
+            fixed4 frag(v2f IN) : SV_Target
+            {
+                half4 color = (tex2D(_MainTex, IN.texcoord) + _TextureSampleAdd) * IN.color;
+
+                // Calculate the overlay texture coordinates and sample it
+                float2 centeredUV = (IN.texcoord - 0.5)*2;
+                float2 overlayUV = centeredUV * _Scale;
+                float rad = _Rotation / 360 * 2 * UNITY_PI;
+                float2 rotatedUV = float2(
+                    overlayUV.x * cos(rad) - overlayUV.y * sin(rad),
+                    overlayUV.x * sin(rad) + overlayUV.y * cos(rad)
+                );
+                float2 normalizedUV = rotatedUV / 2 + 0.5;
+                float2 offsetUV = normalizedUV + float2(_Offset.x, _Offset.y);
+                fixed4 overlay = tex2D(_OverlayTex, offsetUV) * _OverlayColor;
+ 
+                // Blend the background and overlay textures
+                color = lerp(color, overlay, overlay.a);
+
+                #ifdef UNITY_UI_CLIP_RECT
+                color.a *= UnityGet2DClipping(IN.worldPosition.xy, _ClipRect);
+                #endif
+
+                #ifdef UNITY_UI_ALPHACLIP
+                clip (color.a - 0.001);
+                #endif
+
+                return color;
+            }
+        ENDCG
+        }
+    }
+}

Assets/Plugins/Animate UI Materials/Examples/ExampleUIShader.shader.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: d8010de858794e33a27636c6183ce4d2
+timeCreated: 1682164300
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/Examples/ExampleUIShader.shader
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/Examples/Image.controller

@@ -0,0 +1,72 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1102 &-7894766971529659986
+AnimatorState:
+  serializedVersion: 6
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: New Animation
+  m_Speed: 1
+  m_CycleOffset: 0
+  m_Transitions: []
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 7400000, guid: 196814563dea2d7469ff1de55d0d3815, type: 2}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!91 &9100000
+AnimatorController:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Image
+  serializedVersion: 5
+  m_AnimatorParameters: []
+  m_AnimatorLayers:
+  - serializedVersion: 5
+    m_Name: Base Layer
+    m_StateMachine: {fileID: 5797805570552003858}
+    m_Mask: {fileID: 0}
+    m_Motions: []
+    m_Behaviours: []
+    m_BlendingMode: 0
+    m_SyncedLayerIndex: -1
+    m_DefaultWeight: 0
+    m_IKPass: 0
+    m_SyncedLayerAffectsTiming: 0
+    m_Controller: {fileID: 9100000}
+--- !u!1107 &5797805570552003858
+AnimatorStateMachine:
+  serializedVersion: 6
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Base Layer
+  m_ChildStates:
+  - serializedVersion: 1
+    m_State: {fileID: -7894766971529659986}
+    m_Position: {x: 260, y: 120, z: 0}
+  m_ChildStateMachines: []
+  m_AnyStateTransitions: []
+  m_EntryTransitions: []
+  m_StateMachineTransitions: {}
+  m_StateMachineBehaviours: []
+  m_AnyStatePosition: {x: 50, y: 20, z: 0}
+  m_EntryPosition: {x: 50, y: 120, z: 0}
+  m_ExitPosition: {x: 800, y: 120, z: 0}
+  m_ParentStateMachinePosition: {x: 800, y: 20, z: 0}
+  m_DefaultState: {fileID: -7894766971529659986}

Assets/Plugins/Animate UI Materials/Examples/Image.controller.meta

@@ -0,0 +1,15 @@
+fileFormatVersion: 2
+guid: ba1af5f887a74c44190010c05f6748ee
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 9100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/Examples/Image.controller
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/Examples/Texture 1.png.meta

@@ -0,0 +1,131 @@
+fileFormatVersion: 2
+guid: 212f10d282ba58242b61e8ad04af89d1
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/Examples/Texture 1.png
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/Examples/Texture 2.png.meta

@@ -0,0 +1,131 @@
+fileFormatVersion: 2
+guid: f5588e963e393074a943ed2b8a86fb1a
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 12
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 0
+    aniso: 1
+    mipBias: 0
+    wrapU: 0
+    wrapV: 0
+    wrapW: 0
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Server
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/Examples/Texture 2.png
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/Examples/UI Overlay.mat

@@ -0,0 +1,50 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: UI Overlay
+  m_Shader: {fileID: 4800000, guid: d8010de858794e33a27636c6183ce4d2, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords: []
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OverlayTex:
+        m_Texture: {fileID: 2800000, guid: 212f10d282ba58242b61e8ad04af89d1, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _ColorMask: 15
+    - _OffsetX: 0
+    - _OffsetY: 0
+    - _Rotation: 0
+    - _Scale: 1
+    - _Stencil: 0
+    - _StencilComp: 8
+    - _StencilOp: 0
+    - _StencilReadMask: 255
+    - _StencilWriteMask: 255
+    - _UseUIAlphaClip: 0
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _OverlayColor: {r: 1, g: 1, b: 1, a: 1}
+  m_BuildTextureStacks: []

Assets/Plugins/Animate UI Materials/Examples/UI Overlay.mat.meta

@@ -0,0 +1,15 @@
+fileFormatVersion: 2
+guid: da1cb4f2f1551d948a65d84276aef03d
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/Examples/UI Overlay.mat
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/GraphicMaterialOverride.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Plugins.Animate_UI_Materials
+{
+  [ExecuteAlways]
+  [AddComponentMenu("UI/Animate UI Material/GraphicMaterialOverride")]
+  public class GraphicMaterialOverride : BufferedMaterialModifier
+  {
+    /// <summary>
+    /// Recreate the modified material using each active IMaterialPropertyModifier on this GameObject or its children
+    /// </summary>
+    public void SetMaterialDirty()
+    {
+      if (TryGetComponent(out Graphic graphic))
+      {
+        graphic.SetMaterialDirty();
+      }
+    }
+
+    /// <summary>
+    /// A buffer list to accelerate GetComponents requests
+    /// </summary>
+    [NonSerialized] List<IMaterialPropertyModifier> _modifiers;
+
+    /// <summary>
+    /// Retrieves all enabled IMaterialPropertyModifiers belonging to direct children
+    /// </summary>
+    /// <returns>An iterator over all enabled modifiers, avoid storing this value</returns>
+    public IEnumerable<IMaterialPropertyModifier> GetModifiers(bool includeInactive = false)
+    {
+      // Ensure the buffer list is available
+      _modifiers ??= new List<IMaterialPropertyModifier>();
+
+      // Load all IPropertyModifiers belonging the direct children of this GameObject
+      foreach (Transform child in transform)
+      {
+        // skip this GameObject if disabled
+        if (!child.gameObject.activeSelf && !includeInactive) continue;
+        // disabled children will be ignored
+        child.GetComponents(_modifiers);
+        // Call the children to apply their modified properties
+        foreach (IMaterialPropertyModifier propertyModifier in _modifiers)
+        {
+          // Check if the modifier is enabled (skip if not)
+          if (propertyModifier.enabled || includeInactive)
+          {
+            yield return propertyModifier;
+          }
+        }
+      }
+
+      // Ensure no ref is kept
+      _modifiers.Clear();
+    }
+
+    // On enable and disable, update the target graphic
+    void OnEnable() => SetMaterialDirty();
+
+    void OnDisable() => SetMaterialDirty();
+
+    /// <summary>
+    /// Called by Graphic using the IMaterialModifier interface through the parent class
+    /// Modifies the buffered material to match all children component specifications
+    /// </summary>
+    /// <param name="modifiedMaterial">A copy of the Graphic base material, buffered for reuse</param>
+    protected override void ModifyMaterial(Material modifiedMaterial)
+    {
+      // Iterate over all active modifiers
+      foreach (IMaterialPropertyModifier modifier in GetModifiers())
+      {
+        // Ignore un-init modifiers
+        if (!string.IsNullOrEmpty(modifier.PropertyName))
+        {
+          // Apply the property to the new material
+          modifier.ApplyModifiedProperty(modifiedMaterial);
+        }
+      }
+    }
+  }
+}

Assets/Plugins/Animate UI Materials/GraphicMaterialOverride.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: ec7c531f67844491ae84a4f3d1575d01
+timeCreated: 1681719063
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/GraphicMaterialOverride.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/GraphicMaterialReplacer.cs

@@ -0,0 +1,56 @@
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Plugins.Animate_UI_Materials
+{
+  /// <summary>
+  /// Simply replaces a Graphic component's material
+  /// Does not create or modify materials
+  /// Useful for debugging, or switching the material of a Graphic that does not offer this option in some context
+  /// </summary>
+  [ExecuteAlways]
+  [AddComponentMenu("UI/Animate UI Material/GraphicMaterialReplacer")]
+  public class GraphicMaterialReplacer : MonoBehaviour, IMaterialModifier
+  {
+    [SerializeField] Material material;
+
+    public Material Material
+    {
+      get => material;
+      set {
+        material = value;
+        SetMaterialDirty();
+      }
+    }
+
+    /// <summary>
+    /// Request Graphic to regenerate materials
+    /// </summary>
+    void SetMaterialDirty()
+    {
+      if (TryGetComponent(out Graphic graphic))
+      {
+        graphic.SetMaterialDirty();
+      }
+    }
+
+    // On enable and disable, update the target graphic
+    void OnEnable() => SetMaterialDirty();
+
+    void OnDisable() => SetMaterialDirty();
+
+    /// <summary>
+    /// From IMaterialModifier
+    /// Receives the current material before display, and returns another material if enabled
+    /// Here, simply sends the "material" field if enabled
+    /// </summary>
+    /// <param name="baseMaterial"></param>
+    /// <returns>A new material object</returns>
+    public Material GetModifiedMaterial(Material baseMaterial)
+    {
+      // Return the base material if invalid or if this component is disabled
+      if (!enabled || baseMaterial == null) return baseMaterial;
+      return material;
+    }
+  }
+}

Assets/Plugins/Animate UI Materials/GraphicMaterialReplacer.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: ca4bb79969f54a608a95cc7bd9d297e7
+timeCreated: 1693523425
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/GraphicMaterialReplacer.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/GraphicPropertyOverride.cs

@@ -0,0 +1,200 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Plugins.Animate_UI_Materials
+{
+  /// <summary>
+  ///   Used in combination with GraphicMaterialOverride to modify and animate shader properties
+  ///   The base class is used for the shared Editor script, and reacting to OnValidate events
+  /// </summary>
+  [ExecuteAlways]
+  public abstract class GraphicPropertyOverride : MonoBehaviour, IMaterialPropertyModifier
+  {
+    /// <summary>
+    /// The name of the shader property, serialized
+    /// </summary>
+    [SerializeField] protected string propertyName;
+
+    public virtual string DisplayName => propertyName;
+
+    /// <summary>
+    /// The id of the shader property
+    /// </summary>
+    /// <remarks> Should not be serialized, as it can change between game runs</remarks>
+    protected int PropertyId;
+
+    // Request a material update whenever the parent changes
+    void OnEnable()
+    {
+      SetMaterialDirty(true);
+    }
+
+    void OnDisable()
+    {
+      SetMaterialDirty();
+    }
+
+#if UNITY_EDITOR // if in the unity editor, include unity editor callbacks
+    /// <summary>
+    /// On editor change, mark as dirty
+    /// </summary>
+    void OnValidate()
+    {
+      SetMaterialDirty(true);
+    }
+#endif
+
+    /// <summary>
+    /// Try to retrieve and apply the default property value
+    /// If the source material cannot be found, reset to sensible defaults
+    /// </summary>
+    public abstract void ResetPropertyToDefault();
+
+    /// <summary>
+    /// Set the material as dirty
+    /// ApplyModifiedProperty will be called by the parent GraphicMaterialProperty
+    /// </summary>
+    /// <param name="renewId">If the GraphicPropertyOverride should try to get the shader property id, just to be safe</param>
+    public void SetMaterialDirty(bool renewId = false)
+    {
+      if (renewId || PropertyId == 0) PropertyId = Shader.PropertyToID(propertyName);
+      GraphicMaterialOverride parent = ParentOverride;
+      if (parent) parent.SetMaterialDirty();
+    }
+
+    /// <summary>
+    /// Try to apply the GraphicPropertyOverride property to the material
+    /// Does not create a copy, only feed material instances to this
+    /// </summary>
+    /// <param name="material">The material to modify</param>
+    public abstract void ApplyModifiedProperty(Material material);
+
+    /// <summary>
+    /// The name of the shader property to override
+    /// Can be invalid if the shader has changed, or if the component was not setup
+    /// </summary>
+    public string PropertyName
+    {
+      get => propertyName;
+      set
+      {
+        propertyName = value;
+        SetMaterialDirty(true);
+      }
+    }
+
+    /// <summary>
+    ///   Try to get the Graphic component on the parent
+    /// </summary>
+    protected Graphic ParentGraphic => transform.parent ? transform.parent.GetComponent<Graphic>() : null;
+
+    /// <summary>
+    ///   Try to get the GraphicMaterialOverride component on the parent
+    /// </summary>
+    protected GraphicMaterialOverride ParentOverride =>
+      transform.parent ? transform.parent.GetComponent<GraphicMaterialOverride>() : null;
+  }
+
+  /// <summary>
+  /// Template extension of GraphicPropertyOverride
+  /// Adds LateUpdate function to react to value changes
+  /// Compares value changes using EqualityComparer
+  /// Adds a SerializedField of type T
+  /// </summary>
+  /// <typeparam name="T"></typeparam>
+  public abstract class GraphicPropertyOverride<T> : GraphicPropertyOverride
+  {
+    /// <summary>
+    /// The serialized value, modified by the inspector or the animator
+    /// </summary>
+    [SerializeField] protected T propertyValue;
+
+    /// <summary>
+    /// The last known value, init the the type default (0, null, ...)
+    /// Used to check for changes
+    /// NonSerialized to prevent unity from serializing this
+    /// </summary>
+    [NonSerialized] T _previousValue;
+
+    /// <summary>
+    ///   If _previousValue was set since last construction
+    /// </summary>
+    [NonSerialized] bool _previousValueIsInit;
+
+    /// <summary>
+    /// Checks if any changes happened just before rendering
+    /// Can be removed to optimize, since OnDidApplyAnimationProperties is doing the heavy lifting
+    /// But OnDidApplyAnimationProperties is undocumented, and will potentially change silently in the future
+    /// </summary>
+    void LateUpdate()
+    {
+      // If a previous value was recorded
+      // And it perfectly matches the current value
+      // Then ignore this update
+      if (_previousValueIsInit && EqualityComparer<T>.Default.Equals(propertyValue, _previousValue)) return;
+
+      _previousValueIsInit = true;
+      _previousValue = propertyValue;
+      SetMaterialDirty();
+    }
+
+    /// <summary>
+    /// Called by the animator system when a value is modified
+    /// </summary>
+    public void OnDidApplyAnimationProperties()
+    {
+      _previousValueIsInit = true;
+      _previousValue = propertyValue;
+      SetMaterialDirty();
+    }
+
+    /// <summary>
+    /// The value of the overriding property
+    /// Will react correctly when changed
+    /// </summary>
+    public T PropertyValue
+    {
+      get => propertyValue;
+      set
+      {
+        _previousValueIsInit = true;
+        _previousValue = propertyValue = value;
+        SetMaterialDirty();
+      }
+    }
+
+    /// <summary>
+    /// Try to retrieve and apply the default property value
+    /// If the source material cannot be found, reset to sensible defaults
+    /// </summary>
+    public override void ResetPropertyToDefault()
+    {
+      // Try to get the associated Graphic component
+      Graphic graphic = ParentGraphic;
+      // If successful, get the material
+      Material material = graphic ? graphic.material : null;
+      // init the reset value to default
+      T value = default;
+      bool gotDefaultValue = false;
+
+      // If material was received, try to get the default value from the material
+      if (material) gotDefaultValue = GetDefaultValue(material, out value);
+
+      // Log a warning if we failed
+      if (!gotDefaultValue) Debug.LogWarning("Could not retrieve material default value", this);
+
+      // Set current value to what we managed to retrieve, and update
+      PropertyValue = value;
+    }
+
+    /// <summary>
+    /// Retrieve the default property value from the source material
+    /// </summary>
+    /// <param name="material">The source material</param>
+    /// <param name="defaultValue">The value from the material</param>
+    /// <returns>True if the value could be retrieved</returns>
+    public abstract bool GetDefaultValue(Material material, out T defaultValue);
+  }
+}

Assets/Plugins/Animate UI Materials/GraphicPropertyOverride.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 41cc1aea6b8342d5a6c8ac437a094f0e
+timeCreated: 1681914388
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/GraphicPropertyOverride.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideColor.cs

@@ -0,0 +1,41 @@
+using UnityEngine;
+
+namespace Plugins.Animate_UI_Materials
+{
+  /// <summary>
+  ///   Used in with GraphicMaterialOverride to modify a material without creating a variant
+  ///   Added to a child of the Graphic element
+  ///   This variant only applies to Color properties
+  /// </summary>
+  [AddComponentMenu("UI/Animate UI Material/GraphicPropertyOverrideColor")]
+  public class GraphicPropertyOverrideColor : GraphicPropertyOverride<Color>
+  {
+#if UNITY_EDITOR
+    /// <summary>
+    /// A flag for the editor to draw the color field as HDR
+    /// </summary>
+    public bool isHDR;
+#endif
+    /// <summary>
+    /// Apply the modified property to the material
+    /// </summary>
+    /// <param name="material"></param>
+    public override void ApplyModifiedProperty(Material material)
+    {
+      material.SetColor(PropertyId, propertyValue);
+    }
+
+    /// <summary>
+    /// Retrieve the default Color value from the source material
+    /// </summary>
+    /// <param name="material">The source material</param>
+    /// <param name="defaultValue">The Color value from the material</param>
+    /// <returns>True if the value could be retrieved</returns>
+    public override bool GetDefaultValue(Material material, out Color defaultValue)
+    {
+      bool hasProperty = material.HasColor(PropertyId);
+      defaultValue = hasProperty ? material.GetColor(PropertyId) : default;
+      return hasProperty;
+    }
+  }
+}

Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideColor.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 0769e07e9d844582aed9c22013f56c3b
+timeCreated: 1681915536
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideColor.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideFloat.cs

@@ -0,0 +1,36 @@
+using UnityEngine;
+
+namespace Plugins.Animate_UI_Materials
+{
+  /// <summary>
+  ///   Used in with GraphicMaterialOverride to modify a material without creating a variant
+  ///   Added to a child of the Graphic element
+  ///   This variant only applies to Float properties
+  /// </summary>
+  [AddComponentMenu("UI/Animate UI Material/GraphicPropertyOverrideFloat")]
+  public class GraphicPropertyOverrideFloat : GraphicPropertyOverride<float>
+  {
+    /// <summary>
+    ///   Apply the modified property to the material
+    /// </summary>
+    /// <param name="material"></param>
+    public override void ApplyModifiedProperty(Material material)
+    {
+      material.SetFloat(PropertyId, propertyValue);
+    }
+
+    /// <summary>
+    /// Retrieve the default float value from the source material
+    /// </summary>
+    /// <param name="material">The source material</param>
+    /// <param name="defaultValue">The float value from the material</param>
+    /// <returns>True if the value could be retrieved</returns>
+    public override bool GetDefaultValue(Material material, out float defaultValue)
+    {
+      bool hasProperty = material.HasFloat(PropertyId);
+      if (hasProperty) defaultValue = material.GetFloat(PropertyId);
+      else defaultValue = default;
+      return hasProperty;
+    }
+  }
+}

Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideFloat.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 389648ab9de94296b8f4a6f6957df101
+timeCreated: 1681915244
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideFloat.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideInt.cs

@@ -0,0 +1,36 @@
+using UnityEngine;
+
+namespace Plugins.Animate_UI_Materials
+{
+  /// <summary>
+  ///   Used in with GraphicMaterialOverride to modify a material without creating a variant
+  ///   Added to a child of the Graphic element
+  ///   This variant only applies to Int properties
+  /// </summary>
+  [AddComponentMenu("UI/Animate UI Material/GraphicPropertyOverrideInt")]
+  public class GraphicPropertyOverrideInt : GraphicPropertyOverride<int>
+  {
+    /// <summary>
+    ///   Apply the modified property to the material
+    /// </summary>
+    /// <param name="material"></param>
+    public override void ApplyModifiedProperty(Material material)
+    {
+      material.SetInteger(PropertyId, propertyValue);
+    }
+
+    /// <summary>
+    /// Retrieve the default int value from the source material
+    /// </summary>
+    /// <param name="material">The source material</param>
+    /// <param name="defaultValue">The int value from the material</param>
+    /// <returns>True if the value could be retrieved</returns>
+    public override bool GetDefaultValue(Material material, out int defaultValue)
+    {
+      bool hasProperty = material.HasInteger(PropertyId);
+      if (hasProperty) defaultValue = material.GetInteger(PropertyId);
+      else defaultValue = default;
+      return hasProperty;
+    }
+  }
+}

Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideInt.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 130e282abc8245dcae85a781438fb2bc
+timeCreated: 1682061527
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideInt.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideRange.cs

@@ -0,0 +1,36 @@
+using UnityEngine;
+
+namespace Plugins.Animate_UI_Materials
+{
+  /// <summary>
+  ///   Used in with GraphicMaterialOverride to modify a material without creating a variant
+  ///   Added to a child of the Graphic element
+  ///   This variant only applies to Range properties
+  /// </summary>
+  [AddComponentMenu("UI/Animate UI Material/GraphicPropertyOverrideRange")]
+  public class GraphicPropertyOverrideRange : GraphicPropertyOverride<float>
+  {
+    /// <summary>
+    ///   Apply the modified property to the material
+    /// </summary>
+    /// <param name="material"></param>
+    public override void ApplyModifiedProperty(Material material)
+    {
+      material.SetFloat(PropertyId, propertyValue);
+    }
+
+    /// <summary>
+    /// Retrieve the default float value from the source material
+    /// </summary>
+    /// <param name="material">The source material</param>
+    /// <param name="defaultValue">The float value from the material</param>
+    /// <returns>True if the value could be retrieved</returns>
+    public override bool GetDefaultValue(Material material, out float defaultValue)
+    {
+      bool hasProperty = material.HasFloat(PropertyId);
+      if (hasProperty) defaultValue = material.GetFloat(PropertyId);
+      else defaultValue = default;
+      return hasProperty;
+    }
+  }
+}

Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideRange.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 035dcf41a5a94b9ba8c514a7714b4fbb
+timeCreated: 1682061553
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideRange.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideScaleAndOffset.cs

@@ -0,0 +1,57 @@
+using UnityEngine;
+
+namespace Plugins.Animate_UI_Materials
+{
+  [System.Serializable]
+  public struct TextureScaleOffset
+  {
+    public Texture Texture;
+    public Vector4 ScaleOffset;
+    public Vector2 Scale => new Vector2(ScaleOffset.x, ScaleOffset.y);
+    public Vector2 Offset => new Vector2(ScaleOffset.z, ScaleOffset.w);
+
+    public TextureScaleOffset(Texture texture, Vector2 scale, Vector2 offset)
+    {
+      Texture = texture;
+      ScaleOffset = new Vector4(scale.x, scale.y, offset.x, offset.y);
+    }
+  }
+
+  /// <summary>
+  ///   Used in with GraphicMaterialOverride to modify a material without creating a variant
+  ///   Added to a child of the Graphic element
+  ///   This variant only applies to Texture properties
+  /// </summary>
+  [AddComponentMenu("UI/Animate UI Material/GraphicPropertyOverrideScaleAndOffset")]
+  public class GraphicPropertyOverrideScaleAndOffset : GraphicPropertyOverride<TextureScaleOffset>
+  {
+    public override string DisplayName => $"{propertyName} Scale Offset";
+
+    /// <summary>
+    ///   Apply the modified property to the material
+    /// </summary>
+    /// <param name="material"></param>
+    public override void ApplyModifiedProperty(Material material)
+    {
+      material.SetTextureOffset(PropertyId, propertyValue.Offset);
+      material.SetTextureScale(PropertyId, propertyValue.Scale);
+      material.SetTexture(PropertyId, propertyValue.Texture);
+    }
+
+    /// <summary>
+    /// Retrieve the default Texture value from the source material
+    /// </summary>
+    /// <param name="material">The source material</param>
+    /// <param name="defaultValue">The Texture value from the material</param>
+    /// <returns>True if the value could be retrieved</returns>
+    public override bool GetDefaultValue(Material material, out TextureScaleOffset defaultValue)
+    {
+      bool hasProperty = material.HasTexture(PropertyId);
+      Vector2 scale = hasProperty ? material.GetTextureOffset(PropertyId) : Vector2.one;
+      Vector2 offset = hasProperty ? material.GetTextureScale(PropertyId) : Vector2.zero;
+      Texture texture = hasProperty ? material.GetTexture(PropertyId) : null;
+      defaultValue = new TextureScaleOffset(texture, scale, offset);
+      return hasProperty;
+    }
+  }
+}

Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideScaleAndOffset.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: c8ebb8aba46242f88d3296cc8d7984c9
+timeCreated: 1701451148
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideScaleAndOffset.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideTexture.cs

@@ -0,0 +1,36 @@
+using UnityEngine;
+
+namespace Plugins.Animate_UI_Materials
+{
+  /// <summary>
+  ///   Used in with GraphicMaterialOverride to modify a material without creating a variant
+  ///   Added to a child of the Graphic element
+  ///   This variant only applies to Texture properties
+  /// </summary>
+  [AddComponentMenu("UI/Animate UI Material/GraphicPropertyOverrideTexture")]
+  public class GraphicPropertyOverrideTexture : GraphicPropertyOverride<Texture>
+  {
+    /// <summary>
+    ///   Apply the modified property to the material
+    /// </summary>
+    /// <param name="material"></param>
+    public override void ApplyModifiedProperty(Material material)
+    {
+      material.SetTexture(PropertyId, propertyValue);
+    }
+
+    /// <summary>
+    /// Retrieve the default Texture value from the source material
+    /// </summary>
+    /// <param name="material">The source material</param>
+    /// <param name="defaultValue">The Texture value from the material</param>
+    /// <returns>True if the value could be retrieved</returns>
+    public override bool GetDefaultValue(Material material, out Texture defaultValue)
+    {
+      bool hasProperty = material.HasTexture(PropertyId);
+      if (hasProperty) defaultValue = material.GetTexture(PropertyId);
+      else defaultValue = default;
+      return hasProperty;
+    }
+  }
+}

Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideTexture.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: e6f24b72ca8a4caabda35db3768eaf4f
+timeCreated: 1682090672
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideTexture.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideVector.cs

@@ -0,0 +1,36 @@
+using UnityEngine;
+
+namespace Plugins.Animate_UI_Materials
+{
+  /// <summary>
+  ///   Used in with GraphicMaterialOverride to modify a material without creating a variant
+  ///   Added to a child of the Graphic element
+  ///   This variant only applies to Vector properties
+  /// </summary>
+  [AddComponentMenu("UI/Animate UI Material/GraphicPropertyOverrideVector")]
+  public class GraphicPropertyOverrideVector : GraphicPropertyOverride<Vector4>
+  {
+    /// <summary>
+    ///   Apply the modified property to the material
+    /// </summary>
+    /// <param name="material"></param>
+    public override void ApplyModifiedProperty(Material material)
+    {
+      material.SetVector(PropertyId, propertyValue);
+    }
+
+    /// <summary>
+    /// Retrieve the default Vector value from the source material
+    /// </summary>
+    /// <param name="material">The source material</param>
+    /// <param name="defaultValue">The Vector value from the material</param>
+    /// <returns>True if the value could be retrieved</returns>
+    public override bool GetDefaultValue(Material material, out Vector4 defaultValue)
+    {
+      bool hasProperty = material.HasVector(PropertyId);
+      if (hasProperty) defaultValue = material.GetVector(PropertyId);
+      else defaultValue = default;
+      return hasProperty;
+    }
+  }
+}

Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideVector.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 7de2cc36a6a241da9a1302efa1f3cf46
+timeCreated: 1682061467
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/GraphicPropertyOverrideVector.cs
+  uploadId: 766200

Assets/Plugins/Animate UI Materials/IMaterialPropertyModifier.cs

@@ -0,0 +1,39 @@
+using UnityEngine;
+
+namespace Plugins.Animate_UI_Materials
+{
+  public interface IMaterialPropertyModifier
+  {
+    /// <summary>
+    ///   The name of the shader property that the modifier affects
+    /// </summary>
+    string PropertyName { get; }
+
+    /// <summary>
+    ///   The display name of the modifier component for the editor
+    /// </summary>
+    string DisplayName { get; }
+
+    /// <summary>
+    ///   The "enabled" value of the modifier component
+    /// </summary>
+    bool enabled { get; set;  }
+
+    /// <summary>
+    ///   The "gameObject" value of the modifier component
+    /// </summary>
+    GameObject gameObject { get; }
+
+    /// <summary>
+    ///   Apply the modified property to the material
+    /// </summary>
+    /// <param name="material"></param>
+    void ApplyModifiedProperty(Material material);
+
+    /// <summary>
+    /// Try to retrieve and apply the default property value
+    /// If the source material cannot be found, reset to sensible defaults
+    /// </summary>
+    void ResetPropertyToDefault();
+  }
+}

Assets/Plugins/Animate UI Materials/IMaterialPropertyModifier.cs.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: f54bd367836249f1a19414bb0a531a5a
+timeCreated: 1682057978
+AssetOrigin:
+  serializedVersion: 1
+  productId: 253197
+  packageName: Animate UI Materials
+  packageVersion: 1.3.0
+  assetPath: Assets/Plugins/Animate UI Materials/IMaterialPropertyModifier.cs
+  uploadId: 766200

Assets/Plugins/Easy Save 3/Resources/ES3/ES3Defaults.asset

@@ -42,6 +42,7 @@ MonoBehaviour:
     - andywiecko.BurstTriangulator
     - Assembly-CSharp
     - Assembly-CSharp-firstpass
+    - Assembly-GraphicMaterialOverride
     - AstarPathfindingProject
     - Autodesk.Fbx
     - Autodesk.Fbx.BuildTestAssets
@@ -65,6 +66,8 @@ MonoBehaviour:
     - spine-unity
     - spine-unity-examples
     - UnitSystem
+    - Unity.RenderPipelines.Core.Samples.Runtime
+    - Unity.UI.Shaders.Sample
     showAdvancedSettings: 0
   addMgrToSceneAutomatically: 0
   autoUpdateReferences: 1

Assets/Samples/Scriptable Render Pipeline Core.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 07f815f72bcf74336b1efd37e3adab4c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Scriptable Render Pipeline Core/Common.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 828e313ddee6e47da92014cc4166dd2c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e19da844068fe904e85ee6d071c5ddbd
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/SamplesFixtureEmissive.mat

@@ -0,0 +1,156 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-462588174902266333
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 639247ca83abc874e893eb93af2b5e44, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 0
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: SamplesFixtureEmissive
+  m_Shader: {fileID: -6465566751694194690, guid: 55dd6397dd059324398dec8c06cb4153, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords:
+  - _DISABLE_SSR_TRANSPARENT
+  m_LightmapFlags: 2
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 2225
+  stringTagMap:
+    MotionVector: User
+  disabledShaderPasses:
+  - TransparentDepthPrepass
+  - TransparentDepthPostpass
+  - TransparentBackface
+  - RayTracingPrepass
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AddPrecomputedVelocity: 0
+    - _AlphaCutoffEnable: 0
+    - _AlphaDstBlend: 0
+    - _AlphaSrcBlend: 1
+    - _BlendMode: 0
+    - _ConservativeDepthOffsetEnable: 0
+    - _CullMode: 2
+    - _CullModeForward: 2
+    - _DepthOffsetEnable: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedGIMode: 0
+    - _DoubleSidedNormalMode: 2
+    - _DstBlend: 0
+    - _DstBlend2: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _Falloff_Distance_End: 1.05
+    - _Falloff_Distance_Start: 0.5
+    - _Falloff_from_UV_center: 1
+    - _Intensity: 250
+    - _MaterialID: 1
+    - _MaterialTypeMask: 2
+    - _Material_Emissive_Multiplier: 0.025
+    - _Multiplier: 0.05
+    - _OpaqueCullMode: 2
+    - _PerPixelSorting: 0
+    - _QueueControl: 1
+    - _QueueOffset: 0
+    - _RayTracing: 0
+    - _ReceivesSSR: 1
+    - _ReceivesSSRTransparent: 0
+    - _RefractionModel: 0
+    - _RenderQueueType: 1
+    - _RequireSplitLighting: 0
+    - _Square: 1
+    - _SrcBlend: 1
+    - _StencilRef: 0
+    - _StencilRefDepth: 8
+    - _StencilRefDistortionVec: 4
+    - _StencilRefGBuffer: 10
+    - _StencilRefMV: 40
+    - _StencilWriteMask: 6
+    - _StencilWriteMaskDepth: 9
+    - _StencilWriteMaskDistortionVec: 4
+    - _StencilWriteMaskGBuffer: 15
+    - _StencilWriteMaskMV: 41
+    - _SupportDecals: 1
+    - _SurfaceType: 0
+    - _TransmissionEnable: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentCullMode: 2
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _TransparentSortPriority: 0
+    - _TransparentWritingMotionVec: 0
+    - _TransparentZWrite: 0
+    - _UseShadowThreshold: 0
+    - _ZTestDepthEqualForOpaque: 3
+    - _ZTestGBuffer: 4
+    - _ZTestTransparent: 4
+    - _ZWrite: 1
+    m_Colors:
+    - _Base_Color: {r: 0.21698102, g: 0.21698102, b: 0.21698102, a: 0}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Emission_Color: {r: 1, g: 1, b: 1, a: 0}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1
+--- !u!114 &4129780837305980848
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9
+--- !u!114 &6988152796153263981
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 13
+  hdPluginSubTargetMaterialVersions:
+    m_Keys: []
+    m_Values: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/SamplesFixtureEmissive.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 73c28ce5f256d4b4abbda3e19a4552d7
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/SamplesRoughBlack.mat

@@ -0,0 +1,334 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-8844631721867378353
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9
+--- !u!114 &-5320171063680880354
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 13
+  hdPluginSubTargetMaterialVersions:
+    m_Keys: []
+    m_Values: 
+--- !u!114 &-3900041929240879694
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 639247ca83abc874e893eb93af2b5e44, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 0
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: SamplesRoughBlack
+  m_Shader: {fileID: -6465566751694194690, guid: 181d9f8961a46b84fa2b2acfc30cdf9c, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords:
+  - _DISABLE_SSR_TRANSPARENT
+  - _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 2225
+  stringTagMap:
+    MotionVector: User
+  disabledShaderPasses:
+  - TransparentDepthPrepass
+  - TransparentDepthPostpass
+  - TransparentBackface
+  - RayTracingPrepass
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoatMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Diffuse:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Mask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Normal:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmissionMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmittanceColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AORemapMax: 1
+    - _AORemapMin: 0
+    - _ATDistance: 1
+    - _AddPrecomputedVelocity: 0
+    - _AlbedoAffectEmissive: 0
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _AlphaCutoffPostpass: 0.5
+    - _AlphaCutoffPrepass: 0.5
+    - _AlphaCutoffShadow: 0.5
+    - _AlphaDstBlend: 0
+    - _AlphaRemapMax: 1
+    - _AlphaRemapMin: 0
+    - _AlphaSrcBlend: 1
+    - _Ambient_Occlusion_R: 1
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _CoatMask: 0
+    - _ConservativeDepthOffsetEnable: 0
+    - _CullMode: 2
+    - _CullModeForward: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DiffusionProfile: 0
+    - _DiffusionProfileHash: 0
+    - _DisplacementLockObjectScale: 1
+    - _DisplacementLockTilingScale: 1
+    - _DisplacementMode: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedGIMode: 0
+    - _DoubleSidedNormalMode: 1
+    - _DstBlend: 0
+    - _DstBlend2: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveExposureWeight: 1
+    - _EmissiveIntensity: 1
+    - _EmissiveIntensityUnit: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _EnableGeometricSpecularAA: 0
+    - _EnergyConservingSpecularColor: 1
+    - _HeightAmplitude: 0.02
+    - _HeightCenter: 0.5
+    - _HeightMapParametrization: 0
+    - _HeightMax: 1
+    - _HeightMin: -1
+    - _HeightOffset: 0
+    - _HeightPoMAmplitude: 2
+    - _HeightTessAmplitude: 2
+    - _HeightTessCenter: 0.5
+    - _InvTilingScale: 1
+    - _Ior: 1.5
+    - _IridescenceMask: 1
+    - _IridescenceThickness: 1
+    - _LinkDetailsWithBase: 1
+    - _MaterialID: 1
+    - _MaterialTypeMask: 2
+    - _Metallic: 0
+    - _MetallicRemapMax: 1
+    - _MetallicRemapMin: 0
+    - _Metallic_B: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _Normal_Strength: 1
+    - _ObjectSpaceUVMapping: 0
+    - _ObjectSpaceUVMappingEmissive: 0
+    - _OpaqueCullMode: 2
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _PPDPrimitiveLength: 1
+    - _PPDPrimitiveWidth: 1
+    - _PerPixelSorting: 0
+    - _QueueControl: -1
+    - _QueueOffset: 0
+    - _RayTracing: 0
+    - _ReceivesSSR: 1
+    - _ReceivesSSRTransparent: 0
+    - _RefractionModel: 0
+    - _RenderQueueType: 1
+    - _RequireSplitLighting: 0
+    - _Smoothness: 0
+    - _SmoothnessRemapMax: 1
+    - _SmoothnessRemapMin: 0
+    - _Smoothness_G: 0
+    - _SpecularAAScreenSpaceVariance: 0.1
+    - _SpecularAAThreshold: 0.2
+    - _SpecularOcclusionMode: 1
+    - _SrcBlend: 1
+    - _StencilRef: 0
+    - _StencilRefDepth: 8
+    - _StencilRefDistortionVec: 4
+    - _StencilRefGBuffer: 10
+    - _StencilRefMV: 40
+    - _StencilWriteMask: 6
+    - _StencilWriteMaskDepth: 9
+    - _StencilWriteMaskDistortionVec: 4
+    - _StencilWriteMaskGBuffer: 15
+    - _StencilWriteMaskMV: 41
+    - _SubsurfaceMask: 1
+    - _SupportDecals: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
+    - _Thickness: 1
+    - _TransmissionEnable: 1
+    - _TransmissionMask: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentCullMode: 2
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _TransparentSortPriority: 0
+    - _TransparentWritingMotionVec: 0
+    - _TransparentZWrite: 0
+    - _Triplanar_Scale: 1
+    - _USE_TRIPLANAR: 0
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVEmissive: 0
+    - _UseEmissiveIntensity: 0
+    - _UseShadowThreshold: 0
+    - _ZTestDepthEqualForOpaque: 3
+    - _ZTestGBuffer: 4
+    - _ZTestTransparent: 4
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 0.127, g: 0.127, b: 0.127, a: 1}
+    - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0}
+    - _Color: {r: 0.12699997, g: 0.12699997, b: 0.12699997, a: 1}
+    - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1}
+    - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0}
+    - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}
+    - _UV_Offset: {r: 0, g: 0, b: 0, a: 0}
+    - _UV_Tiling: {r: 1, g: 1, b: 0, a: 0}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/SamplesRoughBlack.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 519c06b70a5dfe94988ab6fe98d7405a
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/SamplesSpotlightEmissive.mat

@@ -0,0 +1,153 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: SamplesSpotlightEmissive
+  m_Shader: {fileID: -6465566751694194690, guid: 55dd6397dd059324398dec8c06cb4153, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords:
+  - _DISABLE_SSR_TRANSPARENT
+  m_LightmapFlags: 2
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 2225
+  stringTagMap:
+    MotionVector: User
+  disabledShaderPasses:
+  - TransparentDepthPrepass
+  - TransparentDepthPostpass
+  - TransparentBackface
+  - RayTracingPrepass
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AddPrecomputedVelocity: 0
+    - _AlphaCutoffEnable: 0
+    - _AlphaDstBlend: 0
+    - _AlphaSrcBlend: 1
+    - _BlendMode: 0
+    - _ConservativeDepthOffsetEnable: 0
+    - _CullMode: 2
+    - _CullModeForward: 2
+    - _DepthOffsetEnable: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedGIMode: 0
+    - _DoubleSidedNormalMode: 2
+    - _DstBlend: 0
+    - _DstBlend2: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _Falloff_Distance_End: 1
+    - _Falloff_Distance_Start: 0.25
+    - _Falloff_from_UV_center: 1
+    - _Intensity: 10
+    - _MaterialID: 1
+    - _MaterialTypeMask: 2
+    - _OpaqueCullMode: 2
+    - _PerPixelSorting: 0
+    - _QueueControl: 1
+    - _QueueOffset: 0
+    - _RayTracing: 0
+    - _ReceivesSSR: 1
+    - _ReceivesSSRTransparent: 0
+    - _RefractionModel: 0
+    - _RenderQueueType: 1
+    - _RequireSplitLighting: 0
+    - _SrcBlend: 1
+    - _StencilRef: 0
+    - _StencilRefDepth: 8
+    - _StencilRefDistortionVec: 4
+    - _StencilRefGBuffer: 10
+    - _StencilRefMV: 40
+    - _StencilWriteMask: 6
+    - _StencilWriteMaskDepth: 9
+    - _StencilWriteMaskDistortionVec: 4
+    - _StencilWriteMaskGBuffer: 15
+    - _StencilWriteMaskMV: 41
+    - _SupportDecals: 1
+    - _SurfaceType: 0
+    - _TransmissionEnable: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentCullMode: 2
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _TransparentSortPriority: 0
+    - _TransparentWritingMotionVec: 0
+    - _TransparentZWrite: 0
+    - _UseShadowThreshold: 0
+    - _ZTestDepthEqualForOpaque: 3
+    - _ZTestGBuffer: 4
+    - _ZTestTransparent: 4
+    - _ZWrite: 1
+    m_Colors:
+    - _Base_Color: {r: 0.21698102, g: 0.21698102, b: 0.21698102, a: 0}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Emission_Color: {r: 1, g: 1, b: 1, a: 0}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1
+--- !u!114 &341765169038055598
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 639247ca83abc874e893eb93af2b5e44, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 0
+--- !u!114 &4129780837305980848
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9
+--- !u!114 &6988152796153263981
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 13
+  hdPluginSubTargetMaterialVersions:
+    m_Keys: []
+    m_Values: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/SamplesSpotlightEmissive.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 59f9c77da24034145adf7056aaeb4174
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/SamplesTurntable_White.mat

@@ -0,0 +1,165 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-6334813361708750137
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 639247ca83abc874e893eb93af2b5e44, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 0
+--- !u!114 &-4311493914180223959
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: SamplesTurntable_White
+  m_Shader: {fileID: -6465566751694194690, guid: daae7dca060ff1344bf7d7e511e0e961, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords:
+  - _DISABLE_SSR_TRANSPARENT
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 2225
+  stringTagMap:
+    MotionVector: User
+  disabledShaderPasses:
+  - TransparentDepthPrepass
+  - TransparentDepthPostpass
+  - TransparentBackface
+  - RayTracingPrepass
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _SampleTexture2D_a25ebd923630491a8e2c99ae8fd6997b_Texture_1:
+        m_Texture: {fileID: 2800000, guid: 1d8481de16af723418a688958c41224b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SampleTexture2D_a25ebd923630491a8e2c99ae8fd6997b_Texture_1_Texture2D:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AddPrecomputedVelocity: 0
+    - _AlphaCutoffEnable: 0
+    - _AlphaDstBlend: 0
+    - _AlphaSrcBlend: 1
+    - _Anisotropy: 0.5
+    - _BlendMode: 0
+    - _Color_Variation: 2
+    - _ConservativeDepthOffsetEnable: 0
+    - _CullMode: 2
+    - _CullModeForward: 2
+    - _DepthOffsetEnable: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedGIMode: 0
+    - _DoubleSidedNormalMode: 2
+    - _DstBlend: 0
+    - _DstBlend2: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _Logo_Smoothness: 0.25
+    - _MaterialID: 1
+    - _MaterialTypeMask: 4
+    - _Noise_Tiling: 0.62
+    - _OpaqueCullMode: 2
+    - _PerPixelSorting: 0
+    - _QueueControl: -1
+    - _QueueOffset: 0
+    - _RayTracing: 0
+    - _ReceivesSSR: 1
+    - _ReceivesSSRTransparent: 0
+    - _RefractionModel: 0
+    - _RenderQueueType: 1
+    - _RequireSplitLighting: 0
+    - _Smoothness: 0.05
+    - _Smoothness_Variation: 0.1
+    - _SrcBlend: 1
+    - _Steel_Smoothness: 0.375
+    - _StencilRef: 0
+    - _StencilRefDepth: 8
+    - _StencilRefDistortionVec: 4
+    - _StencilRefGBuffer: 10
+    - _StencilRefMV: 40
+    - _StencilWriteMask: 6
+    - _StencilWriteMaskDepth: 9
+    - _StencilWriteMaskDistortionVec: 4
+    - _StencilWriteMaskGBuffer: 15
+    - _StencilWriteMaskMV: 41
+    - _SupportDecals: 1
+    - _SurfaceType: 0
+    - _TransmissionEnable: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentCullMode: 2
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _TransparentSortPriority: 0
+    - _TransparentWritingMotionVec: 0
+    - _TransparentZWrite: 0
+    - _UseShadowThreshold: 0
+    - _ZTestDepthEqualForOpaque: 3
+    - _ZTestGBuffer: 4
+    - _ZTestTransparent: 4
+    - _ZWrite: 1
+    m_Colors:
+    - _Center_Color: {r: 0.16037738, g: 0.16037738, b: 0.16037738, a: 0}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Logo_Color: {r: 0.6886792, g: 0.6886792, b: 0.6886792, a: 1}
+    - _Steel_Color: {r: 0.6941177, g: 0.6941177, b: 0.6941177, a: 1}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1
+--- !u!114 &5654949938188718973
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 13
+  hdPluginSubTargetMaterialVersions:
+    m_Keys: []
+    m_Values: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/SamplesTurntable_White.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1805e702256a0ba4c8f99e94e6a14e35
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/Samples_BackdropFabric.mat

@@ -0,0 +1,376 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-8225026165073191674
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9
+--- !u!114 &-6154481183976877875
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 639247ca83abc874e893eb93af2b5e44, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 0
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Samples_BackdropFabric
+  m_Shader: {fileID: -6465566751694194690, guid: 137a9d0b49032c544abaff345d2c4f5c, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords:
+  - _DISABLE_SSR_TRANSPARENT
+  - _DOUBLESIDED_ON
+  - _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 1
+  m_CustomRenderQueue: 2225
+  stringTagMap:
+    MotionVector: User
+  disabledShaderPasses:
+  - TransparentDepthPrepass
+  - TransparentDepthPostpass
+  - TransparentBackface
+  - RayTracingPrepass
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoatMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FuzzMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SampleTexture2D_78839aa280ca4494bd3327504d2bad10_Texture_1:
+        m_Texture: {fileID: 2800000, guid: 1d8481de16af723418a688958c41224b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SampleTexture2D_902879fdde31447d937665ba0f7b22c1_Texture_1:
+        m_Texture: {fileID: 2800000, guid: 6204d5e5928803d43a2994437a71e2f5, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SampleTexture2D_b53501e4ed5944e5ad663a7f6bdf83cb_Texture_1:
+        m_Texture: {fileID: 2800000, guid: 1d8481de16af723418a688958c41224b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SampleTexture2D_fcb428a0e2674339a94d053242cbb679_Texture_1:
+        m_Texture: {fileID: 2800000, guid: 1d8481de16af723418a688958c41224b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThreadMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmissionMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmittanceColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Triplanar_1b18acb21b804ef3ba3a4056a073deed_Texture_1:
+        m_Texture: {fileID: 2800000, guid: 1d8481de16af723418a688958c41224b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Triplanar_1b18acb21b804ef3ba3a4056a073deed_Texture_1_Texture2D:
+        m_Texture: {fileID: 2800000, guid: 1d8481de16af723418a688958c41224b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Triplanar_4b94b7bfb5c042558eedcdbc26d14943_Texture_1:
+        m_Texture: {fileID: 2800000, guid: 1d8481de16af723418a688958c41224b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AORemapMax: 1
+    - _AORemapMin: 0
+    - _ATDistance: 1
+    - _AddPrecomputedVelocity: 0
+    - _AlbedoAffectEmissive: 0
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _AlphaCutoffPostpass: 0.5
+    - _AlphaCutoffPrepass: 0.5
+    - _AlphaCutoffShadow: 0.5
+    - _AlphaDstBlend: 0
+    - _AlphaRemapMax: 1
+    - _AlphaRemapMin: 0
+    - _AlphaSrcBlend: 1
+    - _Anisotropy: 0.75
+    - _Blend: 1
+    - _BlendMode: 0
+    - _CoatMask: 0
+    - _Color_Variation_Multiplier: 0.75
+    - _ConservativeDepthOffsetEnable: 0
+    - _CullMode: 0
+    - _CullModeForward: 0
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DiffusionProfile: 0
+    - _DiffusionProfileHash: 0
+    - _DisplacementLockObjectScale: 1
+    - _DisplacementLockTilingScale: 1
+    - _DisplacementMode: 0
+    - _DoubleSidedEnable: 1
+    - _DoubleSidedGIMode: 0
+    - _DoubleSidedNormalMode: 1
+    - _DstBlend: 0
+    - _DstBlend2: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveExposureWeight: 1
+    - _EmissiveIntensity: 1
+    - _EmissiveIntensityUnit: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _EnableGeometricSpecularAA: 0
+    - _EnergyConservingSpecularColor: 1
+    - _Float: 1
+    - _FuzzMapUVScale: 0.1
+    - _FuzzStrength: 1
+    - _HeightAmplitude: 0.02
+    - _HeightCenter: 0.5
+    - _HeightMapParametrization: 0
+    - _HeightMax: 1
+    - _HeightMin: -1
+    - _HeightOffset: 0
+    - _HeightPoMAmplitude: 2
+    - _HeightTessAmplitude: 2
+    - _HeightTessCenter: 0.5
+    - _InvTilingScale: 1
+    - _Ior: 1.5
+    - _IridescenceMask: 1
+    - _IridescenceThickness: 1
+    - _LinkDetailsWithBase: 1
+    - _MaterialID: 1
+    - _MaterialTypeMask: 2
+    - _Metallic: 0
+    - _MetallicRemapMax: 1
+    - _MetallicRemapMin: 0
+    - _Noise_Intensity: 0
+    - _NormalMapSpace: 0
+    - _NormalMapStrength: 1
+    - _NormalScale: 1
+    - _ObjectSpaceUVMapping: 0
+    - _ObjectSpaceUVMappingEmissive: 0
+    - _OpaqueCullMode: 2
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _PPDPrimitiveLength: 1
+    - _PPDPrimitiveWidth: 1
+    - _PerPixelSorting: 0
+    - _QueueControl: -1
+    - _QueueOffset: 0
+    - _RayTracing: 0
+    - _ReceivesSSR: 1
+    - _ReceivesSSRTransparent: 0
+    - _RefractionModel: 0
+    - _RenderQueueType: 1
+    - _RequireSplitLighting: 1
+    - _Smoothness: 0.5
+    - _SmoothnessMax: 1
+    - _SmoothnessMin: 0
+    - _SmoothnessRemapMax: 1
+    - _SmoothnessRemapMin: 0
+    - _Smoothness_A: 0
+    - _Smoothness_B: 0.25
+    - _SpecularAAScreenSpaceVariance: 0.1
+    - _SpecularAAThreshold: 0.2
+    - _SpecularOcclusionMode: 1
+    - _Specular_A: 0
+    - _Specular_B: 0.25
+    - _SrcBlend: 1
+    - _StencilRef: 0
+    - _StencilRefDepth: 8
+    - _StencilRefDistortionVec: 4
+    - _StencilRefGBuffer: 10
+    - _StencilRefMV: 40
+    - _StencilWriteMask: 6
+    - _StencilWriteMaskDepth: 9
+    - _StencilWriteMaskDistortionVec: 4
+    - _StencilWriteMaskGBuffer: 15
+    - _StencilWriteMaskMV: 43
+    - _SubsurfaceMask: 1
+    - _SupportDecals: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
+    - _Thickness: 1
+    - _ThreadAOStrength01: 0.5
+    - _ThreadNormalStrength: 0.5
+    - _ThreadSmoothnessScale: 0.5
+    - _Tiling: 0.5
+    - _Tiling_Noise: 20
+    - _TransmissionEnable: 1
+    - _TransmissionMask: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentCullMode: 2
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _TransparentSortPriority: 0
+    - _TransparentWritingMotionVec: 0
+    - _TransparentZWrite: 0
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVEmissive: 0
+    - _UseEmissiveIntensity: 0
+    - _UseShadowThreshold: 0
+    - _ZTestDepthEqualForOpaque: 3
+    - _ZTestGBuffer: 4
+    - _ZTestTransparent: 4
+    - _ZWrite: 1
+    - _useThreadMap: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0}
+    - _Color: {r: 0.38679248, g: 0.38679248, b: 0.38679248, a: 1}
+    - _Color_A: {r: 0.5, g: 0.5, b: 0.5, a: 0}
+    - _Color_B: {r: 0.4, g: 0.4, b: 0.4, a: 0}
+    - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1}
+    - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0}
+    - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}
+    - _uvBaseMask: {r: 1, g: 0, b: 0, a: 0}
+    - _uvBaseST: {r: 1, g: 1, b: 0, a: 0}
+    - _uvThreadMask: {r: 1, g: 0, b: 0, a: 0}
+    - _uvThreadST: {r: 1, g: 1, b: 0, a: 0}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1
+--- !u!114 &6461052843977076103
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 13
+  hdPluginSubTargetMaterialVersions:
+    m_Keys: []
+    m_Values: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/Samples_BackdropFabric.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 638589c7422aff14eaa79da6fad69c7c
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/Samples_BackdropFabric_Red.mat

@@ -0,0 +1,85 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-8225026165073191674
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Samples_BackdropFabric_Red
+  m_Shader: {fileID: -6465566751694194690, guid: 137a9d0b49032c544abaff345d2c4f5c, type: 3}
+  m_Parent: {fileID: 2100000, guid: 638589c7422aff14eaa79da6fad69c7c, type: 2}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords:
+  - _DISABLE_SSR_TRANSPARENT
+  - _DOUBLESIDED_ON
+  - _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap:
+    MotionVector: User
+  disabledShaderPasses:
+  - TransparentDepthPrepass
+  - TransparentDepthPostpass
+  - TransparentBackface
+  - RayTracingPrepass
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs: []
+    m_Ints: []
+    m_Floats:
+    - _Anisotropy: -0.5
+    - _Specular_A: 0.5
+    - _Specular_B: 0.5
+    m_Colors:
+    - _Color: {r: 0.5471698, g: 0.120790295, b: 0.13512228, a: 1}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1
+--- !u!114 &1443011941897949152
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 639247ca83abc874e893eb93af2b5e44, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 0
+--- !u!114 &6461052843977076103
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 13
+  hdPluginSubTargetMaterialVersions:
+    m_Keys: []
+    m_Values: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/Samples_BackdropFabric_Red.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5542edf9bbf7f31498a9a217ab9585b8
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/Samples_BlackPaint.mat

@@ -0,0 +1,363 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Samples_BlackPaint
+  m_Shader: {fileID: -6465566751694194690, guid: 77a073c5851b973499ddf6de1a1c803f, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords:
+  - _DISABLE_SSR_TRANSPARENT
+  - _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 2225
+  stringTagMap:
+    MotionVector: User
+  disabledShaderPasses:
+  - TransparentDepthPrepass
+  - TransparentDepthPostpass
+  - TransparentBackface
+  - RayTracingPrepass
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoatMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Diffuse:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IQTileBreakUp_0b3cd1a6a008445da99ac63a2babcbf2_Texture2D_3705510442_Texture2D:
+        m_Texture: {fileID: 2800000, guid: 69883503249f7bb439f8d69205c55906, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IQTileBreakUp_c8ee369118cf4b56864a96241dbcdc78_Texture2D_3705510442_Texture2D:
+        m_Texture: {fileID: 2800000, guid: 69883503249f7bb439f8d69205c55906, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Mask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Normal:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmissionMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmittanceColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Triplanar_2a2e7b2954ed4542938d699f1646feac_Texture_1_Texture2D:
+        m_Texture: {fileID: 2800000, guid: db6d649b1616e6d4993c6d59045ff96b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Triplanar_5383659d67874c699e04e095f586c1f3_Texture_1_Texture2D:
+        m_Texture: {fileID: 2800000, guid: 69883503249f7bb439f8d69205c55906, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AORemapMax: 1
+    - _AORemapMin: 0
+    - _ATDistance: 1
+    - _AddPrecomputedVelocity: 0
+    - _AlbedoAffectEmissive: 0
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _AlphaCutoffPostpass: 0.5
+    - _AlphaCutoffPrepass: 0.5
+    - _AlphaCutoffShadow: 0.5
+    - _AlphaDstBlend: 0
+    - _AlphaRemapMax: 1
+    - _AlphaRemapMin: 0
+    - _AlphaSrcBlend: 1
+    - _Ambient_Occlusion_R: 1
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _CoatMask: 0
+    - _Color_Variant_Contrast: 0
+    - _Color_Variant_Intensity: 0.125
+    - _ConservativeDepthOffsetEnable: 0
+    - _CullMode: 2
+    - _CullModeForward: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DiffusionProfile: 0
+    - _DiffusionProfileHash: 0
+    - _DisplacementLockObjectScale: 1
+    - _DisplacementLockTilingScale: 1
+    - _DisplacementMode: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedGIMode: 0
+    - _DoubleSidedNormalMode: 1
+    - _DstBlend: 0
+    - _DstBlend2: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveExposureWeight: 1
+    - _EmissiveIntensity: 1
+    - _EmissiveIntensityUnit: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _EnableGeometricSpecularAA: 0
+    - _EnergyConservingSpecularColor: 1
+    - _HeightAmplitude: 0.02
+    - _HeightCenter: 0.5
+    - _HeightMapParametrization: 0
+    - _HeightMax: 1
+    - _HeightMin: -1
+    - _HeightOffset: 0
+    - _HeightPoMAmplitude: 2
+    - _HeightTessAmplitude: 2
+    - _HeightTessCenter: 0.5
+    - _InvTilingScale: 1
+    - _Ior: 1.5
+    - _IridescenceMask: 1
+    - _IridescenceThickness: 1
+    - _LinkDetailsWithBase: 1
+    - _MaterialID: 1
+    - _MaterialTypeMask: 2
+    - _Metallic: 0
+    - _MetallicRemapMax: 1
+    - _MetallicRemapMin: 0
+    - _Metallic_B: 0
+    - _Noise_B_Strength: 0.598
+    - _Noise_B_Strength_Color: 0.301
+    - _Noise_G_Strength: 0
+    - _Noise_G_Strength_Color: 1
+    - _Noise_R_Strength: 0
+    - _Noise_R_Strength_Color: 0.101
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _Normal_Strength: 1
+    - _ObjectSpaceUVMapping: 0
+    - _ObjectSpaceUVMappingEmissive: 0
+    - _Object_Space: 0
+    - _OpaqueCullMode: 2
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _PPDPrimitiveLength: 1
+    - _PPDPrimitiveWidth: 1
+    - _PerPixelSorting: 0
+    - _QueueControl: -1
+    - _QueueOffset: 0
+    - _RayTracing: 0
+    - _ReceivesSSR: 1
+    - _ReceivesSSRTransparent: 0
+    - _RefractionModel: 0
+    - _RenderQueueType: 1
+    - _RequireSplitLighting: 0
+    - _Scale: 0.1
+    - _Smoothness: 0.025
+    - _SmoothnessRemapMax: 1
+    - _SmoothnessRemapMin: 0
+    - _Smoothness_1: 0.041
+    - _Smoothness_2: 0.257
+    - _Smoothness_Contrast: 0.108
+    - _Smoothness_G: 0.1
+    - _SpecularAAScreenSpaceVariance: 0.1
+    - _SpecularAAThreshold: 0.2
+    - _SpecularOcclusionMode: 1
+    - _SrcBlend: 1
+    - _StencilRef: 0
+    - _StencilRefDepth: 8
+    - _StencilRefDistortionVec: 4
+    - _StencilRefGBuffer: 10
+    - _StencilRefMV: 40
+    - _StencilWriteMask: 6
+    - _StencilWriteMaskDepth: 9
+    - _StencilWriteMaskDistortionVec: 4
+    - _StencilWriteMaskGBuffer: 15
+    - _StencilWriteMaskMV: 41
+    - _SubsurfaceMask: 1
+    - _SupportDecals: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
+    - _Thickness: 1
+    - _TransmissionEnable: 1
+    - _TransmissionMask: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentCullMode: 2
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _TransparentSortPriority: 0
+    - _TransparentWritingMotionVec: 0
+    - _TransparentZWrite: 0
+    - _USE_TRIPLANAR: 0
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVEmissive: 0
+    - _UseEmissiveIntensity: 0
+    - _UseShadowThreshold: 0
+    - _ZTestDepthEqualForOpaque: 3
+    - _ZTestGBuffer: 4
+    - _ZTestTransparent: 4
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 0.13, g: 0.13, b: 0.13, a: 0}
+    - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0}
+    - _Color: {r: 0.12, g: 0.12, b: 0.12, a: 0}
+    - _Color_Variant: {r: 0.1981132, g: 0.1981132, b: 0.1981132, a: 0}
+    - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1}
+    - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0}
+    - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}
+    - _UV_Offset: {r: 0, g: 0, b: 0, a: 0}
+    - _UV_Tiling: {r: 1, g: 1, b: 0, a: 0}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1
+--- !u!114 &7008279879314206002
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 639247ca83abc874e893eb93af2b5e44, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 0
+--- !u!114 &7902377284972801844
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9
+--- !u!114 &8076905772522948068
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 13
+  hdPluginSubTargetMaterialVersions:
+    m_Keys: []
+    m_Values: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/Samples_BlackPaint.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 735e5139c2106f54096a4ebbeea42ac7
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/Samples_Checker.mat

@@ -0,0 +1,165 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Samples_Checker
+  m_Shader: {fileID: -6465566751694194690, guid: 12b97e20ea15a7844849d66169c21bed, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords:
+  - _DISABLE_SSR_TRANSPARENT
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 2225
+  stringTagMap:
+    MotionVector: User
+  disabledShaderPasses:
+  - TransparentDepthPrepass
+  - TransparentDepthPostpass
+  - TransparentBackface
+  - RayTracingPrepass
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _SampleTexture2D_86d1f10a843f4c7680c0bd6cb0715121_Texture_1_Texture2D:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _Adapt_Checker_to_Scale: 1
+    - _AddPrecomputedVelocity: 0
+    - _AlphaCutoffEnable: 0
+    - _AlphaDstBlend: 0
+    - _AlphaSrcBlend: 1
+    - _BlendMode: 0
+    - _CheckerBoardScale: 8
+    - _ConservativeDepthOffsetEnable: 0
+    - _CullMode: 2
+    - _CullModeForward: 2
+    - _DepthOffsetEnable: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedGIMode: 0
+    - _DoubleSidedNormalMode: 2
+    - _DstBlend: 0
+    - _DstBlend2: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _MaterialID: 1
+    - _MaterialTypeMask: 2
+    - _Metal: 0
+    - _Metal_1: 0
+    - _Metal_2: 0
+    - _Noise_Color_Intensity: 0.25
+    - _Noise_Scale: 3.17
+    - _Noise_Smoothness_Intensity: 0.5
+    - _OpaqueCullMode: 2
+    - _PerPixelSorting: 0
+    - _QueueControl: -1
+    - _QueueOffset: 0
+    - _Radius: 0.5
+    - _RayTracing: 0
+    - _ReceivesSSR: 1
+    - _ReceivesSSRTransparent: 0
+    - _RefractionModel: 0
+    - _RenderQueueType: 1
+    - _RequireSplitLighting: 0
+    - _Smoothness_1: 0.25
+    - _Smoothness_2: 0.1
+    - _SrcBlend: 1
+    - _StencilRef: 0
+    - _StencilRefDepth: 8
+    - _StencilRefDistortionVec: 4
+    - _StencilRefGBuffer: 10
+    - _StencilRefMV: 40
+    - _StencilWriteMask: 6
+    - _StencilWriteMaskDepth: 9
+    - _StencilWriteMaskDistortionVec: 4
+    - _StencilWriteMaskGBuffer: 15
+    - _StencilWriteMaskMV: 41
+    - _SupportDecals: 1
+    - _SurfaceType: 0
+    - _TransmissionEnable: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentCullMode: 2
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _TransparentSortPriority: 0
+    - _TransparentWritingMotionVec: 0
+    - _TransparentZWrite: 0
+    - _UseShadowThreshold: 0
+    - _ZTestDepthEqualForOpaque: 3
+    - _ZTestGBuffer: 4
+    - _ZTestTransparent: 4
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0, g: 0, b: 0, a: 0}
+    - _Color_1: {r: 0.254717, g: 0.254717, b: 0.254717, a: 0}
+    - _Color_2: {r: 0.191, g: 0.191, b: 0.191, a: 0}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1
+--- !u!114 &484575842197547937
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 13
+  hdPluginSubTargetMaterialVersions:
+    m_Keys: []
+    m_Values: 
+--- !u!114 &6243711038889969139
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 639247ca83abc874e893eb93af2b5e44, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 0
+--- !u!114 &8018026817525244604
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/Samples_Checker.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3dd629c30f0676f47876c908191b19f3
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/Samples_Curtain.mat

@@ -0,0 +1,374 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-7907225886885702278
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9
+--- !u!114 &-4757135422042230766
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 639247ca83abc874e893eb93af2b5e44, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 0
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Samples_Curtain
+  m_Shader: {fileID: -6465566751694194690, guid: 137a9d0b49032c544abaff345d2c4f5c, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords:
+  - _DISABLE_SSR_TRANSPARENT
+  - _DOUBLESIDED_ON
+  - _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 1
+  m_CustomRenderQueue: 2225
+  stringTagMap:
+    MotionVector: User
+  disabledShaderPasses:
+  - TransparentDepthPrepass
+  - TransparentDepthPostpass
+  - TransparentBackface
+  - RayTracingPrepass
+  - MOTIONVECTORS
+  m_LockedProperties: _Smoothness_A
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoatMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _FuzzMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SampleTexture2D_78839aa280ca4494bd3327504d2bad10_Texture_1:
+        m_Texture: {fileID: 2800000, guid: 1d8481de16af723418a688958c41224b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SampleTexture2D_902879fdde31447d937665ba0f7b22c1_Texture_1:
+        m_Texture: {fileID: 2800000, guid: 6204d5e5928803d43a2994437a71e2f5, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SampleTexture2D_b53501e4ed5944e5ad663a7f6bdf83cb_Texture_1:
+        m_Texture: {fileID: 2800000, guid: 1d8481de16af723418a688958c41224b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SampleTexture2D_fcb428a0e2674339a94d053242cbb679_Texture_1:
+        m_Texture: {fileID: 2800000, guid: 1d8481de16af723418a688958c41224b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThreadMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmissionMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmittanceColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Triplanar_1b18acb21b804ef3ba3a4056a073deed_Texture_1:
+        m_Texture: {fileID: 2800000, guid: 1d8481de16af723418a688958c41224b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Triplanar_1b18acb21b804ef3ba3a4056a073deed_Texture_1_Texture2D:
+        m_Texture: {fileID: 2800000, guid: 1d8481de16af723418a688958c41224b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Triplanar_4b94b7bfb5c042558eedcdbc26d14943_Texture_1:
+        m_Texture: {fileID: 2800000, guid: 1d8481de16af723418a688958c41224b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AORemapMax: 1
+    - _AORemapMin: 0
+    - _ATDistance: 1
+    - _AddPrecomputedVelocity: 0
+    - _AlbedoAffectEmissive: 0
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _AlphaCutoffPostpass: 0.5
+    - _AlphaCutoffPrepass: 0.5
+    - _AlphaCutoffShadow: 0.5
+    - _AlphaDstBlend: 0
+    - _AlphaRemapMax: 1
+    - _AlphaRemapMin: 0
+    - _AlphaSrcBlend: 1
+    - _Anisotropy: -0.19
+    - _Blend: 1
+    - _BlendMode: 0
+    - _CoatMask: 0
+    - _Color_Variation_Multiplier: 0.5
+    - _ConservativeDepthOffsetEnable: 0
+    - _CullMode: 0
+    - _CullModeForward: 0
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DiffusionProfile: 0
+    - _DiffusionProfileHash: 0
+    - _DisplacementLockObjectScale: 1
+    - _DisplacementLockTilingScale: 1
+    - _DisplacementMode: 0
+    - _DoubleSidedEnable: 1
+    - _DoubleSidedGIMode: 0
+    - _DoubleSidedNormalMode: 1
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveExposureWeight: 1
+    - _EmissiveIntensity: 1
+    - _EmissiveIntensityUnit: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _EnableGeometricSpecularAA: 0
+    - _EnergyConservingSpecularColor: 1
+    - _Float: 1
+    - _FuzzMapUVScale: 0.1
+    - _FuzzStrength: 1
+    - _HeightAmplitude: 0.02
+    - _HeightCenter: 0.5
+    - _HeightMapParametrization: 0
+    - _HeightMax: 1
+    - _HeightMin: -1
+    - _HeightOffset: 0
+    - _HeightPoMAmplitude: 2
+    - _HeightTessAmplitude: 2
+    - _HeightTessCenter: 0.5
+    - _InvTilingScale: 1
+    - _Ior: 1.5
+    - _IridescenceMask: 1
+    - _IridescenceThickness: 1
+    - _LinkDetailsWithBase: 1
+    - _MaterialID: 1
+    - _MaterialTypeMask: 2
+    - _Metallic: 0
+    - _MetallicRemapMax: 1
+    - _MetallicRemapMin: 0
+    - _Noise_Intensity: 0
+    - _NormalMapSpace: 0
+    - _NormalMapStrength: 1
+    - _NormalScale: 1
+    - _ObjectSpaceUVMapping: 0
+    - _ObjectSpaceUVMappingEmissive: 0
+    - _OpaqueCullMode: 2
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _PPDPrimitiveLength: 1
+    - _PPDPrimitiveWidth: 1
+    - _QueueControl: -1
+    - _QueueOffset: 0
+    - _RayTracing: 0
+    - _ReceivesSSR: 1
+    - _ReceivesSSRTransparent: 0
+    - _RefractionModel: 0
+    - _RenderQueueType: 1
+    - _RequireSplitLighting: 1
+    - _Smoothness: 0.5
+    - _SmoothnessMax: 1
+    - _SmoothnessMin: 0
+    - _SmoothnessRemapMax: 1
+    - _SmoothnessRemapMin: 0
+    - _Smoothness_A: 0.25
+    - _Smoothness_B: 0.33
+    - _SpecularAAScreenSpaceVariance: 0.1
+    - _SpecularAAThreshold: 0.2
+    - _SpecularOcclusionMode: 1
+    - _Specular_A: 0.5
+    - _Specular_B: 0.5
+    - _SrcBlend: 1
+    - _StencilRef: 0
+    - _StencilRefDepth: 8
+    - _StencilRefDistortionVec: 4
+    - _StencilRefGBuffer: 10
+    - _StencilRefMV: 40
+    - _StencilWriteMask: 6
+    - _StencilWriteMaskDepth: 9
+    - _StencilWriteMaskDistortionVec: 4
+    - _StencilWriteMaskGBuffer: 15
+    - _StencilWriteMaskMV: 43
+    - _SubsurfaceMask: 1
+    - _SupportDecals: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
+    - _Thickness: 1
+    - _ThreadAOStrength01: 0.5
+    - _ThreadNormalStrength: 0.5
+    - _ThreadSmoothnessScale: 0.5
+    - _Tiling: 0.33
+    - _Tiling_Noise: 20
+    - _TransmissionEnable: 1
+    - _TransmissionMask: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentCullMode: 2
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _TransparentSortPriority: 0
+    - _TransparentWritingMotionVec: 0
+    - _TransparentZWrite: 0
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVEmissive: 0
+    - _UseEmissiveIntensity: 0
+    - _UseShadowThreshold: 0
+    - _ZTestDepthEqualForOpaque: 3
+    - _ZTestGBuffer: 4
+    - _ZTestTransparent: 4
+    - _ZWrite: 1
+    - _useThreadMap: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0}
+    - _Color: {r: 0.24528301, g: 0.24528301, b: 0.24528301, a: 1}
+    - _Color_A: {r: 0.5, g: 0.5, b: 0.5, a: 0}
+    - _Color_B: {r: 0.4, g: 0.4, b: 0.4, a: 0}
+    - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1}
+    - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0}
+    - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}
+    - _uvBaseMask: {r: 1, g: 0, b: 0, a: 0}
+    - _uvBaseST: {r: 1, g: 1, b: 0, a: 0}
+    - _uvThreadMask: {r: 1, g: 0, b: 0, a: 0}
+    - _uvThreadST: {r: 1, g: 1, b: 0, a: 0}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1
+--- !u!114 &6461052843977076103
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 13
+  hdPluginSubTargetMaterialVersions:
+    m_Keys: []
+    m_Values: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/Samples_Curtain.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3619d3635b32e074093e20a11daf1aa3
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/Samples_Platform.mat

@@ -0,0 +1,363 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-5759668321534919737
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 639247ca83abc874e893eb93af2b5e44, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 0
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Samples_Platform
+  m_Shader: {fileID: -6465566751694194690, guid: 77a073c5851b973499ddf6de1a1c803f, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords:
+  - _DISABLE_SSR_TRANSPARENT
+  - _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 2225
+  stringTagMap:
+    MotionVector: User
+  disabledShaderPasses:
+  - TransparentDepthPrepass
+  - TransparentDepthPostpass
+  - TransparentBackface
+  - RayTracingPrepass
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoatMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Diffuse:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IQTileBreakUp_0b3cd1a6a008445da99ac63a2babcbf2_Texture2D_3705510442_Texture2D:
+        m_Texture: {fileID: 2800000, guid: 69883503249f7bb439f8d69205c55906, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IQTileBreakUp_c8ee369118cf4b56864a96241dbcdc78_Texture2D_3705510442_Texture2D:
+        m_Texture: {fileID: 2800000, guid: 69883503249f7bb439f8d69205c55906, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Mask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Normal:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmissionMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmittanceColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Triplanar_2a2e7b2954ed4542938d699f1646feac_Texture_1_Texture2D:
+        m_Texture: {fileID: 2800000, guid: db6d649b1616e6d4993c6d59045ff96b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Triplanar_5383659d67874c699e04e095f586c1f3_Texture_1_Texture2D:
+        m_Texture: {fileID: 2800000, guid: 69883503249f7bb439f8d69205c55906, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AORemapMax: 1
+    - _AORemapMin: 0
+    - _ATDistance: 1
+    - _AddPrecomputedVelocity: 0
+    - _AlbedoAffectEmissive: 0
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _AlphaCutoffPostpass: 0.5
+    - _AlphaCutoffPrepass: 0.5
+    - _AlphaCutoffShadow: 0.5
+    - _AlphaDstBlend: 0
+    - _AlphaRemapMax: 1
+    - _AlphaRemapMin: 0
+    - _AlphaSrcBlend: 1
+    - _Ambient_Occlusion_R: 1
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _CoatMask: 0
+    - _Color_Variant_Contrast: 0
+    - _Color_Variant_Intensity: 0.413
+    - _ConservativeDepthOffsetEnable: 0
+    - _CullMode: 2
+    - _CullModeForward: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DiffusionProfile: 0
+    - _DiffusionProfileHash: 0
+    - _DisplacementLockObjectScale: 1
+    - _DisplacementLockTilingScale: 1
+    - _DisplacementMode: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedGIMode: 0
+    - _DoubleSidedNormalMode: 1
+    - _DstBlend: 0
+    - _DstBlend2: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveExposureWeight: 1
+    - _EmissiveIntensity: 1
+    - _EmissiveIntensityUnit: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _EnableGeometricSpecularAA: 0
+    - _EnergyConservingSpecularColor: 1
+    - _HeightAmplitude: 0.02
+    - _HeightCenter: 0.5
+    - _HeightMapParametrization: 0
+    - _HeightMax: 1
+    - _HeightMin: -1
+    - _HeightOffset: 0
+    - _HeightPoMAmplitude: 2
+    - _HeightTessAmplitude: 2
+    - _HeightTessCenter: 0.5
+    - _InvTilingScale: 1
+    - _Ior: 1.5
+    - _IridescenceMask: 1
+    - _IridescenceThickness: 1
+    - _LinkDetailsWithBase: 1
+    - _MaterialID: 1
+    - _MaterialTypeMask: 2
+    - _Metallic: 0
+    - _MetallicRemapMax: 1
+    - _MetallicRemapMin: 0
+    - _Metallic_B: 0
+    - _Noise_B_Strength: 0.403
+    - _Noise_B_Strength_Color: 0.313
+    - _Noise_G_Strength: 1
+    - _Noise_G_Strength_Color: 1
+    - _Noise_R_Strength: 0.08
+    - _Noise_R_Strength_Color: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _Normal_Strength: 1
+    - _ObjectSpaceUVMapping: 0
+    - _ObjectSpaceUVMappingEmissive: 0
+    - _Object_Space: 0
+    - _OpaqueCullMode: 2
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _PPDPrimitiveLength: 1
+    - _PPDPrimitiveWidth: 1
+    - _PerPixelSorting: 0
+    - _QueueControl: -1
+    - _QueueOffset: 0
+    - _RayTracing: 0
+    - _ReceivesSSR: 1
+    - _ReceivesSSRTransparent: 0
+    - _RefractionModel: 0
+    - _RenderQueueType: 1
+    - _RequireSplitLighting: 0
+    - _Scale: 0.5
+    - _Smoothness: 0.025
+    - _SmoothnessRemapMax: 1
+    - _SmoothnessRemapMin: 0
+    - _Smoothness_1: 0.028
+    - _Smoothness_2: 0.25
+    - _Smoothness_Contrast: 0.291
+    - _Smoothness_G: 0.1
+    - _SpecularAAScreenSpaceVariance: 0.1
+    - _SpecularAAThreshold: 0.2
+    - _SpecularOcclusionMode: 1
+    - _SrcBlend: 1
+    - _StencilRef: 0
+    - _StencilRefDepth: 8
+    - _StencilRefDistortionVec: 4
+    - _StencilRefGBuffer: 10
+    - _StencilRefMV: 40
+    - _StencilWriteMask: 6
+    - _StencilWriteMaskDepth: 9
+    - _StencilWriteMaskDistortionVec: 4
+    - _StencilWriteMaskGBuffer: 15
+    - _StencilWriteMaskMV: 41
+    - _SubsurfaceMask: 1
+    - _SupportDecals: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
+    - _Thickness: 1
+    - _TransmissionEnable: 1
+    - _TransmissionMask: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentCullMode: 2
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _TransparentSortPriority: 0
+    - _TransparentWritingMotionVec: 0
+    - _TransparentZWrite: 0
+    - _USE_TRIPLANAR: 0
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVEmissive: 0
+    - _UseEmissiveIntensity: 0
+    - _UseShadowThreshold: 0
+    - _ZTestDepthEqualForOpaque: 3
+    - _ZTestGBuffer: 4
+    - _ZTestTransparent: 4
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 0.13, g: 0.13, b: 0.13, a: 0}
+    - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0}
+    - _Color: {r: 0.6981132, g: 0.6981132, b: 0.6981132, a: 0}
+    - _Color_Variant: {r: 0.2830189, g: 0.21537915, b: 0.21537915, a: 0}
+    - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1}
+    - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0}
+    - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}
+    - _UV_Offset: {r: 0, g: 0, b: 0, a: 0}
+    - _UV_Tiling: {r: 1, g: 1, b: 0, a: 0}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1
+--- !u!114 &7902377284972801844
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9
+--- !u!114 &8076905772522948068
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 13
+  hdPluginSubTargetMaterialVersions:
+    m_Keys: []
+    m_Values: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/Samples_Platform.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 25a9739d74f47314c9cd2d850a5357c0
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/Samples_RoughGrey.mat

@@ -0,0 +1,334 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-1603643827908197234
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 639247ca83abc874e893eb93af2b5e44, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 0
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Samples_RoughGrey
+  m_Shader: {fileID: -6465566751694194690, guid: 181d9f8961a46b84fa2b2acfc30cdf9c, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords:
+  - _DISABLE_SSR_TRANSPARENT
+  - _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 2225
+  stringTagMap:
+    MotionVector: User
+  disabledShaderPasses:
+  - TransparentDepthPrepass
+  - TransparentDepthPostpass
+  - TransparentBackface
+  - RayTracingPrepass
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoatMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Diffuse:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Mask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Normal:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmissionMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmittanceColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AORemapMax: 1
+    - _AORemapMin: 0
+    - _ATDistance: 1
+    - _AddPrecomputedVelocity: 0
+    - _AlbedoAffectEmissive: 0
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _AlphaCutoffPostpass: 0.5
+    - _AlphaCutoffPrepass: 0.5
+    - _AlphaCutoffShadow: 0.5
+    - _AlphaDstBlend: 0
+    - _AlphaRemapMax: 1
+    - _AlphaRemapMin: 0
+    - _AlphaSrcBlend: 1
+    - _Ambient_Occlusion_R: 1
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _CoatMask: 0
+    - _ConservativeDepthOffsetEnable: 0
+    - _CullMode: 2
+    - _CullModeForward: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DiffusionProfile: 0
+    - _DiffusionProfileHash: 0
+    - _DisplacementLockObjectScale: 1
+    - _DisplacementLockTilingScale: 1
+    - _DisplacementMode: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedGIMode: 0
+    - _DoubleSidedNormalMode: 1
+    - _DstBlend: 0
+    - _DstBlend2: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveExposureWeight: 1
+    - _EmissiveIntensity: 1
+    - _EmissiveIntensityUnit: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _EnableGeometricSpecularAA: 0
+    - _EnergyConservingSpecularColor: 1
+    - _HeightAmplitude: 0.02
+    - _HeightCenter: 0.5
+    - _HeightMapParametrization: 0
+    - _HeightMax: 1
+    - _HeightMin: -1
+    - _HeightOffset: 0
+    - _HeightPoMAmplitude: 2
+    - _HeightTessAmplitude: 2
+    - _HeightTessCenter: 0.5
+    - _InvTilingScale: 1
+    - _Ior: 1.5
+    - _IridescenceMask: 1
+    - _IridescenceThickness: 1
+    - _LinkDetailsWithBase: 1
+    - _MaterialID: 1
+    - _MaterialTypeMask: 2
+    - _Metallic: 0
+    - _MetallicRemapMax: 1
+    - _MetallicRemapMin: 0
+    - _Metallic_B: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _Normal_Strength: 1
+    - _ObjectSpaceUVMapping: 0
+    - _ObjectSpaceUVMappingEmissive: 0
+    - _OpaqueCullMode: 2
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _PPDPrimitiveLength: 1
+    - _PPDPrimitiveWidth: 1
+    - _PerPixelSorting: 0
+    - _QueueControl: -1
+    - _QueueOffset: 0
+    - _RayTracing: 0
+    - _ReceivesSSR: 1
+    - _ReceivesSSRTransparent: 0
+    - _RefractionModel: 0
+    - _RenderQueueType: 1
+    - _RequireSplitLighting: 0
+    - _Smoothness: 0.025
+    - _SmoothnessRemapMax: 1
+    - _SmoothnessRemapMin: 0
+    - _Smoothness_G: 0
+    - _SpecularAAScreenSpaceVariance: 0.1
+    - _SpecularAAThreshold: 0.2
+    - _SpecularOcclusionMode: 1
+    - _SrcBlend: 1
+    - _StencilRef: 0
+    - _StencilRefDepth: 8
+    - _StencilRefDistortionVec: 4
+    - _StencilRefGBuffer: 10
+    - _StencilRefMV: 40
+    - _StencilWriteMask: 6
+    - _StencilWriteMaskDepth: 9
+    - _StencilWriteMaskDistortionVec: 4
+    - _StencilWriteMaskGBuffer: 15
+    - _StencilWriteMaskMV: 41
+    - _SubsurfaceMask: 1
+    - _SupportDecals: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
+    - _Thickness: 1
+    - _TransmissionEnable: 1
+    - _TransmissionMask: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentCullMode: 2
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _TransparentSortPriority: 0
+    - _TransparentWritingMotionVec: 0
+    - _TransparentZWrite: 0
+    - _Triplanar_Scale: 1
+    - _USE_TRIPLANAR: 0
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVEmissive: 0
+    - _UseEmissiveIntensity: 0
+    - _UseShadowThreshold: 0
+    - _ZTestDepthEqualForOpaque: 3
+    - _ZTestGBuffer: 4
+    - _ZTestTransparent: 4
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 0.5, g: 0.5, b: 0.5, a: 0}
+    - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0}
+    - _Color: {r: 0.5, g: 0.5, b: 0.5, a: 0}
+    - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1}
+    - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0}
+    - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}
+    - _UV_Offset: {r: 0, g: 0, b: 0, a: 0}
+    - _UV_Tiling: {r: 1, g: 1, b: 0, a: 0}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1
+--- !u!114 &7902377284972801844
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9
+--- !u!114 &8076905772522948068
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 13
+  hdPluginSubTargetMaterialVersions:
+    m_Keys: []
+    m_Values: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/Samples_RoughGrey.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: fb22585495bb7654fa50ed515d77bb79
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/Samples_RoughSteel.mat

@@ -0,0 +1,352 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Samples_RoughSteel
+  m_Shader: {fileID: -6465566751694194690, guid: 181d9f8961a46b84fa2b2acfc30cdf9c, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords:
+  - _DISABLE_SSR_TRANSPARENT
+  - _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 2225
+  stringTagMap:
+    MotionVector: User
+  disabledShaderPasses:
+  - TransparentDepthPrepass
+  - TransparentDepthPostpass
+  - TransparentBackface
+  - RayTracingPrepass
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _CoatMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Diffuse:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _IridescenceThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Mask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Normal:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmissionMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmittanceColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Triplanar_5383659d67874c699e04e095f586c1f3_Texture_1_Texture2D:
+        m_Texture: {fileID: 2800000, guid: 69883503249f7bb439f8d69205c55906, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AORemapMax: 1
+    - _AORemapMin: 0
+    - _ATDistance: 1
+    - _AddPrecomputedVelocity: 0
+    - _AlbedoAffectEmissive: 0
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _AlphaCutoffPostpass: 0.5
+    - _AlphaCutoffPrepass: 0.5
+    - _AlphaCutoffShadow: 0.5
+    - _AlphaDstBlend: 0
+    - _AlphaRemapMax: 1
+    - _AlphaRemapMin: 0
+    - _AlphaSrcBlend: 1
+    - _Ambient_Occlusion_R: 1
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _CoatMask: 0
+    - _Color_Variant_Contrast: 0
+    - _Color_Variant_Intensity: 0
+    - _ConservativeDepthOffsetEnable: 0
+    - _CullMode: 2
+    - _CullModeForward: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DiffusionProfile: 0
+    - _DiffusionProfileHash: 0
+    - _DisplacementLockObjectScale: 1
+    - _DisplacementLockTilingScale: 1
+    - _DisplacementMode: 0
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedGIMode: 0
+    - _DoubleSidedNormalMode: 1
+    - _DstBlend: 0
+    - _DstBlend2: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveExposureWeight: 1
+    - _EmissiveIntensity: 1
+    - _EmissiveIntensityUnit: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _EnableGeometricSpecularAA: 0
+    - _EnergyConservingSpecularColor: 1
+    - _HeightAmplitude: 0.02
+    - _HeightCenter: 0.5
+    - _HeightMapParametrization: 0
+    - _HeightMax: 1
+    - _HeightMin: -1
+    - _HeightOffset: 0
+    - _HeightPoMAmplitude: 2
+    - _HeightTessAmplitude: 2
+    - _HeightTessCenter: 0.5
+    - _InvTilingScale: 1
+    - _Ior: 1.5
+    - _IridescenceMask: 1
+    - _IridescenceThickness: 1
+    - _LinkDetailsWithBase: 1
+    - _MaterialID: 1
+    - _MaterialTypeMask: 2
+    - _Metallic: 1
+    - _MetallicRemapMax: 1
+    - _MetallicRemapMin: 0
+    - _Metallic_B: 1
+    - _Noise_B_Strength: 0
+    - _Noise_B_Strength_Color: 0.47
+    - _Noise_G_Strength: 1
+    - _Noise_G_Strength_Color: 0.47
+    - _Noise_R_Strength: 0
+    - _Noise_R_Strength_Color: 0.05
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _Normal_Strength: 1
+    - _ObjectSpaceUVMapping: 0
+    - _ObjectSpaceUVMappingEmissive: 0
+    - _Object_Space: 0
+    - _OpaqueCullMode: 2
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _PPDPrimitiveLength: 1
+    - _PPDPrimitiveWidth: 1
+    - _PerPixelSorting: 0
+    - _QueueControl: -1
+    - _QueueOffset: 0
+    - _RayTracing: 0
+    - _ReceivesSSR: 1
+    - _ReceivesSSRTransparent: 0
+    - _RefractionModel: 0
+    - _RenderQueueType: 1
+    - _RequireSplitLighting: 0
+    - _Scale: 1
+    - _Smoothness: 0.439
+    - _SmoothnessRemapMax: 1
+    - _SmoothnessRemapMin: 0
+    - _Smoothness_1: 0.073
+    - _Smoothness_2: 0.111
+    - _Smoothness_Contrast: 0.63
+    - _Smoothness_G: 0.391
+    - _SpecularAAScreenSpaceVariance: 0.1
+    - _SpecularAAThreshold: 0.2
+    - _SpecularOcclusionMode: 1
+    - _SrcBlend: 1
+    - _StencilRef: 0
+    - _StencilRefDepth: 8
+    - _StencilRefDistortionVec: 4
+    - _StencilRefGBuffer: 10
+    - _StencilRefMV: 40
+    - _StencilWriteMask: 6
+    - _StencilWriteMaskDepth: 9
+    - _StencilWriteMaskDistortionVec: 4
+    - _StencilWriteMaskGBuffer: 15
+    - _StencilWriteMaskMV: 41
+    - _SubsurfaceMask: 1
+    - _SupportDecals: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
+    - _Thickness: 1
+    - _TransmissionEnable: 1
+    - _TransmissionMask: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentCullMode: 2
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _TransparentSortPriority: 0
+    - _TransparentWritingMotionVec: 0
+    - _TransparentZWrite: 0
+    - _Triplanar_Scale: 1
+    - _USE_TRIPLANAR: 0
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVEmissive: 0
+    - _UseEmissiveIntensity: 0
+    - _UseShadowThreshold: 0
+    - _ZTestDepthEqualForOpaque: 3
+    - _ZTestGBuffer: 4
+    - _ZTestTransparent: 4
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 0.69411767, g: 0.69411767, b: 0.69411767, a: 1}
+    - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0}
+    - _Color: {r: 0.69411767, g: 0.69411767, b: 0.69411767, a: 1}
+    - _Color_Variant: {r: 0, g: 0, b: 0, a: 0}
+    - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1}
+    - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0}
+    - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}
+    - _UV_Offset: {r: 0, g: 0, b: 0, a: 0}
+    - _UV_Tiling: {r: 1, g: 1, b: 0, a: 0}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1
+--- !u!114 &179314134643499751
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 13
+  hdPluginSubTargetMaterialVersions:
+    m_Keys: []
+    m_Values: 
+--- !u!114 &7156090504686309666
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 9
+--- !u!114 &7470243039165956749
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 639247ca83abc874e893eb93af2b5e44, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 0

Assets/Samples/Scriptable Render Pipeline Core/Common/Materials/Samples_RoughSteel.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 55610f65dcca6294b9fc9386d9879d82
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: