rizzeadmin/RizzeBattleRoyale
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
RizzeBattleRoyale/Assets/3rdParty/Hovl Studio/Render Pipelines support/Editor/ShaderChanger.cs

1029 lines
64 KiB
C#
Raw Permalink Normal View History

Initial Commit
2025-09-24 11:24:38 +05:00
#if UNITY_EDITOR
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using System.IO;
public class RPChanger : EditorWindow
{
[MenuItem("Tools/RP changer for Hovl Studio assets")]
public static void ShowWindow()
{
RPChanger window = (RPChanger)EditorWindow.GetWindow(typeof(RPChanger));
window.minSize = new Vector2(250, 120);
window.maxSize = new Vector2(250, 120);
}
public void OnGUI()
{
GUILayout.Label("Change VFX pipeline to:");
if (GUILayout.Button("Standard RP"))
{
FindShaders();
ChangeToSRP();
}
if (GUILayout.Button("Universal RP"))
{
FindShaders();
ChangeToURP();
}
if (GUILayout.Button("HDRP"))
{
FindShaders();
ChangeToHDRP();
ChangeToSRP();
ChangeToHDRP();
}
}
Shader Add_CG;
Shader Blend_CG;
Shader LightGlow;
Shader Lit_CenterGlow;
Shader Blend_TwoSides;
Shader Blend_Normals;
Shader Ice;
Shader Distortion;
Shader ParallaxIce;
Shader BlendDistort;
Shader VolumeLaser;
Shader Explosion;
Shader SwordSlash;
Shader ShockWave;
Shader Add_CG_URP;
Shader Blend_CG_URP;
Shader LightGlow_URP;
Shader Lit_CenterGlow_URP;
Shader Blend_TwoSides_URP;
Shader Blend_Normals_URP;
Shader Ice_URP;
Shader Distortion_URP;
Shader ParallaxIce_URP;
Shader BlendDistort_URP;
Shader VolumeLaser_URP;
Shader Explosion_URP;
Shader SwordSlash_URP;
Shader ShockWave_URP;
Shader Add_CG_HDRP;
Shader Blend_CG_HDRP;
Shader LightGlow_HDRP;
Shader Lit_CenterGlow_HDRP;
Shader Blend_TwoSides_HDRP;
Shader Blend_Normals_HDRP;
Shader Ice_HDRP;
Shader Distortion_HDRP;
Shader ParallaxIce_HDRP;
Shader BlendDistort_HDRP;
Shader VolumeLaser_HDRP;
Shader Explosion_HDRP;
Shader SwordSlash_HDRP;
Shader ShockWave_HDRP;
Material[] shaderMaterials;
private void FindShaders()
{
if (Shader.Find("Hovl/Particles/Add_CenterGlow") != null) Add_CG = Shader.Find("Hovl/Particles/Add_CenterGlow");
if (Shader.Find("Hovl/Particles/Blend_CenterGlow") != null) Blend_CG = Shader.Find("Hovl/Particles/Blend_CenterGlow");
if (Shader.Find("Hovl/Particles/LightGlow") != null) LightGlow = Shader.Find("Hovl/Particles/LightGlow");
if (Shader.Find("Hovl/Particles/Lit_CenterGlow") != null) Lit_CenterGlow = Shader.Find("Hovl/Particles/Lit_CenterGlow");
if (Shader.Find("Hovl/Particles/Blend_TwoSides") != null) Blend_TwoSides = Shader.Find("Hovl/Particles/Blend_TwoSides");
if (Shader.Find("Hovl/Particles/Blend_Normals") != null) Blend_Normals = Shader.Find("Hovl/Particles/Blend_Normals");
if (Shader.Find("Hovl/Particles/Ice") != null) Ice = Shader.Find("Hovl/Particles/Ice");
if (Shader.Find("Hovl/Particles/Distortion") != null) Distortion = Shader.Find("Hovl/Particles/Distortion");
if (Shader.Find("Hovl/Opaque/ParallaxIce") != null) ParallaxIce = Shader.Find("Hovl/Opaque/ParallaxIce");
if (Shader.Find("Hovl/Particles/BlendDistort") != null) BlendDistort = Shader.Find("Hovl/Particles/BlendDistort");
if (Shader.Find("Hovl/Particles/VolumeLaser") != null) VolumeLaser = Shader.Find("Hovl/Particles/VolumeLaser");
if (Shader.Find("Hovl/Particles/Explosion") != null) Explosion = Shader.Find("Hovl/Particles/Explosion");
if (Shader.Find("Hovl/Particles/SwordSlash") != null) SwordSlash = Shader.Find("Hovl/Particles/SwordSlash");
if (Shader.Find("Hovl/Particles/ShockWave") != null) ShockWave = Shader.Find("Hovl/Particles/ShockWave");
if (Shader.Find("ERB/LWRP/Particles/LightGlow") != null) LightGlow_URP = Shader.Find("ERB/LWRP/Particles/LightGlow");
if (Shader.Find("Shader Graphs/URP_Lit_CenterGlow") != null) Lit_CenterGlow_URP = Shader.Find("Shader Graphs/URP_Lit_CenterGlow");
if (Shader.Find("Shader Graphs/URP_Blend_TwoSides") != null) Blend_TwoSides_URP = Shader.Find("Shader Graphs/URP_Blend_TwoSides");
if (Shader.Find("Shader Graphs/URP_Blend_Normals") != null) Blend_Normals_URP = Shader.Find("Shader Graphs/URP_Blend_Normals");
if (Shader.Find("Shader Graphs/URP_Ice") != null) Ice_URP = Shader.Find("Shader Graphs/URP_Ice");
if (Shader.Find("Shader Graphs/URP_Distortion") != null) Distortion_URP = Shader.Find("Shader Graphs/URP_Distortion");
if (Shader.Find("Shader Graphs/URP_ParallaxIce") != null) ParallaxIce_URP = Shader.Find("Shader Graphs/URP_ParallaxIce");
if (Shader.Find("Shader Graphs/URP_Add_CG") != null) Add_CG_URP = Shader.Find("Shader Graphs/URP_Add_CG");
if (Shader.Find("Shader Graphs/URP_Blend_CG") != null) Blend_CG_URP = Shader.Find("Shader Graphs/URP_Blend_CG");
if (Shader.Find("Shader Graphs/URP_BlendDistort") != null) BlendDistort_URP = Shader.Find("Shader Graphs/URP_BlendDistort");
if (Shader.Find("Shader Graphs/URP_VolumeLaser") != null) VolumeLaser_URP = Shader.Find("Shader Graphs/URP_VolumeLaser");
if (Shader.Find("Shader Graphs/URP_Explosion") != null) Explosion_URP = Shader.Find("Shader Graphs/URP_Explosion");
if (Shader.Find("Shader Graphs/URP_SwordSlash") != null) SwordSlash_URP = Shader.Find("Shader Graphs/URP_SwordSlash");
if (Shader.Find("Shader Graphs/URP_ShockWave") != null) ShockWave_URP = Shader.Find("Shader Graphs/URP_ShockWave");
if (Shader.Find("ERB/HDRP/Particles/LightGlow") != null) LightGlow_HDRP = Shader.Find("ERB/HDRP/Particles/LightGlow");
if (Shader.Find("Shader Graphs/HDRP_Lit_CenterGlow") != null) Lit_CenterGlow_HDRP = Shader.Find("Shader Graphs/HDRP_Lit_CenterGlow");
if (Shader.Find("Shader Graphs/HDRP_Blend_TwoSides") != null) Blend_TwoSides_HDRP = Shader.Find("Shader Graphs/HDRP_Blend_TwoSides");
if (Shader.Find("Shader Graphs/HDRP_Blend_Normals") != null) Blend_Normals_HDRP = Shader.Find("Shader Graphs/HDRP_Blend_Normals");
if (Shader.Find("Shader Graphs/HDRP_Ice") != null) Ice_HDRP = Shader.Find("Shader Graphs/HDRP_Ice");
if (Shader.Find("Shader Graphs/HDRP_Distortion") != null) Distortion_HDRP = Shader.Find("Shader Graphs/HDRP_Distortion");
if (Shader.Find("Shader Graphs/HDRP_ParallaxIce") != null) ParallaxIce_HDRP = Shader.Find("Shader Graphs/HDRP_ParallaxIce");
if (Shader.Find("Shader Graphs/HDRP_Add_CG") != null) Add_CG_HDRP = Shader.Find("Shader Graphs/HDRP_Add_CG");
if (Shader.Find("Shader Graphs/HDRP_Blend_CG") != null) Blend_CG_HDRP = Shader.Find("Shader Graphs/HDRP_Blend_CG");
if (Shader.Find("Shader Graphs/HDRP_BlendDistort") != null) BlendDistort_HDRP = Shader.Find("Shader Graphs/HDRP_BlendDistort");
if (Shader.Find("Shader Graphs/HDRP_VolumeLaser") != null) VolumeLaser_HDRP = Shader.Find("Shader Graphs/HDRP_VolumeLaser");
if (Shader.Find("Shader Graphs/HDRP_Explosion") != null) Explosion_HDRP = Shader.Find("Shader Graphs/HDRP_Explosion");
if (Shader.Find("Shader Graphs/HDRP_SwordSlash") != null) SwordSlash_HDRP = Shader.Find("Shader Graphs/HDRP_SwordSlash");
if (Shader.Find("Shader Graphs/HDRP_ShockWave") != null) ShockWave_HDRP = Shader.Find("Shader Graphs/HDRP_ShockWave");
string[] folderMat = AssetDatabase.FindAssets("t:Material", new[] { "Assets" });
shaderMaterials = new Material[folderMat.Length];
for (int i = 0; i < folderMat.Length; i++)
{
var patch = AssetDatabase.GUIDToAssetPath(folderMat[i]);
shaderMaterials[i] = (Material)AssetDatabase.LoadAssetAtPath(patch, typeof(Material));
}
}
private void ChangeToURP()
{
foreach (var material in shaderMaterials)
{
if (Shader.Find("ERB/LWRP/Particles/LightGlow") != null)
{
if (material.shader == LightGlow || material.shader == LightGlow_HDRP)
{
material.shader = LightGlow_URP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/URP_Lit_CenterGlow") != null)
{
if (material.shader == Lit_CenterGlow || material.shader == Lit_CenterGlow_HDRP)
{
material.shader = Lit_CenterGlow_URP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/URP_Blend_TwoSides") != null)
{
if (material.shader == Blend_TwoSides || material.shader == Blend_TwoSides_HDRP)
{
if (material.GetTexture("_MainTex") != null || material.GetTexture("_Noise") != null || material.HasProperty("_Cutoff"))
{
Vector2 MainScale = material.GetTextureScale("_MainTex");
Vector2 MainOffset = material.GetTextureOffset("_MainTex");
Vector2 NoiseScale = material.GetTextureScale("_Noise");
Vector2 NoiseOffset = material.GetTextureOffset("_Noise");
float Cutoff = material.GetFloat("_Cutoff");
material.shader = Blend_TwoSides_URP;
if (material.HasProperty("_MaskClipValue"))
material.SetFloat("_MaskClipValue", Cutoff);
if (material.HasProperty("_MainTexTiling"))
material.SetVector("_MainTexTiling", new Vector4(MainScale[0], MainScale[1], MainOffset[0], MainOffset[1]));
if (material.HasProperty("_NoiseTiling"))
material.SetVector("_NoiseTiling", new Vector4(NoiseScale[0], NoiseScale[1], NoiseOffset[0], NoiseOffset[1]));
}
else
material.shader = Blend_TwoSides_URP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/URP_Blend_Normals") != null)
{
if (material.shader == Blend_Normals || material.shader == Blend_Normals_HDRP)
{
if (material.GetTexture("_MainTex") != null || material.GetTexture("_Noise") != null)
{
Vector2 MainScale = material.GetTextureScale("_MainTex");
Vector2 MainOffset = material.GetTextureOffset("_MainTex");
Vector2 NoiseScale = material.GetTextureScale("_Noise");
Vector2 NoiseOffset = material.GetTextureOffset("_Noise");
material.shader = Blend_Normals_URP;
if (material.HasProperty("_MainTexTiling"))
material.SetVector("_MainTexTiling", new Vector4(MainScale[0], MainScale[1], MainOffset[0], MainOffset[1]));
if (material.HasProperty("_NoiseTiling"))
material.SetVector("_NoiseTiling", new Vector4(NoiseScale[0], NoiseScale[1], NoiseOffset[0], NoiseOffset[1]));
}
else
material.shader = Blend_Normals_URP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/URP_Ice") != null)
{
if (material.shader == Ice || material.shader == Ice_HDRP)
{
if (material.GetTexture("_MainTex") != null)
{
Vector2 MainScale = material.GetTextureScale("_MainTex");
Vector2 MainOffset = material.GetTextureOffset("_MainTex");
material.shader = Ice_URP;
if (material.HasProperty("_Tiling"))
material.SetVector("_Tiling", new Vector4(MainScale[0], MainScale[1], MainOffset[0], MainOffset[1]));
}
else
material.shader = Ice_URP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/URP_ParallaxIce") != null)
{
if (material.shader == ParallaxIce || material.shader == ParallaxIce_HDRP)
{
if (material.GetTexture("_Emission") != null)
{
Vector2 MainScale = material.GetTextureScale("_Emission");
Vector2 MainOffset = material.GetTextureOffset("_Emission");
material.shader = ParallaxIce_URP;
if (material.HasProperty("_EmissionTiling"))
material.SetVector("_EmissionTiling", new Vector4(MainScale[0], MainScale[1], MainOffset[0], MainOffset[1]));
}
else
material.shader = ParallaxIce_URP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/URP_Distortion") != null)
{
if (material.shader == Distortion || material.shader == Distortion_HDRP)
{
material.SetFloat("_ZWrite", 0);
material.shader = Distortion_URP;
material.renderQueue = 2750;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/URP_Add_CG") != null)
{
if (material.shader == Add_CG || material.shader == Add_CG_HDRP)
{
if (material.GetTexture("_MainTex") != null || material.GetTexture("_Noise") != null
|| material.GetTexture("_Flow") != null || material.GetTexture("_Mask") != null)
{
Vector2 MainScale = material.GetTextureScale("_MainTex");
Vector2 MainOffset = material.GetTextureOffset("_MainTex");
Vector2 NoiseScale = material.GetTextureScale("_Noise");
Vector2 NoiseOffset = material.GetTextureOffset("_Noise");
Vector2 FlowScale = material.GetTextureScale("_Flow");
Vector2 FlowOffset = material.GetTextureOffset("_Flow");
Vector2 MaskScale = material.GetTextureScale("_Mask");
Vector2 MaskOffset = material.GetTextureOffset("_Mask");
material.shader = Add_CG_URP;
if (material.HasProperty("_ZWrite")) material.SetFloat("_ZWrite", 0);
if (material.HasProperty("_MainTexTiling"))
material.SetVector("_MainTexTiling", new Vector4(MainScale[0], MainScale[1], MainOffset[0], MainOffset[1]));
if (material.HasProperty("_NoiseTiling"))
material.SetVector("_NoiseTiling", new Vector4(NoiseScale[0], NoiseScale[1], NoiseOffset[0], NoiseOffset[1]));
if (material.HasProperty("_FlowTiling"))
material.SetVector("_FlowTiling", new Vector4(FlowScale[0], FlowScale[1], FlowOffset[0], FlowOffset[1]));
if (material.HasProperty("_MaskTiling"))
material.SetVector("_MaskTiling", new Vector4(MaskScale[0], MaskScale[1], MaskOffset[0], MaskOffset[1]));
}
else
material.shader = Add_CG_URP;
Debug.Log("Shaders changed successfully");
}
}
else Debug.Log("First import shaders!");
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/URP_Blend_CG") != null)
{
if (material.shader == Blend_CG || material.shader == Blend_CG_HDRP)
{
if (material.GetTexture("_MainTex") != null || material.GetTexture("_Noise") != null
|| material.GetTexture("_Flow") != null || material.GetTexture("_Mask") != null)
{
Vector2 MainScale = material.GetTextureScale("_MainTex");
Vector2 MainOffset = material.GetTextureOffset("_MainTex");
Vector2 NoiseScale = material.GetTextureScale("_Noise");
Vector2 NoiseOffset = material.GetTextureOffset("_Noise");
Vector2 FlowScale = material.GetTextureScale("_Flow");
Vector2 FlowOffset = material.GetTextureOffset("_Flow");
Vector2 MaskScale = material.GetTextureScale("_Mask");
Vector2 MaskOffset = material.GetTextureOffset("_Mask");
material.shader = Blend_CG_URP;
if (material.HasProperty("_ZWrite")) material.SetFloat("_ZWrite", 0);
if (material.HasProperty("_MainTexTiling"))
material.SetVector("_MainTexTiling", new Vector4(MainScale[0], MainScale[1], MainOffset[0], MainOffset[1]));
if (material.HasProperty("_NoiseTiling"))
material.SetVector("_NoiseTiling", new Vector4(NoiseScale[0], NoiseScale[1], NoiseOffset[0], NoiseOffset[1]));
if (material.HasProperty("_FlowTiling"))
material.SetVector("_FlowTiling", new Vector4(FlowScale[0], FlowScale[1], FlowOffset[0], FlowOffset[1]));
if (material.HasProperty("_MaskTiling"))
material.SetVector("_MaskTiling", new Vector4(MaskScale[0], MaskScale[1], MaskOffset[0], MaskOffset[1]));
}
else
material.shader = Blend_CG_URP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/URP_BlendDistort") != null)
{
if (material.shader == BlendDistort || material.shader == BlendDistort_HDRP)
{
if (material.GetTexture("_MainTex") != null || material.GetTexture("_Noise") != null
|| material.GetTexture("_Flow") != null || material.GetTexture("_Mask") != null || material.GetTexture("_NormalMap") != null)
{
Vector2 MainScale = material.GetTextureScale("_MainTex");
Vector2 MainOffset = material.GetTextureOffset("_MainTex");
Vector2 NoiseScale = material.GetTextureScale("_Noise");
Vector2 NoiseOffset = material.GetTextureOffset("_Noise");
Vector2 FlowScale = material.GetTextureScale("_Flow");
Vector2 FlowOffset = material.GetTextureOffset("_Flow");
Vector2 MaskScale = material.GetTextureScale("_Mask");
Vector2 MaskOffset = material.GetTextureOffset("_Mask");
Vector2 NormalScale = material.GetTextureScale("_NormalMap");
Vector2 NormalOffset = material.GetTextureOffset("_NormalMap");
material.shader = BlendDistort_URP;
if (material.HasProperty("_ZWrite")) material.SetFloat("_ZWrite", 0);
if (material.HasProperty("_MainTexTiling"))
material.SetVector("_MainTexTiling", new Vector4(MainScale[0], MainScale[1], MainOffset[0], MainOffset[1]));
if (material.HasProperty("_NoiseTiling"))
material.SetVector("_NoiseTiling", new Vector4(NoiseScale[0], NoiseScale[1], NoiseOffset[0], NoiseOffset[1]));
if (material.HasProperty("_FlowTiling"))
material.SetVector("_FlowTiling", new Vector4(FlowScale[0], FlowScale[1], FlowOffset[0], FlowOffset[1]));
if (material.HasProperty("_MaskTiling"))
material.SetVector("_MaskTiling", new Vector4(MaskScale[0], MaskScale[1], MaskOffset[0], MaskOffset[1]));
if (material.HasProperty("_NormalMapTiling"))
material.SetVector("_NormalMapTiling", new Vector4(NormalScale[0], NormalScale[1], NormalOffset[0], NormalOffset[1]));
}
else
material.shader = BlendDistort_URP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/URP_VolumeLaser") != null)
{
if (material.shader == VolumeLaser || material.shader == VolumeLaser_HDRP)
{
material.shader = VolumeLaser_URP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/URP_Explosion") != null)
{
if (material.shader == Explosion || material.shader == Explosion_HDRP)
{
material.shader = Explosion_URP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/URP_SwordSlash") != null)
{
if (material.shader == SwordSlash || material.shader == SwordSlash_HDRP)
{
if (material.GetTexture("_MainTexture") != null || material.GetTexture("_EmissionTex") != null
|| material.GetTexture("_Dissolve") != null)
{
Vector2 MainScale = material.GetTextureScale("_MainTexture");
Vector2 MainOffset = material.GetTextureOffset("_MainTexture");
Vector2 EmissionTexScale = material.GetTextureScale("_EmissionTex");
Vector2 EmissionTexOffset = material.GetTextureOffset("_EmissionTex");
Vector2 DissolveScale = material.GetTextureScale("_Dissolve");
Vector2 DissolveOffset = material.GetTextureOffset("_Dissolve");
material.shader = SwordSlash_URP;
if (material.HasProperty("_ZWrite")) material.SetFloat("_ZWrite", 0);
if (material.HasProperty("_MainTextureTiling"))
material.SetVector("_MainTextureTiling", new Vector4(MainScale[0], MainScale[1], MainOffset[0], MainOffset[1]));
if (material.HasProperty("_EmissionTexTiling"))
material.SetVector("_EmissionTexTiling", new Vector4(EmissionTexScale[0], EmissionTexScale[1], EmissionTexOffset[0], EmissionTexOffset[1]));
if (material.HasProperty("_DissolveTiling"))
material.SetVector("_DissolveTiling", new Vector4(DissolveScale[0], DissolveScale[1], DissolveOffset[0], DissolveOffset[1]));
}
else
material.shader = SwordSlash_URP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/URP_ShockWave") != null)
{
if (material.shader == ShockWave || material.shader == ShockWave_HDRP)
{
if (material.GetTexture("_MainTexture") != null || material.GetTexture("_Noise") != null
|| material.GetTexture("_Flow") != null || material.GetTexture("_Mask") != null)
{
Vector2 MainScale = material.GetTextureScale("_MainTexture");
Vector2 MainOffset = material.GetTextureOffset("_MainTexture");
Vector2 NoiseScale = material.GetTextureScale("_Noise");
Vector2 NoiseOffset = material.GetTextureOffset("_Noise");
Vector2 FlowScale = material.GetTextureScale("_Flow");
Vector2 FlowOffset = material.GetTextureOffset("_Flow");
Vector2 MaskScale = material.GetTextureScale("_Mask");
Vector2 MaskOffset = material.GetTextureOffset("_Mask");
material.shader = ShockWave_URP;
if (material.HasProperty("_ZWrite")) material.SetFloat("_ZWrite", 0);
if (material.HasProperty("_MainTexTiling"))
material.SetVector("_MainTexTiling", new Vector4(MainScale[0], MainScale[1], MainOffset[0], MainOffset[1]));
if (material.HasProperty("_NoiseTiling"))
material.SetVector("_NoiseTiling", new Vector4(NoiseScale[0], NoiseScale[1], NoiseOffset[0], NoiseOffset[1]));
if (material.HasProperty("_FlowTiling"))
material.SetVector("_FlowTiling", new Vector4(FlowScale[0], FlowScale[1], FlowOffset[0], FlowOffset[1]));
if (material.HasProperty("_MaskTiling"))
material.SetVector("_MaskTiling", new Vector4(MaskScale[0], MaskScale[1], MaskOffset[0], MaskOffset[1]));
}
else
material.shader = ShockWave_URP;
}
}
}
}
private void ChangeToSRP()
{
foreach (var material in shaderMaterials)
{
if (Shader.Find("Hovl/Particles/LightGlow") != null)
{
if (material.shader == LightGlow_URP || material.shader == LightGlow_HDRP)
{
material.shader = LightGlow;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Hovl/Particles/Lit_CenterGlow") != null)
{
if (material.shader == Lit_CenterGlow_URP || material.shader == Lit_CenterGlow_HDRP)
{
material.shader = Lit_CenterGlow;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Hovl/Particles/Blend_TwoSides") != null)
{
if (material.shader == Blend_TwoSides_URP || material.shader == Blend_TwoSides_HDRP)
{
if (material.HasProperty("_MainTexTiling") && material.HasProperty("_NoiseTiling"))
{
Vector4 MainTiling = material.GetVector("_MainTexTiling");
Vector4 NoiseTiling = material.GetVector("_NoiseTiling");
material.shader = Blend_TwoSides;
if (material.GetTexture("_MainTex") != null && material.GetTexture("_Noise") != null)
{
material.SetTextureScale("_MainTex", new Vector2(MainTiling[0], MainTiling[1]));
material.SetTextureOffset("_MainTex", new Vector2(MainTiling[2], MainTiling[3]));
material.SetTextureScale("_Noise", new Vector2(NoiseTiling[0], NoiseTiling[1]));
material.SetTextureOffset("_Noise", new Vector2(NoiseTiling[2], NoiseTiling[3]));
}
}
else
material.shader = Blend_TwoSides;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Hovl/Particles/Blend_Normals") != null)
{
if (material.shader == Blend_Normals_URP || material.shader == Blend_Normals_HDRP)
{
if (material.HasProperty("_MainTexTiling") && material.HasProperty("_NoiseTiling"))
{
Vector4 MainTiling = material.GetVector("_MainTexTiling");
Vector4 NoiseTiling = material.GetVector("_NoiseTiling");
material.shader = Blend_Normals;
if (material.GetTexture("_MainTex") != null && material.GetTexture("_Noise") != null)
{
material.SetTextureScale("_MainTex", new Vector2(MainTiling[0], MainTiling[1]));
material.SetTextureOffset("_MainTex", new Vector2(MainTiling[2], MainTiling[3]));
material.SetTextureScale("_Noise", new Vector2(NoiseTiling[0], NoiseTiling[1]));
material.SetTextureOffset("_Noise", new Vector2(NoiseTiling[2], NoiseTiling[3]));
}
}
else
material.shader = Blend_Normals;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Hovl/Particles/Ice") != null)
{
if (material.shader == Ice_URP || material.shader == Ice_HDRP)
{
if (material.HasProperty("_Tiling"))
{
Vector4 MainTiling = material.GetVector("_Tiling");
material.shader = Ice;
if (material.GetTexture("_MainTex") != null)
{
material.SetTextureScale("_MainTex", new Vector2(MainTiling[0], MainTiling[1]));
material.SetTextureOffset("_MainTex", new Vector2(MainTiling[2], MainTiling[3]));
}
}
else
material.shader = Ice;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Hovl/Opaque/ParallaxIce") != null)
{
if (material.shader == ParallaxIce_URP || material.shader == ParallaxIce_HDRP)
{
if (material.HasProperty("_EmissionTiling"))
{
Vector4 MainTiling = material.GetVector("_EmissionTiling");
material.shader = ParallaxIce;
if (material.GetTexture("_Emission") != null)
{
material.SetTextureScale("_Emission", new Vector2(MainTiling[0], MainTiling[1]));
material.SetTextureOffset("_Emission", new Vector2(MainTiling[2], MainTiling[3]));
}
}
else
material.shader = ParallaxIce;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Hovl/Particles/Distortion") != null)
{
if (material.shader == Distortion_URP || material.shader == Distortion_HDRP)
{
material.shader = Distortion;
material.renderQueue = 2750;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Hovl/Particles/Add_CenterGlow") != null)
{
if (material.shader == Add_CG_URP || material.shader == Add_CG_HDRP)
{
if (material.HasProperty("_MainTexTiling") && material.HasProperty("_NoiseTiling")
&& material.HasProperty("_FlowTiling") && material.HasProperty("_MaskTiling"))
{
Vector4 MainTiling = material.GetVector("_MainTexTiling");
Vector4 NoiseTiling = material.GetVector("_NoiseTiling");
Vector4 FlowTiling = material.GetVector("_FlowTiling");
Vector4 MaskTiling = material.GetVector("_MaskTiling");
material.shader = Add_CG;
if (material.GetTexture("_MainTex") != null && material.GetTexture("_Noise") != null)
{
material.SetTextureScale("_MainTex", new Vector2(MainTiling[0], MainTiling[1]));
material.SetTextureOffset("_MainTex", new Vector2(MainTiling[2], MainTiling[3]));
material.SetTextureScale("_Noise", new Vector2(NoiseTiling[0], NoiseTiling[1]));
material.SetTextureOffset("_Noise", new Vector2(NoiseTiling[2], NoiseTiling[3]));
material.SetTextureScale("_Flow", new Vector2(FlowTiling[0], FlowTiling[1]));
material.SetTextureOffset("_Flow", new Vector2(FlowTiling[2], FlowTiling[3]));
material.SetTextureScale("_Mask", new Vector2(MaskTiling[0], MaskTiling[1]));
material.SetTextureOffset("_Mask", new Vector2(MaskTiling[2], MaskTiling[3]));
}
}
else
material.shader = Add_CG;
Debug.Log("Shaders changed successfully");
}
}
else Debug.Log("First import shaders!");
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Hovl/Particles/Blend_CenterGlow") != null)
{
if (material.shader == Blend_CG_URP || material.shader == Blend_CG_HDRP)
{
if (material.HasProperty("_MainTexTiling") && material.HasProperty("_NoiseTiling")
&& material.HasProperty("_FlowTiling") && material.HasProperty("_MaskTiling"))
{
Vector4 MainTiling = material.GetVector("_MainTexTiling");
Vector4 NoiseTiling = material.GetVector("_NoiseTiling");
Vector4 FlowTiling = material.GetVector("_FlowTiling");
Vector4 MaskTiling = material.GetVector("_MaskTiling");
material.shader = Blend_CG;
if (material.GetTexture("_MainTex") != null && material.GetTexture("_Noise") != null)
{
material.SetTextureScale("_MainTex", new Vector2(MainTiling[0], MainTiling[1]));
material.SetTextureOffset("_MainTex", new Vector2(MainTiling[2], MainTiling[3]));
material.SetTextureScale("_Noise", new Vector2(NoiseTiling[0], NoiseTiling[1]));
material.SetTextureOffset("_Noise", new Vector2(NoiseTiling[2], NoiseTiling[3]));
material.SetTextureScale("_Flow", new Vector2(FlowTiling[0], FlowTiling[1]));
material.SetTextureOffset("_Flow", new Vector2(FlowTiling[2], FlowTiling[3]));
material.SetTextureScale("_Mask", new Vector2(MaskTiling[0], MaskTiling[1]));
material.SetTextureOffset("_Mask", new Vector2(MaskTiling[2], MaskTiling[3]));
}
}
else
material.shader = Blend_CG;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Hovl/Particles/BlendDistort") != null)
{
if (material.shader == BlendDistort_URP || material.shader == BlendDistort_HDRP)
{
if (material.HasProperty("_MainTexTiling") && material.HasProperty("_NoiseTiling")
&& material.HasProperty("_FlowTiling") && material.HasProperty("_MaskTiling") && material.HasProperty("_NormalMapTiling"))
{
Vector4 MainTiling = material.GetVector("_MainTexTiling");
Vector4 NoiseTiling = material.GetVector("_NoiseTiling");
Vector4 FlowTiling = material.GetVector("_FlowTiling");
Vector4 MaskTiling = material.GetVector("_MaskTiling");
Vector4 NormalTiling = material.GetVector("_NormalMapTiling");
material.shader = BlendDistort;
if (material.GetTexture("_MainTex") != null && material.GetTexture("_Noise") != null)
{
material.SetTextureScale("_MainTex", new Vector2(MainTiling[0], MainTiling[1]));
material.SetTextureOffset("_MainTex", new Vector2(MainTiling[2], MainTiling[3]));
material.SetTextureScale("_Noise", new Vector2(NoiseTiling[0], NoiseTiling[1]));
material.SetTextureOffset("_Noise", new Vector2(NoiseTiling[2], NoiseTiling[3]));
material.SetTextureScale("_Flow", new Vector2(FlowTiling[0], FlowTiling[1]));
material.SetTextureOffset("_Flow", new Vector2(FlowTiling[2], FlowTiling[3]));
material.SetTextureScale("_Mask", new Vector2(MaskTiling[0], MaskTiling[1]));
material.SetTextureOffset("_Mask", new Vector2(MaskTiling[2], MaskTiling[3]));
material.SetTextureScale("_NormalMap", new Vector2(NormalTiling[0], NormalTiling[1]));
material.SetTextureOffset("_NormalMap", new Vector2(NormalTiling[2], NormalTiling[3]));
}
}
else
material.shader = BlendDistort;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Hovl/Particles/VolumeLaser") != null)
{
if (material.shader == VolumeLaser_URP || material.shader == VolumeLaser_HDRP)
{
material.shader = VolumeLaser;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Hovl/Particles/Explosion") != null)
{
if (material.shader == Explosion_URP || material.shader == Explosion_HDRP)
{
material.shader = Explosion;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Hovl/Particles/SwordSlash") != null)
{
if (material.shader == SwordSlash_URP || material.shader == SwordSlash_HDRP)
{
if (material.HasProperty("_MainTextureTiling") && material.HasProperty("_EmissionTexTiling") && material.HasProperty("_DissovleTiling"))
{
Vector4 MainTiling = material.GetVector("_MainTextureTiling");
Vector4 EmissionTiling = material.GetVector("_EmissionTexTiling");
Vector4 DissolveTiling = material.GetVector("_DissovleTiling");
material.shader = SwordSlash;
if (material.GetTexture("_MainTex") != null && material.GetTexture("_Noise") != null)
{
material.SetTextureScale("_MainTex", new Vector2(MainTiling[0], MainTiling[1]));
material.SetTextureOffset("_MainTex", new Vector2(MainTiling[2], MainTiling[3]));
material.SetTextureScale("_Noise", new Vector2(EmissionTiling[0], EmissionTiling[1]));
material.SetTextureOffset("_Noise", new Vector2(EmissionTiling[2], EmissionTiling[3]));
material.SetTextureScale("_Flow", new Vector2(DissolveTiling[0], DissolveTiling[1]));
material.SetTextureOffset("_Flow", new Vector2(DissolveTiling[2], DissolveTiling[3]));
}
}
else
material.shader = SwordSlash;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Hovl/Particles/ShockWave") != null)
{
if (material.shader == ShockWave_URP || material.shader == ShockWave_HDRP)
{
if (material.HasProperty("_MainTexTiling") && material.HasProperty("_NoiseTiling")
&& material.HasProperty("_FlowTiling") && material.HasProperty("_MaskTiling"))
{
Vector4 MainTiling = material.GetVector("_MainTexTiling");
Vector4 NoiseTiling = material.GetVector("_NoiseTiling");
Vector4 FlowTiling = material.GetVector("_FlowTiling");
Vector4 MaskTiling = material.GetVector("_MaskTiling");
material.shader = ShockWave;
if (material.GetTexture("_MainTexture") != null && material.GetTexture("_Noise") != null)
{
material.SetTextureScale("_MainTexture", new Vector2(MainTiling[0], MainTiling[1]));
material.SetTextureOffset("_MainTexture", new Vector2(MainTiling[2], MainTiling[3]));
material.SetTextureScale("_Noise", new Vector2(NoiseTiling[0], NoiseTiling[1]));
material.SetTextureOffset("_Noise", new Vector2(NoiseTiling[2], NoiseTiling[3]));
material.SetTextureScale("_Flow", new Vector2(FlowTiling[0], FlowTiling[1]));
material.SetTextureOffset("_Flow", new Vector2(FlowTiling[2], FlowTiling[3]));
material.SetTextureScale("_Mask", new Vector2(MaskTiling[0], MaskTiling[1]));
material.SetTextureOffset("_Mask", new Vector2(MaskTiling[2], MaskTiling[3]));
}
}
else
material.shader = ShockWave;
}
}
}
}
private void ChangeToHDRP()
{
foreach (var material in shaderMaterials)
{
if (Shader.Find("ERB/HDRP/Particles/LightGlow") != null)
{
if (material.shader == LightGlow || material.shader == LightGlow_URP)
{
material.shader = LightGlow_HDRP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/HDRP_Lit_CenterGlow") != null)
{
if (material.shader == Lit_CenterGlow || material.shader == Lit_CenterGlow_URP)
{
material.shader = Lit_CenterGlow_HDRP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/HDRP_Blend_TwoSides") != null)
{
if (material.shader == Blend_TwoSides || material.shader == Blend_TwoSides_URP)
{
if (material.GetTexture("_MainTex") != null || material.GetTexture("_Noise") != null)
{
Vector2 MainScale = material.GetTextureScale("_MainTex");
Vector2 MainOffset = material.GetTextureOffset("_MainTex");
Vector2 NoiseScale = material.GetTextureScale("_Noise");
Vector2 NoiseOffset = material.GetTextureOffset("_Noise");
material.shader = Blend_TwoSides_HDRP;
if (material.HasProperty("_MainTexTiling"))
material.SetVector("_MainTexTiling", new Vector4(MainScale[0], MainScale[1], MainOffset[0], MainOffset[1]));
if (material.HasProperty("_NoiseTiling"))
material.SetVector("_NoiseTiling", new Vector4(NoiseScale[0], NoiseScale[1], NoiseOffset[0], NoiseOffset[1]));
}
else
material.shader = Blend_TwoSides_HDRP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/HDRP_Blend_Normals") != null)
{
if (material.shader == Blend_Normals || material.shader == Blend_Normals_URP)
{
if (material.GetTexture("_MainTex") != null || material.GetTexture("_Noise") != null)
{
Vector2 MainScale = material.GetTextureScale("_MainTex");
Vector2 MainOffset = material.GetTextureOffset("_MainTex");
Vector2 NoiseScale = material.GetTextureScale("_Noise");
Vector2 NoiseOffset = material.GetTextureOffset("_Noise");
material.shader = Blend_Normals_HDRP;
if (material.HasProperty("_MainTexTiling"))
material.SetVector("_MainTexTiling", new Vector4(MainScale[0], MainScale[1], MainOffset[0], MainOffset[1]));
if (material.HasProperty("_NoiseTiling"))
material.SetVector("_NoiseTiling", new Vector4(NoiseScale[0], NoiseScale[1], NoiseOffset[0], NoiseOffset[1]));
}
else
material.shader = Blend_Normals_HDRP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/HDRP_Ice") != null)
{
if (material.shader == Ice || material.shader == Ice_URP)
{
if (material.GetTexture("_MainTex") != null)
{
Vector2 MainScale = material.GetTextureScale("_MainTex");
Vector2 MainOffset = material.GetTextureOffset("_MainTex");
material.shader = Ice_HDRP;
if (material.HasProperty("_Tiling"))
material.SetVector("_Tiling", new Vector4(MainScale[0], MainScale[1], MainOffset[0], MainOffset[1]));
}
else
material.shader = Ice_HDRP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/HDRP_ParallaxIce") != null)
{
if (material.shader == ParallaxIce || material.shader == ParallaxIce_URP)
{
if (material.GetTexture("_Emission") != null)
{
Vector2 MainScale = material.GetTextureScale("_Emission");
Vector2 MainOffset = material.GetTextureOffset("_Emission");
material.shader = ParallaxIce_HDRP;
if (material.HasProperty("_EmissionTiling"))
material.SetVector("_EmissionTiling", new Vector4(MainScale[0], MainScale[1], MainOffset[0], MainOffset[1]));
}
else
material.shader = ParallaxIce_HDRP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/HDRP_Distortion") != null)
{
if (material.shader == Distortion || material.shader == Distortion_URP)
{
material.SetFloat("_ZWrite", 0);
material.shader = Distortion_HDRP;
material.renderQueue = 2750;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/HDRP_Add_CG") != null)
{
if (material.shader == Add_CG || material.shader == Add_CG_URP)
{
if (material.GetTexture("_MainTex") != null || material.GetTexture("_Noise") != null
|| material.GetTexture("_Flow") != null || material.GetTexture("_Mask") != null)
{
Vector2 MainScale = material.GetTextureScale("_MainTex");
Vector2 MainOffset = material.GetTextureOffset("_MainTex");
Vector2 NoiseScale = material.GetTextureScale("_Noise");
Vector2 NoiseOffset = material.GetTextureOffset("_Noise");
Vector2 FlowScale = material.GetTextureScale("_Flow");
Vector2 FlowOffset = material.GetTextureOffset("_Flow");
Vector2 MaskScale = material.GetTextureScale("_Mask");
Vector2 MaskOffset = material.GetTextureOffset("_Mask");
material.SetFloat("_StencilRef", 0);
material.SetFloat("_AlphaDstBlend", 1);
material.SetFloat("_DstBlend", 1);
material.SetFloat("_ZWrite", 0);
material.SetFloat("_SrcBlend", 1);
material.EnableKeyword("_BLENDMODE_ADD _DOUBLESIDED_ON _SURFACE_TYPE_TRANSPARENT");
material.SetShaderPassEnabled("TransparentBackface", false);
material.SetOverrideTag("RenderType", "Transparent");
material.SetFloat("_CullModeForward", 0);
material.shader = Add_CG_HDRP;
if (material.HasProperty("_MainTexTiling"))
material.SetVector("_MainTexTiling", new Vector4(MainScale[0], MainScale[1], MainOffset[0], MainOffset[1]));
if (material.HasProperty("_NoiseTiling"))
material.SetVector("_NoiseTiling", new Vector4(NoiseScale[0], NoiseScale[1], NoiseOffset[0], NoiseOffset[1]));
if (material.HasProperty("_FlowTiling"))
material.SetVector("_FlowTiling", new Vector4(FlowScale[0], FlowScale[1], FlowOffset[0], FlowOffset[1]));
if (material.HasProperty("_MaskTiling"))
material.SetVector("_MaskTiling", new Vector4(MaskScale[0], MaskScale[1], MaskOffset[0], MaskOffset[1]));
}
else
material.shader = Add_CG_HDRP;
Debug.Log("Shaders changed successfully");
}
}
else Debug.Log("First import shaders!");
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/HDRP_Blend_CG") != null)
{
if (material.shader == Blend_CG || material.shader == Blend_CG_URP)
{
if (material.GetTexture("_MainTex") != null || material.GetTexture("_Noise") != null
|| material.GetTexture("_Flow") != null || material.GetTexture("_Mask") != null)
{
Vector2 MainScale = material.GetTextureScale("_MainTex");
Vector2 MainOffset = material.GetTextureOffset("_MainTex");
Vector2 NoiseScale = material.GetTextureScale("_Noise");
Vector2 NoiseOffset = material.GetTextureOffset("_Noise");
Vector2 FlowScale = material.GetTextureScale("_Flow");
Vector2 FlowOffset = material.GetTextureOffset("_Flow");
Vector2 MaskScale = material.GetTextureScale("_Mask");
Vector2 MaskOffset = material.GetTextureOffset("_Mask");
material.SetFloat("_ZWrite", 0);
material.SetFloat("_StencilRef", 0);
material.SetShaderPassEnabled("TransparentBackface", false);
material.SetOverrideTag("RenderType", "Transparent");
material.SetFloat("_AlphaDstBlend", 10);
material.SetFloat("_DstBlend", 10);
material.SetFloat("_SrcBlend", 1);
material.EnableKeyword("_BLENDMODE_ALPHA _DOUBLESIDED_ON _SURFACE_TYPE_TRANSPARENT");
if (material.HasProperty("_CullModeForward")) material.SetFloat("_CullModeForward", 0);
material.shader = Blend_CG_HDRP;
if (material.HasProperty("_MainTexTiling"))
material.SetVector("_MainTexTiling", new Vector4(MainScale[0], MainScale[1], MainOffset[0], MainOffset[1]));
if (material.HasProperty("_NoiseTiling"))
material.SetVector("_NoiseTiling", new Vector4(NoiseScale[0], NoiseScale[1], NoiseOffset[0], NoiseOffset[1]));
if (material.HasProperty("_FlowTiling"))
material.SetVector("_FlowTiling", new Vector4(FlowScale[0], FlowScale[1], FlowOffset[0], FlowOffset[1]));
if (material.HasProperty("_MaskTiling"))
material.SetVector("_MaskTiling", new Vector4(MaskScale[0], MaskScale[1], MaskOffset[0], MaskOffset[1]));
}
else
material.shader = Blend_CG_HDRP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/HDRP_BlendDistort") != null)
{
if (material.shader == BlendDistort || material.shader == BlendDistort_URP)
{
if (material.GetTexture("_MainTex") != null || material.GetTexture("_Noise") != null
|| material.GetTexture("_Flow") != null || material.GetTexture("_Mask") != null || material.GetTexture("_NormalMap") != null)
{
Vector2 MainScale = material.GetTextureScale("_MainTex");
Vector2 MainOffset = material.GetTextureOffset("_MainTex");
Vector2 NoiseScale = material.GetTextureScale("_Noise");
Vector2 NoiseOffset = material.GetTextureOffset("_Noise");
Vector2 FlowScale = material.GetTextureScale("_Flow");
Vector2 FlowOffset = material.GetTextureOffset("_Flow");
Vector2 MaskScale = material.GetTextureScale("_Mask");
Vector2 MaskOffset = material.GetTextureOffset("_Mask");
Vector2 NormalScale = material.GetTextureScale("_NormalMap");
Vector2 NormalOffset = material.GetTextureOffset("_NormalMap");
material.shader = BlendDistort_HDRP;
if (material.HasProperty("_ZWrite")) material.SetFloat("_ZWrite", 0);
if (material.HasProperty("_MainTexTiling"))
material.SetVector("_MainTexTiling", new Vector4(MainScale[0], MainScale[1], MainOffset[0], MainOffset[1]));
if (material.HasProperty("_NoiseTiling"))
material.SetVector("_NoiseTiling", new Vector4(NoiseScale[0], NoiseScale[1], NoiseOffset[0], NoiseOffset[1]));
if (material.HasProperty("_FlowTiling"))
material.SetVector("_FlowTiling", new Vector4(FlowScale[0], FlowScale[1], FlowOffset[0], FlowOffset[1]));
if (material.HasProperty("_MaskTiling"))
material.SetVector("_MaskTiling", new Vector4(MaskScale[0], MaskScale[1], MaskOffset[0], MaskOffset[1]));
if (material.HasProperty("_NormalMapTiling"))
material.SetVector("_NormalMapTiling", new Vector4(NormalScale[0], NormalScale[1], NormalOffset[0], NormalOffset[1]));
}
else
material.shader = BlendDistort_HDRP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/HDRP_VolumeLaser") != null)
{
if (material.shader == VolumeLaser || material.shader == VolumeLaser_URP)
{
material.shader = VolumeLaser_HDRP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/HDRP_Explosion") != null)
{
if (material.shader == Explosion || material.shader == Explosion_URP)
{
material.SetFloat("_StencilRef", 0);
material.SetFloat("_AlphaDstBlend", 1);
material.SetFloat("_DstBlend", 1);
material.SetFloat("_ZWrite", 0);
material.SetFloat("_SrcBlend", 1);
material.EnableKeyword("_BLENDMODE_ADD _DOUBLESIDED_ON _SURFACE_TYPE_TRANSPARENT");
material.SetShaderPassEnabled("TransparentBackface", false);
material.SetOverrideTag("RenderType", "Transparent");
material.SetFloat("_CullModeForward", 0);
material.shader = Explosion_HDRP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/HDRP_SwordSlash") != null)
{
if (material.shader == SwordSlash || material.shader == SwordSlash_URP)
{
if (material.GetTexture("_MainTexture") != null || material.GetTexture("_EmissionTex") != null
|| material.GetTexture("_Dissolve") != null)
{
Vector2 MainScale = material.GetTextureScale("_MainTexture");
Vector2 MainOffset = material.GetTextureOffset("_MainTexture");
Vector2 EmissionTexScale = material.GetTextureScale("_EmissionTex");
Vector2 EmissionTexOffset = material.GetTextureOffset("_EmissionTex");
Vector2 DissolveScale = material.GetTextureScale("_Dissolve");
Vector2 DissolveOffset = material.GetTextureOffset("_Dissolve");
material.SetFloat("_ZWrite", 0);
material.SetFloat("_StencilRef", 0);
material.SetShaderPassEnabled("TransparentBackface", false);
material.SetOverrideTag("RenderType", "Transparent");
material.SetFloat("_AlphaDstBlend", 10);
material.SetFloat("_DstBlend", 10);
material.SetFloat("_SrcBlend", 1);
material.EnableKeyword("_BLENDMODE_ALPHA _DOUBLESIDED_ON _SURFACE_TYPE_TRANSPARENT");
material.shader = SwordSlash_HDRP;
if (material.HasProperty("_ZWrite")) material.SetFloat("_ZWrite", 0);
if (material.HasProperty("_MainTextureTiling"))
material.SetVector("_MainTextureTiling", new Vector4(MainScale[0], MainScale[1], MainOffset[0], MainOffset[1]));
if (material.HasProperty("_EmissionTexTiling"))
material.SetVector("_EmissionTexTiling", new Vector4(EmissionTexScale[0], EmissionTexScale[1], EmissionTexOffset[0], EmissionTexOffset[1]));
if (material.HasProperty("_DissolveTiling"))
material.SetVector("_DissolveTiling", new Vector4(DissolveScale[0], DissolveScale[1], DissolveOffset[0], DissolveOffset[1]));
}
else
material.shader = SwordSlash_HDRP;
}
}
/*----------------------------------------------------------------------------------------------------*/
if (Shader.Find("Shader Graphs/HDRP_ShockWave") != null)
{
if (material.shader == ShockWave || material.shader == ShockWave_URP)
{
if (material.GetTexture("_MainTexture") != null || material.GetTexture("_Noise") != null
|| material.GetTexture("_Flow") != null || material.GetTexture("_Mask") != null)
{
Vector2 MainScale = material.GetTextureScale("_MainTexture");
Vector2 MainOffset = material.GetTextureOffset("_MainTexture");
Vector2 NoiseScale = material.GetTextureScale("_Noise");
Vector2 NoiseOffset = material.GetTextureOffset("_Noise");
Vector2 FlowScale = material.GetTextureScale("_Flow");
Vector2 FlowOffset = material.GetTextureOffset("_Flow");
Vector2 MaskScale = material.GetTextureScale("_Mask");
Vector2 MaskOffset = material.GetTextureOffset("_Mask");
material.SetFloat("_StencilRef", 0);
material.SetFloat("_AlphaDstBlend", 1);
material.SetFloat("_DstBlend", 1);
material.SetFloat("_ZWrite", 0);
material.SetFloat("_SrcBlend", 1);
material.EnableKeyword("_BLENDMODE_ADD _DOUBLESIDED_ON _SURFACE_TYPE_TRANSPARENT");
material.SetShaderPassEnabled("TransparentBackface", false);
material.SetOverrideTag("RenderType", "Transparent");
material.SetFloat("_CullModeForward", 0);
material.shader = ShockWave_HDRP;
if (material.HasProperty("_MainTexTiling"))
material.SetVector("_MainTexTiling", new Vector4(MainScale[0], MainScale[1], MainOffset[0], MainOffset[1]));
if (material.HasProperty("_NoiseTiling"))
material.SetVector("_NoiseTiling", new Vector4(NoiseScale[0], NoiseScale[1], NoiseOffset[0], NoiseOffset[1]));
if (material.HasProperty("_FlowTiling"))
material.SetVector("_FlowTiling", new Vector4(FlowScale[0], FlowScale[1], FlowOffset[0], FlowOffset[1]));
if (material.HasProperty("_MaskTiling"))
material.SetVector("_MaskTiling", new Vector4(MaskScale[0], MaskScale[1], MaskOffset[0], MaskOffset[1]));
}
else
material.shader = ShockWave_HDRP;
}
}
}
}
}
#endif
Reference in New Issue Copy Permalink