Soullies/ichni_Official
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
56cee0cf010ac0e48d906002c01b4a31a5ed6e69
ichni_Official/Packages/NBShaders/Editor/ParticleBaseGUI.cs

2834 lines
146 KiB
C#
Raw Normal View History

perf
2025-07-21 05:42:20 -04:00
using System;
using System.Linq;
using System.Collections.Generic;
using UnityEditorInternal;
using UnityEngine;
using UnityEngine.Rendering;
using stencilTestHelper;
using UnityEditor.AnimatedValues;
111
2025-08-27 21:45:18 -04:00
using System.Reflection;
using UnityEditor;
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
namespace NBShaderEditor
perf
2025-07-21 05:42:20 -04:00
{
public class ParticleBaseGUI : ShaderGUI
{
111
2025-08-27 21:45:18 -04:00
private ShaderGUIHelper _helper = new ShaderGUIHelper();
perf
2025-07-21 05:42:20 -04:00
public List<Material> mats = new List<Material>();
private Shader shader;
private MaterialEditor matEditor;
public List<W9ParticleShaderFlags> shaderFlags = new List<W9ParticleShaderFlags>();
private int lastFlagBit;
111
2025-08-27 21:45:18 -04:00
// private bool isCustomedStencil = false;//isCustomStencil应该各个材质各自控制。
private readonly int _isCustomedStencilPropID = Shader.PropertyToID("_CustomStencilTest");
private readonly string _defaultStencilKey = "ParticleBaseDefault";
perf
2025-07-21 05:42:20 -04:00
private StencilValuesConfig _stencilValuesConfig;
111
2025-08-27 21:45:18 -04:00
private bool isInit = true;
perf
2025-07-21 05:42:20 -04:00
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
{
//一定要初始化在第一行
mats.Clear();
shaderFlags.Clear();
for (int i = 0; i < materialEditor.targets.Length; i++)
{
111
2025-08-27 21:45:18 -04:00
var targetMat = materialEditor.targets[i] as Material;
mats.Add(targetMat);
perf
2025-07-21 05:42:20 -04:00
shaderFlags.Add(new W9ParticleShaderFlags(mats[i]));
111
2025-08-27 21:45:18 -04:00
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
perf
2025-07-21 05:42:20 -04:00
if (!_stencilValuesConfig)
{
111
2025-08-27 21:45:18 -04:00
_stencilValuesConfig =
AssetDatabase.LoadAssetAtPath<StencilValuesConfig>(
"Packages/com.xuanxuan.nb.shaders/Shader/StencilConfig.asset");
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
perf
2025-07-21 05:42:20 -04:00
matEditor = materialEditor;
111
2025-08-27 21:45:18 -04:00
EditorGUIUtility.labelWidth = 180f;
_helper.Init(materialEditor, props, shaderFlags.ToArray(), mats);
if (isInit)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
CacheRenderersUsingThisMaterial(mats[0],0);
isInit = false;
}
_helper.DrawToolBar();
EditorGUI.BeginChangeCheck();
_helper.DrawBigBlockFoldOut(W9ParticleShaderFlags.foldOutBitMeshOption, 3, GetAnimBoolIndex(3), "模式设置",
() => DrawMeshOptions(),false);
_helper.DrawBigBlockFoldOut(W9ParticleShaderFlags.foldOutBitBaseOption, 3, GetAnimBoolIndex(3), "基本全局功能",
() => DrawBaseOptions(),false);
_helper.DrawBigBlockFoldOut(W9ParticleShaderFlags.foldOutBitMainTexOption, 3, GetAnimBoolIndex(3), "主贴图功能",
() => DrawMainTexOptions());
if (_uiEffectEnabled == 0)
{
_helper.DrawBigBlockFoldOut(W9ParticleShaderFlags.foldOutBit1LightOption, 4, GetAnimBoolIndex(4),
"光照功能", () => DrawLightOptions());
}
_helper.DrawBigBlockFoldOut(W9ParticleShaderFlags.foldOutBitFeatureOption, 3, GetAnimBoolIndex(3), "特别功能",
() => DrawFeatureOptions());
_helper.DrawBigBlockFoldOut(W9ParticleShaderFlags.foldOutBit1TaOption, 4, GetAnimBoolIndex(4), "TA调试",
() => DrawTaOptions());
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
EditorGUIUtility.labelWidth = 0f;
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
if (mats.Count == 1)
{
if (_meshSourceMode == MeshSourceMode.Particle || _meshSourceMode == MeshSourceMode.UIParticle)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
DoVertexStreamsArea(mats[0], m_ParticleRenderersUsingThisMaterial, 0); //填充stream和stremList
mats[0].EnableKeyword("_CUSTOMDATA");
perf
2025-07-21 05:42:20 -04:00
}
else
{
mats[0].DisableKeyword("_CUSTOMDATA");
}
}
111
2025-08-27 21:45:18 -04:00
if (EditorGUI.EndChangeCheck())
{
CacheRenderersUsingThisMaterial(mats[0], 0);
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
DoAfterDraw();
//多选状态下同步ShaderFlag
if (mats.Count > 1)
{
for (int i = 1; i < mats.Count; i++)
{
mats[i].SetInteger(W9ParticleShaderFlags.foldOutFlagId,
mats[0].GetInteger(W9ParticleShaderFlags.foldOutFlagId));
mats[i].SetInteger(W9ParticleShaderFlags.foldOutFlagId1,
mats[0].GetInteger(W9ParticleShaderFlags.foldOutFlagId1));
mats[i].SetInteger(W9ParticleShaderFlags.foldOutFlagId2,
mats[0].GetInteger(W9ParticleShaderFlags.foldOutFlagId2));
}
}
}
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
int _uiEffectEnabled = -1; //0 false,1 true,-1 unKnow | MixedValue
int _meshSourceModeIsParticle = -1; //Particle Or UI Particle;
private int _useGraphicMainTex = -1; //UI Sprite/UI RawImage
int _noiseEnabled = -1; //扭曲
private MeshSourceMode _meshSourceMode = MeshSourceMode.UnKnowOrMixed;
private TransparentMode _transparentMode = TransparentMode.UnKnowOrMixed;
perf
2025-07-21 05:42:20 -04:00
public void DrawMeshOptions()
{
111
2025-08-27 21:45:18 -04:00
_helper.DrawPopUp("Mesh来源模式", "_MeshSourceMode", _meshSourceModeNames, drawBlock: modeProp =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
if (!modeProp.hasMixedValue)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_meshSourceMode = (MeshSourceMode)modeProp.floatValue;
perf
2025-07-21 05:42:20 -04:00
}
else
{
111
2025-08-27 21:45:18 -04:00
_meshSourceMode = MeshSourceMode.UnKnowOrMixed;
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
for (int i = 0; i < mats.Count; i++)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
MeshSourceMode mode = (MeshSourceMode)mats[i].GetFloat("_MeshSourceMode");
int uiEffectEnabled;
int meshSourceModeIsParticle;
int useGraphicMainTex;
if (mode == MeshSourceMode.UIEffectRawImage || mode == MeshSourceMode.UIEffectSprite ||
mode == MeshSourceMode.UIEffectBaseMap || mode == MeshSourceMode.UIParticle)
{
uiEffectEnabled = 1;
}
else
{
uiEffectEnabled = 0;
}
if (mode == MeshSourceMode.Particle || mode == MeshSourceMode.UIParticle)
{
meshSourceModeIsParticle = 1;
}
else
{
meshSourceModeIsParticle = 0;
}
if (mode == MeshSourceMode.UIEffectSprite || mode == MeshSourceMode.UIEffectRawImage)
{
useGraphicMainTex = 1;
}
else
{
useGraphicMainTex = 0;
}
if (i == 0)
{
_uiEffectEnabled = uiEffectEnabled;
_meshSourceModeIsParticle = meshSourceModeIsParticle;
_useGraphicMainTex = useGraphicMainTex;
}
else
{
if (_uiEffectEnabled != uiEffectEnabled)
{
_uiEffectEnabled = -1;
}
if (_meshSourceModeIsParticle != meshSourceModeIsParticle)
{
_meshSourceModeIsParticle = -1;
}
if (_useGraphicMainTex != useGraphicMainTex)
{
_useGraphicMainTex = -1;
}
}
perf
2025-07-21 05:42:20 -04:00
}
if (checkIsParicleSystem)
{
111
2025-08-27 21:45:18 -04:00
if (_meshSourceModeIsParticle <= 0)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
EditorGUILayout.HelpBox("检测到材质用在粒子系统上，和设置不匹配", MessageType.Error);
perf
2025-07-21 05:42:20 -04:00
}
}
else
{
//这个不能Log，因为在Project面板下打开是不知道在不在粒子系统里的。
// if (_meshSourceMode == MeshSourceMode.Particle)
// {
// EditorGUILayout.HelpBox("检测到材质没有用在粒子系统上，和设置不匹配",MessageType.Error);
// }
}
});
111
2025-08-27 21:45:18 -04:00
_helper.DrawPopUp("透明模式", "_TransparentMode", transparentModeNames, drawBlock: transModeProp =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
if (!transModeProp.hasMixedValue)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_transparentMode = (TransparentMode)mats[0].GetFloat("_TransparentMode");
if (_transparentMode == TransparentMode.CutOff)
{
matEditor.ShaderProperty(_helper.GetProperty("_Cutoff"), "裁剪位置");
}
if (_transparentMode == TransparentMode.Transparent)
{
_helper.DrawPopUp("混合模式", "_Blend", blendModeNames, drawBlock: blendProp =>
{
if (!blendProp.hasMixedValue)
{
BlendMode blendMode = (BlendMode)blendProp.floatValue;
if (blendMode == BlendMode.Premultiply || blendMode == BlendMode.Additive||_helper.ResetTool.IsInitResetData)
{
_helper.DrawSlider("叠加到预乘混合","_AdditiveToPreMultiplyAlphaLerp",0,1);
}
}
},drawOnValueChangedBlock: blendProp => {
BlendMode blendMode = (BlendMode)blendProp.floatValue;
MaterialProperty addToPreMultiplyAlphaLerpProp =
_helper.GetProperty("_AdditiveToPreMultiplyAlphaLerp");
if (blendMode == BlendMode.Premultiply)
{
addToPreMultiplyAlphaLerpProp.floatValue = 1;
}
else if (blendMode == BlendMode.Additive)
{
addToPreMultiplyAlphaLerpProp.floatValue = 0;
}
});
}
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
else
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_transparentMode = TransparentMode.UnKnowOrMixed;
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
});
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
public void DrawBaseOptions()
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_helper.DrawFloat("整体颜色强度", "_BaseColorIntensityForTimeline");
_helper.DrawSlider("整体透明度", "_AlphaAll", rangePropertyName:"AlphaAllRangeVec");
if (_uiEffectEnabled == 0)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_helper.DrawPopUp("深度测试", "_ZTest", Enum.GetNames(typeof(CompareFunction)));
}
else if (_uiEffectEnabled == 1)
{
_helper.GetProperty("_ZTest").floatValue = 4.0f; //UI层使用默认值LessEqual
}
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
// _helper.DrawPopUp("时间模式","_TimeMode",Enum.GetNames(typeof(TimeMode)));
_helper.DrawPopUp("渲染面向", "_Cull", Enum.GetNames(typeof(RenderFace)));
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
if (_uiEffectEnabled == 0)
{
if (_transparentMode == TransparentMode.Transparent)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggle("预渲染反面", "_BackFirstPassToggle", drawBlock: (isToggle) =>
{
if (!isToggle.hasMixedValue)
{
bool isBackFirstPass = isToggle.floatValue > 0.5f;
for (int i = 0; i < mats.Count; i++)
{
mats[i].SetShaderPassEnabled("SRPDefaultUnlit", isToggle.floatValue > 0.5f);
if (isBackFirstPass)
{
mats[i].SetFloat("_Cull", (float)RenderFace.Front);
}
}
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
if (isBackFirstPass)
{
EditorGUILayout.HelpBox("预渲染反面会导致打断动态合批，请谨慎使用。", MessageType.Warning);
}
}
});
}
_helper.DrawPopUp("深度写入强制控制", "_ForceZWriteToggle",_ForceZWriteToggleNames);
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBit2BaseBackColor,5,GetAnimBoolIndex(5),"背面颜色", "_BaseBackColor_Toggle", W9ParticleShaderFlags.FLAG_BIT_PARTICLE_BACKCOLOR,
drawBlock:
perf
2025-07-21 05:42:20 -04:00
(isToggle) =>
{
111
2025-08-27 21:45:18 -04:00
// matEditor.ColorProperty(_helper.GetProperty("_BaseBackColor"), "");
_helper.ColorProperty("背面颜色","_BaseBackColor");
perf
2025-07-21 05:42:20 -04:00
});
111
2025-08-27 21:45:18 -04:00
}
if (_uiEffectEnabled == 0)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBitDistanceFade, 3, GetAnimBoolIndex(3), "近距离透明",
"_DistanceFade_Toggle", W9ParticleShaderFlags.FLAG_BIT_PARTICLE_DISTANCEFADE_ON,
isIndentBlock: true, drawBlock: (isToggle) =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_helper.DrawVector4In2Line("_Fade", "透明过度范围", true);
perf
2025-07-21 05:42:20 -04:00
});
}
else
{
111
2025-08-27 21:45:18 -04:00
for (int i = 0; i < mats.Count; i++)
{
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_DISTANCEFADE_ON);
}
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
if (_uiEffectEnabled == 0)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBitSoftParticles, 3, GetAnimBoolIndex(3), "软粒子",
"_SoftParticlesEnabled", shaderKeyword: "_SOFTPARTICLES_ON", isIndentBlock: true, drawBlock:
(isToggle) =>
{
_helper.DrawVector4In2Line("_SoftParticleFadeParams", "远近裁剪面", true);
});
_helper.DrawToggle("剔除主角色", "_StencilWithoutPlayerToggle", shaderKeyword: "_STENCIL_WITHOUT_PLAYER",
drawEndChangeCheck: isToggle =>
{
if (!isToggle.hasMixedValue)
{
for (int i = 0; i < mats.Count; i++)
{
if (isToggle.floatValue > 0.5f)
{
StencilTestHelper.SetMaterialStencil(mats[i], "ParticleWithoutPlayer",
_stencilValuesConfig, out int queue);
mats[i].SetFloat(_isCustomedStencilPropID, 1.0f);
}
else
{
StencilTestHelper.SetMaterialStencil(mats[i], _defaultStencilKey,
_stencilValuesConfig, out int queue);
mats[i].SetFloat(_isCustomedStencilPropID, 0.0f);
}
}
}
});
_helper.DrawToggle("忽略顶点色", "_IgnoreVetexColor_Toggle",
W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_IGNORE_VERTEX_COLOR, flagIndex: 1);
_helper.DrawSlider("雾影响强度", "_fogintensity", 0f, 1f);
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
else if (_uiEffectEnabled == 1)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_helper.GetProperty("_fogintensity").floatValue = 0;
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
}
public void DrawMainTexOptions()
{
Action drawAfterMainTex = () =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
DrawColorChannelSelect("主贴图透明度通道", W9ParticleShaderFlags.FLAG_BIT_COLOR_CHANNEL_POS_0_MAINTEX_ALPHA,3);
if (_meshSourceMode != MeshSourceMode.UIEffectSprite)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
MaterialProperty textureProp = null;
if (_meshSourceMode == MeshSourceMode.UIEffectRawImage)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
textureProp = _helper.GetProperty("_MainTex");
}
else
{
textureProp = _helper.GetProperty("_BaseMap");
}
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
DrawUVModeSelect(W9ParticleShaderFlags.foldOutBit1UVModeMainTex, 4, "主贴图UV来源",
W9ParticleShaderFlags.FLAG_BIT_UVMODE_POS_0_MAINTEX, 0, textureProp: textureProp);
}
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
DrawCustomDataSelect("主贴图X轴偏移自定义曲线", W9ParticleShaderFlags.FLAGBIT_POS_0_CUSTOMDATA_MAINTEX_OFFSET_X,
0);
DrawCustomDataSelect("主贴图Y轴偏移自定义曲线", W9ParticleShaderFlags.FLAGBIT_POS_0_CUSTOMDATA_MAINTEX_OFFSET_Y,
0);
if (_meshSourceMode != MeshSourceMode.UIEffectSprite)
{
_helper.DrawVector4In2Line("_BaseMapMaskMapOffset", "偏移速度", true);
_helper.DrawSlider("主贴图旋转", "_BaseMapUVRotation", 0f, 360f);
_helper.DrawFloat("主贴图旋转速度","_BaseMapUVRotationSpeed");
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
DrawNoiseAffectBlock(() =>
{
_helper.DrawSlider("主贴图扭曲强度控制", "_TexDistortion_intensity",rangePropertyName: "TexDistortionintensityRangeVec");
});
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBitHueShift, 3, GetAnimBoolIndex(3), "主贴图色相偏移",
"_HueShift_Toggle", W9ParticleShaderFlags.FLAG_BIT_HUESHIFT_ON, isIndentBlock: true,
drawBlock: (isToggle) =>
{
_helper.DrawSlider("色相", "_HueShift", 0, 1);
DrawCustomDataSelect("色相自定义曲线", W9ParticleShaderFlags.FLAGBIT_POS_0_CUSTOMDATA_HUESHIFT, 0);
});
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBitSaturability, 3, GetAnimBoolIndex(3),
"主贴图饱和度", "_ChangeSaturability_Toggle", W9ParticleShaderFlags.FLAG_BIT_SATURABILITY_ON,
isIndentBlock: true, drawBlock: (isToggle) =>
{
_helper.DrawSlider("饱和度", "_Saturability", rangePropertyName:"SaturabilityRangeVec");
DrawCustomDataSelect("饱和度强度自定义曲线", W9ParticleShaderFlags.FLAGBIT_POS_1_CUSTOMDATA_SATURATE, 1);
});
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBit1MianTexContrast, 4, GetAnimBoolIndex(4),
"主贴图对比度", "_Contrast_Toggle", W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_MAINTEX_CONTRAST, 1,
isIndentBlock: true, drawBlock: (isToggle) =>
{
matEditor.ShaderProperty(_helper.GetProperty("_ContrastMidColor"), "对比度中值颜色");
_helper.DrawSlider("对比度", "_Contrast", 0, 5);
DrawCustomDataSelect("对比度自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_2_CUSTOMDATA_MAINTEX_CONTRAST, 2);
});
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBit1MainTexColorRefine, 4, GetAnimBoolIndex(4),
"主贴图颜色修正", "_BaseMapColorRefine_Toggle",
W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_MAINTEX_COLOR_REFINE, 1, isIndentBlock: true, drawBlock:
perf
2025-07-21 05:42:20 -04:00
(isToggle) =>
{
111
2025-08-27 21:45:18 -04:00
_helper.DrawVector4Component("A:主颜色相乘", "_BaseMapColorRefine", "x", false);
_helper.DrawVector4Component("B:主颜色Power", "_BaseMapColorRefine", "y", false);
_helper.DrawVector4Component("B:主颜色Power后相乘", "_BaseMapColorRefine", "z", false);
_helper.DrawVector4Component("A/B线性差值", "_BaseMapColorRefine", "w", true, 0f, 1f);
perf
2025-07-21 05:42:20 -04:00
});
111
2025-08-27 21:45:18 -04:00
};
Action drawBaseMapFoldOut = () => {
_helper.DrawTextureFoldOut(W9ParticleShaderFlags.foldOutBitBaseMap, 3, GetAnimBoolIndex(3), "主贴图",
"_BaseMap", "_BaseColor", drawWrapMode: true,
flagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_BASEMAP, flagIndex: 2, drawBlock:
theBaseMap =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
drawAfterMainTex();
});};
Action drawUITextureModify = () =>
{
_helper.ColorProperty( "贴图颜色叠加","_Color");
_helper.DrawVector4In2Line("_UI_MainTex_ST", "Tilling", true);
_helper.DrawVector4In2Line("_UI_MainTex_ST", "Offset", false);
drawAfterMainTex();
};
if (_helper.ResetTool.IsInitResetData)
{
drawBaseMapFoldOut();
drawUITextureModify();
perf
2025-07-21 05:42:20 -04:00
}
else
{
111
2025-08-27 21:45:18 -04:00
if (_useGraphicMainTex <= 0)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
drawBaseMapFoldOut();
// _helper.DrawTexture("主贴图","_BaseMap","_BaseColor",drawWrapMode:true,flagBitsName:W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_BASEMAP,flagIndex:2);
}
else
{
drawUITextureModify();
//实际上贴图来自_MainTex
perf
2025-07-21 05:42:20 -04:00
}
}
111
2025-08-27 21:45:18 -04:00
}
public Gradient rampColorGradient = null;
private MaterialProperty[] rampColorPropArr = new MaterialProperty[6];
private MaterialProperty[] rampColorAlphaPropArr = new MaterialProperty[3];
public Gradient maskMapGradient = null;
public Gradient maskMap2Gradient = null;
public Gradient maskMap3Gradient = null;
private MaterialProperty[] maskMapGradientPropArr = new MaterialProperty[3];
private MaterialProperty[] maskMap2GradientPropArr = new MaterialProperty[3];
private MaterialProperty[] maskMap3GradientPropArr = new MaterialProperty[3];
public Gradient dissolveRampGradient = null;
private MaterialProperty[] dissolveRampColorPropArr = new MaterialProperty[6];
private MaterialProperty[] dissolveRampAlphaPropArr = new MaterialProperty[3];
private FxLightMode _fxLightMode;
public void DrawLightOptions()
{
_helper.DrawPopUp("光照类型", "_FxLightMode", _fxLightModeNames, drawBlock: mode =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
if (!mode.hasMixedValue)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_fxLightMode = (FxLightMode)mode.floatValue;
if (_fxLightMode == FxLightMode.BlinnPhong || _fxLightMode == FxLightMode.PBR ||
_fxLightMode == FxLightMode.HalfLambert)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
if (_fxLightMode == FxLightMode.BlinnPhong || _fxLightMode == FxLightMode.HalfLambert)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggle("高光开关", "_BlinnPhongSpecularToggle", shaderKeyword: "_SPECULAR_COLOR",
drawBlock:
isToggle =>
{
if ((!isToggle.hasMixedValue && isToggle.floatValue > 0.5f)||_helper.ResetTool.IsInitResetData)
{
_helper.ColorProperty("高光颜色","_SpecularColor");
_helper.DrawVector4Component("光滑度", "_MaterialInfo", "y", true, 0, 1);
}
});
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
if (_fxLightMode == FxLightMode.PBR)
{
_helper.DrawVector4Component("金属度", "_MaterialInfo", "x", true, 0, 1);
_helper.DrawVector4Component("光滑度", "_MaterialInfo", "y", true, 0, 1);
}
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
else if (_fxLightMode == FxLightMode.SixWay)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_helper.DrawTexture("六路正方向图(P)", "_RigRTBk", drawScaleOffset: false);
_helper.DrawTexture("六路反方向图(N)", "_RigLBtF", drawScaleOffset: false);
EditorGUILayout.HelpBox("六路UV跟随主贴图UV及颜色", MessageType.Warning);
_helper.DrawToggle("光照颜色吸收", "_SixWayColorAbsorptionToggle",
shaderKeyword: "VFX_SIX_WAY_ABSORPTION", drawBlock:
isAbsorption =>
{
_helper.DrawVector4Component("六路吸收强度", "_SixWayInfo", "x", true, 0, 1);
});
_helper.DrawTexture("六路自发光Ramp", "_SixWayEmissionRamp", drawScaleOffset: false,
drawBlock: rampMap =>
{
if (!rampMap.hasMixedValue)
{
for (int i = 0; i < shaderFlags.Count; i++)
{
if (rampMap.textureValue)
{
shaderFlags[i]
.SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_SIXWAY_RAMPMAP,
index: 1);
}
else
{
shaderFlags[i]
.ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_SIXWAY_RAMPMAP,
index: 1);
}
}
}
});
_helper.DrawVector4Component("六路自发光Pow", "_SixWayInfo", "y", false);
matEditor.ShaderProperty(_helper.GetProperty("_SixWayEmissionColor"), "六路自发光颜色");
}
}
else
{
_fxLightMode = FxLightMode.UnKnownOrMixedValue;
}
});
if (_fxLightMode != FxLightMode.SixWay)
{
//--------------法线-----------------
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBit2BumpTexToggle, 5, GetAnimBoolIndex(5),
"法线贴图开关", "_BumpMapToggle", shaderKeyword: "_NORMALMAP", drawBlock: isBumpMapToggle =>
{
MaterialProperty bumpTexFollowMainTexUVToggle = _helper.GetProperty("_BumpTexFollowMainTexUVToggle");
bool bumpMapFromMainTexUV = !bumpTexFollowMainTexUVToggle.hasMixedValue && bumpTexFollowMainTexUVToggle.floatValue > 0.5 ;
_helper.DrawTextureFoldOut(W9ParticleShaderFlags.foldOutBit1BumpTex, 4, GetAnimBoolIndex(4),
"法线贴图", "_BumpTex", drawWrapMode: !bumpMapFromMainTexUV,
flagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_BUMPTEX,
drawScaleOffset: !bumpMapFromMainTexUV, drawBlock:
theBumpmap =>
{
if (!bumpMapFromMainTexUV || _helper.ResetTool.IsInitResetData)
{
DrawUVModeSelect(W9ParticleShaderFlags.foldOutBit1UVModeBumpTex, 4, "法线贴图UV来源",
W9ParticleShaderFlags.FLAG_BIT_UVMODE_POS_0_BUMPMAP, 0, theBumpmap);
}
_helper.DrawToggle("法线跟随主贴图UV", "_BumpTexFollowMainTexUVToggle", W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_BUMP_TEX_UV_FOLLOW_MAINTEX, 1);
//在DoAfterDraw会执行SetKeyword的逻辑。
_helper.DrawToggle("法线贴图多通道模式", "_BumpMapMaskMode", W9ParticleShaderFlags.FLAG_BIT_PARTICLE_NORMALMAP_MASK_MODE);
_helper.DrawSlider("法线强度", "_BumpScale", rangePropertyName:"BumpScaleRangeVec");
});
});
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBit2MatCapToggle, 5, GetAnimBoolIndex(5),
"MatCap模拟材质", "_MatCapToggle", shaderKeyword: "_MATCAP", drawBlock: isMatCapToggle =>
{
_helper.DrawTexture("MatCap图", "_MatCapTex",colorPropertyName:"_MatCapColor", drawScaleOffset: false);
// matEditor.ColorProperty(_helper.GetProperty("_MatCapColor"), "MatCap颜色");
_helper.DrawVector4Component("MatCap相加到相乘过渡", "_MatCapInfo", "x", true);
});
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
else if (_fxLightMode == FxLightMode.SixWay)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
//这里应该关掉法线和Matcap的Keyword
perf
2025-07-21 05:42:20 -04:00
}
}
public void DrawFeatureOptions()
{
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBitMask, 3, GetAnimBoolIndex(3), "遮罩",
"_Mask_Toggle", shaderKeyword: "_MASKMAP_ON", fontStyle: FontStyle.Bold, drawBlock: (isToggle) =>
{
_helper.DrawVector4Component("遮罩强度", "_MaskMapVec", "x", true);
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBit2MaskRefine,5,GetAnimBoolIndex(5),"遮罩整体调整","_MaskRefineToggle",W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_MASK_REFINE,1,drawBlock:
maskRefineProp =>
{
_helper.DrawVector4Component("范围(Pow)","_MaskRefineVec","x",false);
_helper.DrawVector4Component("相乘","_MaskRefineVec","y",false);
_helper.DrawVector4Component("偏移(相加)","_MaskRefineVec","z",false);
perf
2025-07-21 05:42:20 -04:00
});
111
2025-08-27 21:45:18 -04:00
_helper.DrawPopUp("遮罩模式", "_MaskMapGradientToggle", _maskMapModeNames,
drawBlock: maskMapModeProp =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
Action drawMaskTexturePart = () =>
{
_helper.DrawTextureFoldOut(W9ParticleShaderFlags.foldOutBitMaskMap, 3,
GetAnimBoolIndex(3), "遮罩", "_MaskMap", drawWrapMode: true,
flagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_MASKMAP, flagIndex: 2,
drawBlock: theMaskMap =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
DrawColorChannelSelect("遮罩通道选择", W9ParticleShaderFlags.FLAG_BIT_COLOR_CHANNEL_POS_0_MASKMAP1);
perf
2025-07-21 05:42:20 -04:00
});
111
2025-08-27 21:45:18 -04:00
};
Action drawMaskGradientPart = () =>
{
maskMapGradientPropArr[0] = _helper.GetProperty("_MaskMapGradientFloat0");
maskMapGradientPropArr[1] = _helper.GetProperty("_MaskMapGradientFloat1");
maskMapGradientPropArr[2] = _helper.GetProperty("_MaskMapGradientFloat2");
_helper.DrawGradient(maskMapGradient, false, ColorSpace.Gamma, "遮罩渐变", 6,
"_MaskMapGradientCount", alphaProperties: maskMapGradientPropArr);
_helper.TextureScaleOffsetProperty("_MaskMap");
_helper.DrawWrapMode("遮罩", W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_MASKMAP,
flagIndex: 2);
};
if (_helper.ResetTool.IsInitResetData)
{
drawMaskTexturePart();
drawMaskGradientPart();
}
else
{
if (!maskMapModeProp.hasMixedValue)
{
//绘制贴图
if (maskMapModeProp.floatValue < 0.5f)
{
drawMaskTexturePart();
}
else
{
drawMaskGradientPart();
}
}
}
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
}, drawOnValueChangedBlock: maskMapModeProp =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
for (int i = 0; i < shaderFlags.Count; i++)
{
if (maskMapModeProp.floatValue < 0.5f)
{
shaderFlags[i]
.ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_MASKMAP_GRADIENT,
index: 1);
}
else
{
shaderFlags[i]
.SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_MASKMAP_GRADIENT,
index: 1);
}
}
perf
2025-07-21 05:42:20 -04:00
});
111
2025-08-27 21:45:18 -04:00
DrawUVModeSelect(W9ParticleShaderFlags.foldOutBit1UVModeMaskMap, 4, "遮罩UV来源",
W9ParticleShaderFlags.FLAG_BIT_UVMODE_POS_0_MASKMAP, 0);
DrawCustomDataSelect("Mask图X轴偏移自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_0_CUSTOMDATA_MASK_OFFSET_X, 0);
DrawCustomDataSelect("Mask图Y轴偏移自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_0_CUSTOMDATA_MASK_OFFSET_Y, 0);
_helper.DrawVector4In2Line("_MaskMapOffsetAnition", "遮罩偏移速度", true);
_helper.DrawFloat("遮罩旋转", "_MaskMapUVRotation");
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBitMaskRotate, 3,
GetAnimBoolIndex(3), "遮罩旋转速度", "_Mask_RotationToggle", W9ParticleShaderFlags
.FLAG_BIT_PARTILCE_MASKMAPROTATIONANIMATION_ON, isIndentBlock: false,
drawBlock: (isToggle2) =>
{
_helper.DrawFloat("旋转速度", "_MaskMapRotationSpeed");
});
DrawNoiseAffectBlock(() =>
{
_helper.DrawSlider("遮罩扭曲强度", "_MaskDistortion_intensity", rangePropertyName:"MaskDistortionIntensityRangeVec");
});
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBitMask2, 3, GetAnimBoolIndex(3), "遮罩2",
"_Mask2_Toggle", flagBitsName: W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_MASK_MAP2,
flagIndex: 1, isIndentBlock: true, drawBlock:
perf
2025-07-21 05:42:20 -04:00
(isToggle) =>
{
111
2025-08-27 21:45:18 -04:00
_helper.DrawPopUp("遮罩2模式", "_MaskMap2GradientToggle", _maskMapModeNames,
drawBlock: maskMap2GradientModeProp =>
{
Action drawMask2TexturePart = () =>
{
_helper.DrawTexture("遮罩2贴图", "_MaskMap2", drawWrapMode: true,
wrapModeFlagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_MASKMAP2,
flagIndex: 2,
drawBlock: theMaskMap2Texture =>
{
DrawColorChannelSelect("遮罩2通道选择",
W9ParticleShaderFlags.FLAG_BIT_COLOR_CHANNEL_POS_0_MASKMAP2);
});
};
Action drawMask2GradientPart = () =>
{
maskMap2GradientPropArr[0] = _helper.GetProperty("_MaskMap2GradientFloat0");
maskMap2GradientPropArr[1] = _helper.GetProperty("_MaskMap2GradientFloat1");
maskMap2GradientPropArr[2] = _helper.GetProperty("_MaskMap2GradientFloat2");
_helper.DrawGradient(maskMap2Gradient, false, ColorSpace.Gamma,
"遮罩2渐变(UV纵向)", 6, "_MaskMap2GradientCount",
alphaProperties: maskMap2GradientPropArr);
matEditor.TextureScaleOffsetProperty(_helper.GetProperty("_MaskMap2"));
_helper.DrawWrapMode("遮罩2UV",
W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_MASKMAP2, flagIndex: 2);
};
if (_helper.ResetTool.IsInitResetData)
{
drawMask2TexturePart();
drawMask2GradientPart();
}
else
{
if (!maskMap2GradientModeProp.hasMixedValue)
{
if (maskMap2GradientModeProp.floatValue < 0.5f)
{
drawMask2TexturePart();
}
else
{
drawMask2GradientPart();
}
}
}
DrawUVModeSelect(W9ParticleShaderFlags.foldOutBit1UVModeMaskMap2, 4, "遮罩2UV来源",
W9ParticleShaderFlags.FLAG_BIT_UVMODE_POS_0_MASKMAP_2, 0);
_helper.DrawVector4Component("遮罩2旋转","_MaskMapVec","y",false);
_helper.DrawVector4In2Line("_MaskMapOffsetAnition", "遮罩2偏移速度", false);
}, drawOnValueChangedBlock: maskMap2GradientModeProp =>
{
for (int i = 0; i < shaderFlags.Count; i++)
{
if (maskMap2GradientModeProp.floatValue < 0.5f)
{
shaderFlags[i]
.ClearFlagBits(
W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_MASKMAP_2_GRADIENT,
index: 1);
}
else
{
shaderFlags[i]
.SetFlagBits(
W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_MASKMAP_2_GRADIENT,
index: 1);
}
}
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
});
perf
2025-07-21 05:42:20 -04:00
});
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBitMask3, 3, GetAnimBoolIndex(3), "遮罩3",
"_Mask3_Toggle", flagBitsName: W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_MASK_MAP3,
flagIndex: 1, isIndentBlock: true, drawBlock:
(isToggle) =>
{
_helper.DrawPopUp("遮罩3模式", "_MaskMap3GradientToggle", _maskMapModeNames,
drawBlock: maskMap3GradientModeProp =>
{
Action drawMask3TexturePart = () =>
{
_helper.DrawTexture("遮罩3贴图", "_MaskMap3", drawWrapMode: true,
wrapModeFlagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_MASKMAP3,
flagIndex: 2,
drawBlock: theMaskMap2Texture =>
{
DrawColorChannelSelect("遮罩3通道选择",
W9ParticleShaderFlags.FLAG_BIT_COLOR_CHANNEL_POS_0_MASKMAP3);
});
};
Action drawMask3GradientPart = () =>
{
maskMap3GradientPropArr[0] = _helper.GetProperty("_MaskMap3GradientFloat0");
maskMap3GradientPropArr[1] = _helper.GetProperty("_MaskMap3GradientFloat1");
maskMap3GradientPropArr[2] = _helper.GetProperty("_MaskMap3GradientFloat2");
_helper.DrawGradient(maskMap3Gradient, false, ColorSpace.Gamma,
"遮罩3渐变(UV横向)", 6, "_MaskMap3GradientCount",
alphaProperties: maskMap3GradientPropArr);
matEditor.TextureScaleOffsetProperty(_helper.GetProperty("_MaskMap3"));
_helper.DrawWrapMode("遮罩3UV",
W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_MASKMAP3, flagIndex: 2);
};
if (_helper.ResetTool.IsInitResetData)
{
drawMask3TexturePart();
drawMask3GradientPart();
}
else
{
if (!maskMap3GradientModeProp.hasMixedValue)
{
if (maskMap3GradientModeProp.floatValue < 0.5f)
{
drawMask3TexturePart();
}
else
{
drawMask3GradientPart();
}
}
}
DrawUVModeSelect(W9ParticleShaderFlags.foldOutBit1UVModeMaskMap3, 4, "遮罩3UV来源",
W9ParticleShaderFlags.FLAG_BIT_UVMODE_POS_0_MASKMAP_3, 0);
_helper.DrawVector4Component("遮罩3旋转","_MaskMapVec","z",false);
_helper.DrawVector4In2Line("_MaskMap3OffsetAnition", "遮罩3偏移速度", true);
}, drawOnValueChangedBlock: maskMap3GradientModeProp =>
{
for (int i = 0; i < shaderFlags.Count; i++)
{
if (maskMap3GradientModeProp.floatValue < 0.5f)
{
shaderFlags[i]
.ClearFlagBits(
W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_MASKMAP_3_GRADIENT,
index: 1);
}
else
{
shaderFlags[i]
.SetFlagBits(
W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_MASKMAP_3_GRADIENT,
index: 1);
}
}
});
});
});
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBitNoise, 3, GetAnimBoolIndex(3), "扭曲",
"_noisemapEnabled", shaderKeyword: "_NOISEMAP", fontStyle: FontStyle.Bold,
drawBlock: (isToggle) =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
if (isToggle.hasMixedValue)
{
_noiseEnabled = -1;
}
else
{
_noiseEnabled = isToggle.floatValue > 0.5f ? 1 : 0;
}
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggle("用于屏幕扰动", "_ScreenDistortModeToggle", shaderKeyword: "_SCREEN_DISTORT_MODE",
drawEndChangeCheck: isScreenDistortToggle =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
if (!isScreenDistortToggle.hasMixedValue && isScreenDistortToggle.floatValue > 0.5f)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
//强制设置为Clamp模式。
for (int i = 0; i < mats.Count; i++)
{
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_BASEMAP,
index: 2);
}
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
});
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
EditorGUILayout.LabelField("扭曲贴图RG双通道则为FlowMap,FlowMap贴图设置应该去掉sRGB勾选");
_helper.DrawTextureFoldOut(W9ParticleShaderFlags.foldOutBitNoiseMap, 3, GetAnimBoolIndex(3), "扭曲贴图",
"_NoiseMap", drawWrapMode: true, flagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_NOISEMAP,
flagIndex: 2, drawBlock:
theNoiseMap =>
{
DrawUVModeSelect(W9ParticleShaderFlags.foldOutBit1UVModeNoiseMap, 4, "扭曲贴图UV来源",
W9ParticleShaderFlags.FLAG_BIT_UVMODE_POS_0_NOISE_MAP, 0, theNoiseMap);
_helper.DrawSlider("主贴图扭曲强度", "_TexDistortion_intensity", -1.0f, 1.0f);
DrawCustomDataSelect("扭曲强度自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_1_CUSTOMDATA_NOISE_INTENSITY, 1);
_helper.DrawVector4In2Line("_DistortionDirection", "扭曲方向强度", true);
DrawCustomDataSelect("扭曲方向强度X自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_2_CUSTOMDATA_NOISE_DIRECTION_X, 2);
DrawCustomDataSelect("扭曲方向强度Y自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_2_CUSTOMDATA_NOISE_DIRECTION_Y, 2);
_helper.DrawSlider("扭曲旋转", "_NoiseMapUVRotation", 0f, 360f);
_helper.DrawVector4In2Line("_NoiseOffset", "扭曲偏移速度", true);
_helper.DrawToggle("0.5为中值，双向扭曲", "_DistortionBothDirection_Toggle",
flagBitsName: W9ParticleShaderFlags.FLAG_BIT_PARTICLE_NOISEMAP_NORMALIZEED_ON,
isIndentBlock: false);
});
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBitNoiseMaskToggle, 3, GetAnimBoolIndex(3),
"扭曲遮罩", "_noiseMaskMap_Toggle",
flagBitsName: W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_NOISE_MASKMAP, flagIndex: 1,
drawBlock: isNoiseMaskToggle =>
{
_helper.DrawTexture("扭曲遮罩贴图", "_NoiseMaskMap", drawWrapMode: true,
wrapModeFlagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_NOISE_MASKMAP, drawBlock:
theNoiseMaskMap =>
{
DrawColorChannelSelect("扭曲遮罩图通道选择",
W9ParticleShaderFlags.FLAG_BIT_COLOR_CHANNEL_POS_0_NOISE_MASK);
DrawUVModeSelect(W9ParticleShaderFlags.foldOutBit1UVModeNoiseMaskMap, 4,
"扭曲遮罩贴图UV来源", W9ParticleShaderFlags.FLAG_BIT_UVMODE_POS_0_NOISE_MASK_MAP, 0,
theNoiseMaskMap);
});
});
perf
2025-07-21 05:42:20 -04:00
});
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBitDistortionChoraticaberrat, 3, GetAnimBoolIndex(3),
"扭曲色散", "_Distortion_Choraticaberrat_Toggle", W9ParticleShaderFlags.FLAG_BIT_PARTICLE_CHORATICABERRAT,
isIndentBlock: true, fontStyle: FontStyle.Bold, drawBlock:
(is_Choraticaberrat_Toggle) =>
{
DrawNoiseAffectBlock(() =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggle("色散强度受扭曲强度影响", "_Distortion_Choraticaberrat_WithNoise_Toggle",
W9ParticleShaderFlags.FLAG_BIT_PARTICLE_NOISE_CHORATICABERRAT_WITH_NOISE);
perf
2025-07-21 05:42:20 -04:00
});
111
2025-08-27 21:45:18 -04:00
_helper.DrawVector4Component("色散强度", "_DistortionDirection", "z", false);
DrawCustomDataSelect("色散强度自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_0_CUSTOMDATA_CHORATICABERRAT_INTENSITY, 0);
});
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBitEmission, 3, GetAnimBoolIndex(3), "流光(颜色相加)",
"_EmissionEnabled", shaderKeyword: "_EMISSION", isIndentBlock: true, fontStyle: FontStyle.Bold,
drawBlock: (isToggle) =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
MaterialProperty emissionFollowMainTexUVToggle = _helper.GetProperty("_EmissionFollowMainTexUV");
bool emissionFromMainTexUV = !emissionFollowMainTexUVToggle.hasMixedValue && emissionFollowMainTexUVToggle.floatValue > 0.5 ;
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
_helper.DrawTexture("流光贴图", "_EmissionMap", "_EmissionMapColor", drawWrapMode: !emissionFromMainTexUV,
wrapModeFlagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_EMISSIONMAP, flagIndex: 2,drawScaleOffset:!emissionFromMainTexUV,
drawBlock: theEmissionMap =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
if (!emissionFromMainTexUV)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
DrawUVModeSelect(W9ParticleShaderFlags.foldOutBit1UVModeEmissionMap, 4, "流光贴图UV来源", W9ParticleShaderFlags.FLAG_BIT_UVMODE_POS_0_EMISSION_MAP, 0, theEmissionMap);
_helper.DrawSlider("流光贴图旋转", "_EmissionMapUVRotation", 0f, 360f);
_helper.DrawVector4In2Line("_EmissionMapUVOffset", "流光贴图偏移速度", true);
DrawNoiseAffectBlock(() => { _helper.DrawSlider("流光贴图扭曲强度", "_Emi_Distortion_intensity",rangePropertyName:"EmiDistortionIntensityRangeVec"); });
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
});
_helper.DrawToggle("流光贴图跟随主贴图UV","_EmissionFollowMainTexUV",flagBitsName:W9ParticleShaderFlags.FLAG_BIT_PARTICLE_EMISSION_FOLLOW_MAINTEX_UV);
_helper.DrawFloat("流光颜色强度", "_EmissionMapColorIntensity");
});
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutColorBlend, 3, GetAnimBoolIndex(3), "渐变(颜色相乘)",
"_ColorBlendMap_Toggle", shaderKeyword: "_COLORMAPBLEND", isIndentBlock: true,
fontStyle: FontStyle.Bold,
drawBlock: (isToggle) =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
MaterialProperty colorBlendFollowMainTexUVToggle = _helper.GetProperty("_ColorBlendFollowMainTexUV");
bool colorBlendFromMainTexUV = !colorBlendFollowMainTexUVToggle.hasMixedValue && colorBlendFollowMainTexUVToggle.floatValue > 0.5 ;
_helper.DrawTexture("颜色渐变贴图", "_ColorBlendMap",colorPropertyName:"_ColorBlendColor" ,drawWrapMode: !colorBlendFromMainTexUV,
wrapModeFlagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_COLORBLENDMAP, flagIndex: 2,
drawScaleOffset: !colorBlendFromMainTexUV,drawBlock:
texProp =>
{
if (!colorBlendFromMainTexUV)
{
DrawUVModeSelect(W9ParticleShaderFlags.foldOutBit1UVModeColorBlendMap, 4, "颜色渐变贴图UV来源", W9ParticleShaderFlags.FLAG_BIT_UVMODE_POS_0_COLOR_BLEND_MAP, 0, texProp);
_helper.DrawVector4Component("颜色渐变贴图旋转", "_ColorBlendVec", "w", true, 0f, 360f);
_helper.DrawVector4In2Line("_ColorBlendMapOffset", "颜色渐变贴图偏移速度", true);
DrawNoiseAffectBlock(() => { _helper.DrawVector4Component("颜色渐变扭曲强度","_ColorBlendVec","x",true,0f,1f); });
}
});
_helper.DrawToggle("颜色渐变图跟随主贴图UV","_ColorBlendFollowMainTexUV",W9ParticleShaderFlags.FLAG_BIT_PARTICLE_COLOR_BLEND_FOLLOW_MAINTEX_UV);
// matEditor.ColorProperty(_helper.GetProperty("_ColorBlendColor"), "颜色渐变叠加");
_helper.DrawPopUp("颜色渐变图Alpha作用","_ColorBlendAlphaMultiplyMode",colorBlendAlphaMode,drawOnValueChangedBlock:
alphaModeProp =>
{
for (int i = 0; i < shaderFlags.Count; i++)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
if (alphaModeProp.floatValue > 0.5)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_COLOR_BLEND_ALPHA_MULTIPLY_MODE);
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
else
{
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_COLOR_BLEND_ALPHA_MULTIPLY_MODE);
}
}
});
_helper.DrawVector4Component("颜色渐变图Alpha强度","_ColorBlendVec","z",true,0f,1f);
perf
2025-07-21 05:42:20 -04:00
});
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBit2RampColor, 5, GetAnimBoolIndex(5), "颜色映射(Ramp)",
"_RampColorToggle", shaderKeyword: "_COLOR_RAMP", isIndentBlock: true, fontStyle: FontStyle.Bold,
drawBlock:
isToggleProp =>
{
_helper.DrawPopUp("Ramp来源模式", "_RampColorSourceMode", rampColorSourceMode,
drawBlock: modeProp =>
{
Action drawRampTexture = () =>
{
_helper.DrawTexture("颜色映射黑白图", "_RampColorMap", drawWrapMode: true,
wrapModeFlagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_RAMP_COLOR_MAP,
flagIndex: 2,
drawBlock: texProp =>
{
DrawColorChannelSelect("颜色映射黑白图通道选择",
W9ParticleShaderFlags.FLAG_BIT_COLOR_CHANNEL_POS_0_RAMP_COLOR_MAP);
});
};
Action drawNoRampTexture = () =>
{
_helper.TextureScaleOffsetProperty("_RampColorMap");
_helper.DrawWrapMode("颜色映射UV",
W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_RAMP_COLOR_MAP, 2);
};
if (_helper.ResetTool.IsInitResetData)
{
drawRampTexture();
drawNoRampTexture();
}
else
{
if (!modeProp.hasMixedValue)
{
if (modeProp.floatValue >= 0.5f)
{
drawRampTexture();
}
else
{
drawNoRampTexture();
}
}
}
}, drawOnValueChangedBlock: modeProp =>
{
for (int i = 0; i < shaderFlags.Count; i++)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
if (modeProp.floatValue > 0.5f)
{
shaderFlags[i]
.SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_RAMP_COLOR_MAP_MODE_ON);
}
else
{
shaderFlags[i]
.ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_RAMP_COLOR_MAP_MODE_ON);
}
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
});
DrawUVModeSelect(W9ParticleShaderFlags.foldOutBit1UVModeRampColorMap, 4, "颜色映射黑白图UV来源",
W9ParticleShaderFlags.FLAG_BIT_UVMODE_POS_0_RAMP_COLOR_MAP, 0,
_helper.GetProperty("_RampColorMap"),forceEnable:true);
_helper.DrawVector4In2Line("_RampColorMapOffset", "颜色映射贴图偏移速度", true);
_helper.DrawVector4Component("颜色映射贴图旋转", "_RampColorMapOffset", "w", true, 0f, 360f);
rampColorPropArr[0] = _helper.GetProperty("_RampColor0");
rampColorPropArr[1] = _helper.GetProperty("_RampColor1");
rampColorPropArr[2] = _helper.GetProperty("_RampColor2");
rampColorPropArr[3] = _helper.GetProperty("_RampColor3");
rampColorPropArr[4] = _helper.GetProperty("_RampColor4");
rampColorPropArr[5] = _helper.GetProperty("_RampColor5");
rampColorAlphaPropArr[0] = _helper.GetProperty("_RampColorAlpha0");
rampColorAlphaPropArr[1] = _helper.GetProperty("_RampColorAlpha1");
rampColorAlphaPropArr[2] = _helper.GetProperty("_RampColorAlpha2");
_helper.DrawGradient(rampColorGradient, true, ColorSpace.Gamma, "映射颜色", 6, "_RampColorCount",
rampColorPropArr, rampColorAlphaPropArr);
_helper.DrawPopUp("Ramp颜色混合模式", "_RampColorBlendMode", rampColorBlendMode, drawOnValueChangedBlock:
modeProp =>
{
for (int i = 0; i < shaderFlags.Count; i++)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
if (modeProp.floatValue > 0.5f)
{
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags
.FLAG_BIT_PARTICLE_RAMP_COLOR_BLEND_ADD);
}
else
{
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags
.FLAG_BIT_PARTICLE_RAMP_COLOR_BLEND_ADD);
}
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
});
matEditor.ShaderProperty(_helper.GetProperty("_RampColorBlendColor"), "颜色映射叠加颜色_hdr");
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
});
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutDissolve, 3, GetAnimBoolIndex(3), "溶解",
"_Dissolve_Toggle", shaderKeyword: "_DISSOLVE", isIndentBlock: true, fontStyle: FontStyle.Bold,
drawBlock: (isToggle) =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_helper.DrawTextureFoldOut(W9ParticleShaderFlags.foldOutDissolveMap, 3, GetAnimBoolIndex(3), "溶解贴图",
"_DissolveMap", drawScaleOffset: true, drawWrapMode: true,
flagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_DISSOLVE_MAP, flagIndex: 2,
drawBlock: (dissolveTex) =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
DrawColorChannelSelect("溶解贴图通道选择",
W9ParticleShaderFlags.FLAG_BIT_COLOR_CHANNEL_POS_0_DISSOLVE_MAP);
// matEditor.TextureScaleOffsetProperty(_helper.GetProperty("_DissolveMap"));
DrawCustomDataSelect("溶解贴图X轴偏移自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_1_CUSTOMDATA_DISSOLVE_OFFSET_X, 1);
DrawCustomDataSelect("溶解贴图Y轴偏移自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_1_CUSTOMDATA_DISSOLVE_OFFSET_Y, 1);
DrawUVModeSelect(W9ParticleShaderFlags.foldOutBit1UVModeDissolveMap, 4, "溶解贴图UV来源",
W9ParticleShaderFlags.FLAG_BIT_UVMODE_POS_0_DISSOLVE_MAP, 0, dissolveTex);
_helper.DrawVector4In2Line("_DissolveOffsetRotateDistort", "溶解贴图偏移速度", true);
_helper.DrawVector4Component("溶解贴图旋转", "_DissolveOffsetRotateDistort", "z", true, 0f, 360f);
});
_helper.DrawVector4Component("溶解值Pow", "_Dissolve","y",true,0f,10f);
_helper.DrawToggle("溶解度黑白值测试", "_Dissolve_Test_Toggle", shaderKeyword: "_DISSOLVE_EDITOR_TEST");
_helper.DrawVector4Component("溶解强度", "_Dissolve", "x", true, rangeVecPropName:"DissolveXRangeVec");
DrawCustomDataSelect("溶解强度自定义曲线", W9ParticleShaderFlags.FLAGBIT_POS_0_CUSTOMDATA_DISSOLVE_INTENSITY,
0);
_helper.DrawVector4Component("溶解硬软度", "_Dissolve", "w", true, 0.001f, 1f);
DrawNoiseAffectBlock(() =>
{
_helper.DrawVector4Component("溶解贴图扭曲强度", "_DissolveOffsetRotateDistort", "w", false);
});
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutDissolveVoronoi, 3, GetAnimBoolIndex(3),
"程序化噪波叠加", "_DissolveVoronoi_Toggle",
W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_DISSOVLE_VORONOI, flagIndex: 1, isIndentBlock: true,
drawBlock: isVoronoiToggle =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_helper.DrawVector4In2Line("_DissolveVoronoi_Vec", "噪波1缩放", true);
_helper.DrawVector4Component("噪波1速度", "_DissolveVoronoi_Vec2", "z", false);
_helper.DrawVector4In2Line("_DissolveVoronoi_Vec4", "噪波1偏移", true);
DrawCustomDataSelect("噪波1偏移速度X自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_2_CUSTOMDATA_DISSOLVE_NOISE1_OFFSET_X, 2);
DrawCustomDataSelect("噪波1偏移速度Y自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_2_CUSTOMDATA_DISSOLVE_NOISE1_OFFSET_Y, 2);
_helper.DrawVector4In2Line("_DissolveVoronoi_Vec3", "噪波1偏移速度", true);
EditorGUILayout.Space();
_helper.DrawVector4In2Line("_DissolveVoronoi_Vec", "噪波2缩放", false);
_helper.DrawVector4Component("噪波2速度", "_DissolveVoronoi_Vec2", "w", false);
_helper.DrawVector4In2Line("_DissolveVoronoi_Vec4", "噪波2偏移", false);
DrawCustomDataSelect("噪波2偏移速度X自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_2_CUSTOMDATA_DISSOLVE_NOISE2_OFFSET_X, 2);
DrawCustomDataSelect("噪波2偏移速度Y自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_2_CUSTOMDATA_DISSOLVE_NOISE2_OFFSET_Y, 2);
_helper.DrawVector4In2Line("_DissolveVoronoi_Vec3", "噪波2偏移速度", false);
EditorGUILayout.Space();
EditorGUILayout.Space();
_helper.DrawVector4Component("噪波12混合系数(圆尖)", "_DissolveVoronoi_Vec2", "x", true);
_helper.DrawVector4Component("噪波整体和溶解贴图混合系数", "_DissolveVoronoi_Vec2", "y", true);
EditorGUILayout.Space();
});
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBit2DissolveLine,5,GetAnimBoolIndex(5),"溶解描边","_DissolveLineMaskToggle",W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_DISSOLVE_LINE_MASK,1,drawBlock:
isDissolveLineMask =>
{
// matEditor.ColorProperty(_helper.GetProperty("_DissolveLineColor"), "溶解描边颜色");
_helper.ColorProperty("溶解描边颜色","_DissolveLineColor");
_helper.DrawVector4Component("描边位置","_Dissolve_Vec2","x",true,rangeVecPropName:"Dissolve2XRangeVec");
_helper.DrawVector4Component("描边软硬","_Dissolve_Vec2","y",true,rangeVecPropName:"Dissolve2YRangeVec");
});
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutDissolveRampMap, 3, GetAnimBoolIndex(3),
"溶解Ramp图功能", "_Dissolve_useRampMap_Toggle",
W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_DISSOVLE_USE_RAMP, flagIndex: 1, isIndentBlock: true,
drawBlock:
isDissolveUseRampToggle =>
{
_helper.DrawPopUp("溶解Ramp模式", "_DissolveRampSourceMode", dissolveRampSourceMode,
drawBlock: dissolveRampModeProp =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
Action drawRampTexture = () =>
{
_helper.DrawTexture("溶解Ramp图", "_DissolveRampMap", "_DissolveRampColor",
drawScaleOffset: true, drawWrapMode: true,
wrapModeFlagBitsName: W9ParticleShaderFlags
.FLAG_BIT_WRAPMODE_DISSOLVE_RAMPMAP, flagIndex: 2);
};
Action drawRampGradient = () =>
{
dissolveRampColorPropArr[0] = _helper.GetProperty("_DissolveRampColor0");
dissolveRampColorPropArr[1] = _helper.GetProperty("_DissolveRampColor1");
dissolveRampColorPropArr[2] = _helper.GetProperty("_DissolveRampColor2");
dissolveRampColorPropArr[3] = _helper.GetProperty("_DissolveRampColor3");
dissolveRampColorPropArr[4] = _helper.GetProperty("_DissolveRampColor4");
dissolveRampColorPropArr[5] = _helper.GetProperty("_DissolveRampColor5");
dissolveRampAlphaPropArr[0] = _helper.GetProperty("_DissolveRampAlpha0");
dissolveRampAlphaPropArr[1] = _helper.GetProperty("_DissolveRampAlpha1");
dissolveRampAlphaPropArr[2] = _helper.GetProperty("_DissolveRampAlpha2");
_helper.DrawGradient(dissolveRampGradient, true, ColorSpace.Gamma,
"Ramp颜色", 6, "_DissolveRampCount", dissolveRampColorPropArr,
dissolveRampAlphaPropArr);
matEditor.TextureScaleOffsetProperty(
_helper.GetProperty("_DissolveRampMap"));
matEditor.ShaderProperty(_helper.GetProperty("_DissolveRampColor"),
"Ramp颜色叠加");
_helper.DrawWrapMode("溶解RampUV",
W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_DISSOLVE_RAMPMAP, 2);
};
if (_helper.ResetTool.IsInitResetData)
{
drawRampTexture();
drawRampGradient();
}
else
{
if (!dissolveRampModeProp.hasMixedValue)
{
if (dissolveRampModeProp.floatValue > 0.5f)
{
drawRampTexture();
}
else
{
drawRampGradient();
}
}
}
_helper.DrawPopUp("溶解Ramp混合模式","_DissolveRampColorBlendMode",dissolveRampBlendModeNames,drawOnValueChangedBlock:
rampColorBend =>
{
for (int i = 0; i < shaderFlags.Count; i++)
{
if (rampColorBend.floatValue > 0.5f)
{
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_DISSOLVE_RAMP_MULITPLY,index:1);
}
else
{
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_DISSOLVE_RAMP_MULITPLY,index:1);
}
}
});
}, drawOnValueChangedBlock: dissolveRampModeProp =>
{
for (int i = 0; i < shaderFlags.Count; i++)
{
if (dissolveRampModeProp.floatValue > 0.5f)
{
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags
.FLAG_BIT_PARTICLE_DISSOLVE_RAMP_MAP);
}
else
{
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags
.FLAG_BIT_PARTICLE_DISSOLVE_RAMP_MAP);
}
}
});
});
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutDissolveMask, 3, GetAnimBoolIndex(3), "溶解遮罩图(过程溶解)",
"_DissolveMask_Toggle", W9ParticleShaderFlags.FLAG_BIT_PARTICLE_DISSOLVE_MASK, drawBlock:
(isToggle) =>
{
_helper.DrawTexture("溶解遮罩图", "_DissolveMaskMap", drawWrapMode: true,
wrapModeFlagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_DISSOLVE_MASKMAP,
flagIndex: 2, drawBlock:
texProp =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
DrawUVModeSelect(W9ParticleShaderFlags.foldOutBit1UVModeDissolveMaskMap, 4,
"溶解遮罩图UV来源", W9ParticleShaderFlags.FLAG_BIT_UVMODE_POS_0_DISSOLVE_MASK_MAP, 0,
texProp);
});
DrawColorChannelSelect("溶解遮罩图通道选择",
W9ParticleShaderFlags.FLAG_BIT_COLOR_CHANNEL_POS_0_DISSOLVE_MASK_MAP);
_helper.DrawVector4Component("溶解遮罩强度", "_Dissolve", "z", false);
DrawCustomDataSelect("溶解遮罩图强度自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_1_CUSTOMDATA_DISSOLVE_MASK_INTENSITY, 1);
});
});
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutFresnel, 3, GetAnimBoolIndex(3), "菲涅尔",
"_fresnelEnabled", W9ParticleShaderFlags.FLAG_BIT_PARTICLE_FRESNEL_ON, isIndentBlock: true,
fontStyle: FontStyle.Bold,
drawBlock: (isToggle) =>
{
_helper.DrawPopUp("菲涅尔模式", "_FresnelMode", _fresnelModeNames, drawBlock:
fresnelModeProp =>
{
if ((!fresnelModeProp.hasMixedValue) &&
fresnelModeProp.floatValue.Equals((float)FresnelMode.Color))
{
matEditor.ColorProperty(_helper.GetProperty("_FresnelColor"), "菲涅尔颜色");
_helper.DrawToggle("菲涅尔颜色受Alpha影响", "_FresnelColorAffectByAlpha",
W9ParticleShaderFlags.FLAG_BIT_PARTICLE_FRESNEL_COLOR_AFFETCT_BY_ALPHA);
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
},
drawOnValueChangedBlock: fresnelModeProp =>
{
if (!fresnelModeProp.hasMixedValue)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
FresnelMode fresnelMode = (FresnelMode)fresnelModeProp.floatValue;
for (int i = 0; i < shaderFlags.Count; i++)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
switch (fresnelMode)
{
case FresnelMode.Color:
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags
.FLAG_BIT_PARTICLE_FRESNEL_COLOR_ON);
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags
.FLAG_BIT_PARTICLE_FRESNEL_FADE_ON);
break;
case FresnelMode.Fade:
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags
.FLAG_BIT_PARTICLE_FRESNEL_COLOR_ON);
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags
.FLAG_BIT_PARTICLE_FRESNEL_FADE_ON);
break;
}
perf
2025-07-21 05:42:20 -04:00
}
}
});
111
2025-08-27 21:45:18 -04:00
_helper.DrawVector4Component("菲涅尔强度", "_FresnelUnit", "z", true);
if (mats.Count == 1)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
FresnelMode fresnelMode = (FresnelMode)mats[0].GetFloat("_FresnelMode");
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
_helper.DrawVector4Component("菲涅尔位置", "_FresnelUnit", "x", true, -1f, 1f);
DrawCustomDataSelect("菲尼尔位置自定义曲线", W9ParticleShaderFlags.FLAGBIT_POS_0_CUSTOMDATA_FRESNEL_OFFSET,
0);
_helper.DrawVector4Component("菲涅尔范围Pow", "_FresnelUnit", "y", true, 0f, 10f);
_helper.DrawVector4Component("菲涅尔硬度", "_FresnelUnit", "w", true, 0f, 1f);
_helper.DrawToggle("翻转菲涅尔", "_InvertFresnel_Toggle",
W9ParticleShaderFlags.FLAG_BIT_PARTICLE_FRESNEL_INVERT_ON);
matEditor.VectorProperty(_helper.GetProperty("_FresnelRotation"), "菲涅尔方向偏移");
});
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutVertexOffset, 3, GetAnimBoolIndex(3), "顶点偏移",
"_VertexOffset_Toggle", W9ParticleShaderFlags.FLAG_BIT_PARTICLE_VERTEX_OFFSET_ON, isIndentBlock: true,
fontStyle: FontStyle.Bold,
drawBlock: isToggle =>
{
_helper.DrawTexture("顶点偏移贴图", "_VertexOffset_Map", drawScaleOffset: true, drawWrapMode: true,
wrapModeFlagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_VERTEXOFFSETMAP, flagIndex: 2,
drawBlock: texProp =>
{
DrawUVModeSelect(W9ParticleShaderFlags.foldOutBit1UVModeVertexOffsetMap, 4, "顶点偏移贴图UV来源",
W9ParticleShaderFlags.FLAG_BIT_UVMODE_POS_0_VERTEX_OFFSET_MAP, 0, texProp);
});
DrawCustomDataSelect("顶点扰动X轴偏移自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_1_CUSTOMDATA_VERTEX_OFFSET_X, 1);
DrawCustomDataSelect("顶点扰动Y轴偏移自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_1_CUSTOMDATA_VERTEX_OFFSET_Y, 1);
_helper.DrawVector4In2Line("_VertexOffset_Vec", "顶点偏移动画", true);
_helper.DrawVector4Component("顶点偏移强度", "_VertexOffset_Vec", "z", false);
DrawCustomDataSelect("顶点扰动强度自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_1_CUSTOMDATA_VERTEXOFFSET_INTENSITY, 1);
_helper.DrawToggle("顶点偏移从零开始", "_VertexOffset_StartFromZero",
W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_VERTEXOFFSET_START_FROM_ZERO, 1);
_helper.DrawToggle("顶点偏移使用法线方向", "_VertexOffset_NormalDir_Toggle",
W9ParticleShaderFlags.FLAG_BIT_PARTICLE_VERTEX_OFFSET_NORMAL_DIR, isIndentBlock: false,
drawBlock:
isToggle =>
{
if (!isToggle.hasMixedValue && isToggle.floatValue < 0.5f)
{
// matEditor.ShaderProperty(_helper.GetProperty("_VertexOffset_CustomDir"), "顶点偏移本地方向");
_helper.DrawVector4XYZComponet("顶点偏移本地方向","_VertexOffset_CustomDir");
}
});
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBit1VertexOffsetMask, 4, GetAnimBoolIndex(4),
"顶点偏移遮罩", "_VertexOffset_Mask_Toggle",
W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_VERTEXOFFSET_MASKMAP, 1,
drawBlock: isMaskToggle =>
{
_helper.DrawTexture("顶点偏移遮罩图", "_VertexOffset_MaskMap", drawScaleOffset: true,
drawWrapMode: true,
wrapModeFlagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_VERTEXOFFSET_MASKMAP,
flagIndex: 2,
drawBlock: texProp =>
{
DrawUVModeSelect(W9ParticleShaderFlags.foldOutBit1UVModeVertexOffsetMaskMap, 4,
"顶点偏移遮罩图UV来源",
W9ParticleShaderFlags.FLAG_BIT_UVMODE_POS_0_VERTEX_OFFSET_MASKMAP, 0, texProp);
});
DrawCustomDataSelect("顶点扰动遮罩X轴偏移自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_3_CUSTOMDATA_VERTEX_OFFSET_MASK_X, 3);
DrawCustomDataSelect("顶点扰动遮罩Y轴偏移自定义曲线",
W9ParticleShaderFlags.FLAGBIT_POS_3_CUSTOMDATA_VERTEX_OFFSET_MASK_Y, 3);
_helper.DrawVector4In2Line("_VertexOffset_MaskMap_Vec", "顶点偏移遮罩动画", true);
_helper.DrawVector4Component("顶点偏移遮罩强度", "_VertexOffset_MaskMap_Vec", "z", true);
});
});
if (_uiEffectEnabled == 0)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutDepthOutline, 3, GetAnimBoolIndex(3), "深度描边",
"_DepthOutline_Toggle",
flagBitsName: W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_DEPTH_OUTLINE, fontStyle: FontStyle.Bold,
flagIndex: 1, isIndentBlock: true,
drawBlock: (isToggle) =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
matEditor.ColorProperty(_helper.GetProperty("_DepthOutline_Color"), "深度描边颜色");
_helper.DrawVector4In2Line("_DepthOutline_Vec", "深度描边距离", true);
});
_helper.DrawToggle("深度贴花", "_DepthDecal_Toggle", shaderKeyword: "_DEPTH_DECAL",
fontStyle: FontStyle.Bold,
drawEndChangeCheck: (isToggle) =>
{
if (!isToggle.hasMixedValue)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
for (int i = 0; i < mats.Count; i++)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
if (isToggle.floatValue > 0.5f)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
StencilTestHelper.SetMaterialStencil(mats[i], "ParticleBaseDecal",
_stencilValuesConfig, out int ignore);
mats[i].SetFloat(_isCustomedStencilPropID, 1f);
mats[i].SetFloat("_Cull", (float)RenderFace.Back);
mats[i].SetFloat("_ZTest", (float)CompareFunction.GreaterEqual);
perf
2025-07-21 05:42:20 -04:00
}
else
{
111
2025-08-27 21:45:18 -04:00
StencilTestHelper.SetMaterialStencil(mats[i], _defaultStencilKey,
_stencilValuesConfig, out int ignore);
mats[i].SetFloat(_isCustomedStencilPropID, 0f);
mats[i].SetFloat("_Cull", (float)RenderFace.Front);
mats[i].SetFloat("_ZTest", (float)CompareFunction.LessEqual);
perf
2025-07-21 05:42:20 -04:00
}
}
111
2025-08-27 21:45:18 -04:00
perf
2025-07-21 05:42:20 -04:00
}
});
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutParallexMapping, 3, GetAnimBoolIndex(3), "遮蔽视差",
"_ParallaxMapping_Toggle", shaderKeyword: "_PARALLAX_MAPPING",
isIndentBlock: true, fontStyle: FontStyle.Bold,
drawBlock: isTogggle =>
{
_helper.DrawTexture("视差贴图", "_ParallaxMapping_Map", drawWrapMode: true,
wrapModeFlagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_PARALLAXMAPPINGMAP,
flagIndex: 2);
_helper.DrawSlider("视差", "_ParallaxMapping_Intensity", 0, 0.1f);
Action<float, bool> OnPomLayerCountChange = (f, isMixedValue) =>
{
int shaderID = Shader.PropertyToID("_ParallaxMapping_Vec");
for (int i = 0; i < mats.Count; i++)
{
Vector4 vecValue = mats[i].GetVector(shaderID);
if (vecValue.y < vecValue.x + 1)
{
vecValue.y = vecValue.x + 1;
}
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
mats[i].SetVector(shaderID, vecValue);
}
};
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
_helper.DrawVector4Component("遮蔽视差最小层数", "_ParallaxMapping_Vec", "x", true, 0f, 100f,
drawEndChangeCheckBlock: OnPomLayerCountChange);
_helper.DrawVector4Component("遮蔽视差最大层数", "_ParallaxMapping_Vec", "y", true, 0f, 100f,
drawEndChangeCheckBlock: OnPomLayerCountChange,
drawBlock: (f, hasMixedValue) =>
{
if (!hasMixedValue && f >= 20f)
{
EditorGUILayout.HelpBox("遮蔽视差层数过高将影响性能", MessageType.Warning);
}
});
});
Action<Material> SetPortal = (mat) =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
StencilTestHelper.SetMaterialStencil(mat, "ParticalBasePortal", _stencilValuesConfig,
out int Ignore);
mat.SetFloat(_isCustomedStencilPropID, 1f);
};
Action<Material> SetPortalMask = (mat) =>
{
StencilTestHelper.SetMaterialStencil(mat, "ParticalBasePortalMask", _stencilValuesConfig,
out int Ignore);
if (mat.GetFloat("_TransparentMode") == (float)TransparentMode.Transparent)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
mat.SetFloat("_TransparentMode", (float)TransparentMode.CutOff);
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
mat.SetFloat("_ZTest", (float)CompareFunction.LessEqual);
mat.SetFloat("_ForceZWriteToggle",2);
};
Action<Material> RestPortal = (mat) =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
StencilTestHelper.SetMaterialStencil(mat, _defaultStencilKey,
_stencilValuesConfig, out int ignore);
mat.SetFloat(_isCustomedStencilPropID, 0f);
mat.SetFloat("_TransparentMode", (float)TransparentMode.Transparent);
mat.SetFloat("_ZTest", (float)CompareFunction.LessEqual);
mat.SetFloat("_ForceZWriteToggle", 0f);
};
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBit1Portal, 4, GetAnimBoolIndex(4), "模板视差",
"_Portal_Toggle", fontStyle: FontStyle.Bold,
drawBlock: isPortalToggle =>
{
_helper.DrawToggle("模板视差蒙版", "_Portal_MaskToggle", drawEndChangeCheck: isPortalMaskToggle =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
if (!isPortalMaskToggle.hasMixedValue)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
for (int i = 0; i < mats.Count; i++)
{
if (isPortalMaskToggle.floatValue > 0.5f)
{
SetPortalMask(mats[i]);
}
else if(isPortalToggle.floatValue >0.5f)
{
SetPortal(mats[i]);
}
else
{
RestPortal(mats[i]);
}
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
}
perf
2025-07-21 05:42:20 -04:00
}
});
111
2025-08-27 21:45:18 -04:00
}, drawEndChangeCheck: (isPortalToggle) =>
{
for (int i = 0; i < mats.Count; i++)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
if (isPortalToggle.floatValue > 0.5f)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
if (mats[i].GetFloat("_Portal_MaskToggle") < 0.5f)
{
SetPortal(mats[i]);
}
else
{
SetPortalMask(mats[i]);
}
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
else
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
RestPortal(mats[i]);
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
}
});
}
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
//粒子序列帧融帧的逻辑，是将UV0为第一格，UV1234推到第二格，中间用AnimBlend融合）。所以多UV是必然和这个矛盾的。
_helper.DrawToggle("序列帧融帧(丝滑)", "_FlipbookBlending", shaderKeyword: "_FLIPBOOKBLENDING_ON",
fontStyle: FontStyle.Bold, drawBlock: (isToggle) =>
{
if (!isToggle.hasMixedValue && isToggle.floatValue > 0.5f)
{
if (_meshSourceMode == MeshSourceMode.Particle)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
if (shaderFlags[0].CheckIsUVModeOn(W9ParticleShaderFlags.UVMode.SpecialUVChannel))
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
EditorGUILayout.HelpBox("序列帧融帧和特殊UV通道同时开启，粒子序列帧应该影响UV0和UV1两个通道，特殊通道只能使用UV3（原始UV）",
MessageType.Warning);
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
else
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
EditorGUILayout.HelpBox("AnimationSheet的AffectUVChannel需要有UV0和UV1",
MessageType.Info);
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
}
else if (_meshSourceMode == MeshSourceMode.Mesh)
{
EditorGUILayout.HelpBox("需要添加AnimationSheetHelper脚本", MessageType.Info);
}
}
});
}
public void DrawTaOptions()
{
if (_uiEffectEnabled == 0)
{
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBit1ZOffset, 4, GetAnimBoolIndex(4), "深度偏移",
"_ZOffset_Toggle", fontStyle: FontStyle.Bold, drawBlock:
(isToggle) =>
{
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
matEditor.ShaderProperty(_helper.GetProperty("_offsetFactor"), "OffsetFactor");
matEditor.ShaderProperty(_helper.GetProperty("_offsetUnits"), "Offset单位");
},
drawEndChangeCheck: (isToggle) =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
if (!isToggle.hasMixedValue && isToggle.floatValue < 0.5f)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
for (int i = 0; i < mats.Count; i++)
{
mats[i].SetFloat("_offsetFactor", 0f);
mats[i].SetFloat("_offsetUnits", 0f);
}
perf
2025-07-21 05:42:20 -04:00
}
});
111
2025-08-27 21:45:18 -04:00
}
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
_helper.DrawRenderQueue(_helper.GetProperty("_QueueBias"));
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBit1CustomStencilTest, 4, GetAnimBoolIndex(4),
"模板手动调试开关", "_CustomStencilTest",
drawBlock: isToggle =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
bool hasMixedKeyValue = false;
int stencilKeyIndexID = Shader.PropertyToID("_StencilKeyIndex");
string originKey = "";
for (int i = 0; i < mats.Count; i++)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
string key = _stencilValuesConfig.GetKeyByIndex(mats[i].GetInt(stencilKeyIndexID));
if (i == 0)
{
originKey = key;
}
else
{
if (originKey != key) hasMixedKeyValue = true;
}
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
hasMixedKeyValue = false;
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
EditorGUI.showMixedValue = hasMixedKeyValue;
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.TextField("当前Config:", originKey);
EditorGUI.EndDisabledGroup();
EditorGUI.showMixedValue = false;
matEditor.ShaderProperty(_helper.GetProperty("_Stencil"), "模板值");
matEditor.ShaderProperty(_helper.GetProperty("_StencilComp"), "模板比较方式");
matEditor.ShaderProperty(_helper.GetProperty("_StencilOp"), "模板处理方式");
},
drawEndChangeCheck: isToggle =>
{
if (!isToggle.hasMixedValue)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
for (int i = 0; i < mats.Count; i++)
{
if (isToggle.floatValue > 0.5f)
{
mats[i].SetFloat(_isCustomedStencilPropID, 1f);
}
else
{
StencilTestHelper.SetMaterialStencil(mats[i], _defaultStencilKey, _stencilValuesConfig,
out int ignore);
}
}
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
});
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
if (mats.Count == 1)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_helper.DrawFoldOut(W9ParticleShaderFlags.foldOutBit1ShaderKeyword, 4, GetAnimBoolIndex(4),
"已开启Keyword:", drawBlock:
() =>
{
List<string> shaderKeywords = new List<string>();
foreach (var localKeyword in mats[0].enabledKeywords)
{
shaderKeywords.Add(localKeyword.name);
}
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
if (shaderKeywords != null && shaderKeywords.Count > 0)
{
float height = EditorGUIUtility.singleLineHeight * shaderKeywords.Count;
Rect labelRect = EditorGUILayout.GetControlRect(false, height);
string label = "";
for (int i = 0; i < shaderKeywords.Count; i++)
{
label += shaderKeywords[i];
label += "\n";
}
EditorGUI.LabelField(labelRect, label);
}
});
perf
2025-07-21 05:42:20 -04:00
}
}
111
2025-08-27 21:45:18 -04:00
perf
2025-07-21 05:42:20 -04:00
void DrawNoiseAffectBlock(Action drawBlock)
{
111
2025-08-27 21:45:18 -04:00
EditorGUI.BeginDisabledGroup(_noiseEnabled == 0);
EditorGUI.showMixedValue = _noiseEnabled < 0;
perf
2025-07-21 05:42:20 -04:00
drawBlock();
111
2025-08-27 21:45:18 -04:00
EditorGUI.showMixedValue = false;
perf
2025-07-21 05:42:20 -04:00
EditorGUI.EndDisabledGroup();
}
public string[] blendModeNames =
{
"透明度混合AlphaBlend",
"预乘PreMultiply",
"叠加Additive",
"正片叠底Multiply"
};
111
2025-08-27 21:45:18 -04:00
perf
2025-07-21 05:42:20 -04:00
public enum BlendMode
{
Alpha, // Old school alpha-blending mode, fresnel does not affect amount of transparency
Premultiply, // Physically plausible transparency mode, implemented as alpha pre-multiply
Additive,
Multiply,
Opaque
}
111
2025-08-27 21:45:18 -04:00
perf
2025-07-21 05:42:20 -04:00
public enum TimeMode
{
Default,
UnScaleTime,
ScriptableTime
}
111
2025-08-27 21:45:18 -04:00
perf
2025-07-21 05:42:20 -04:00
public enum RenderFace
{
Front = 2,
Back = 1,
Both = 0
}
111
2025-08-27 21:45:18 -04:00
public enum FresnelMode
{
Color = 0,
Fade = 1,
UnkownOrMixed = -1
}
private string[] _fresnelModeNames =
{
"颜色|边缘光",
"半透明|渐隐"
};
private string[] _maskMapModeNames =
{
"遮罩贴图",
"渐变控件"
};
private string[] _ForceZWriteToggleNames =
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
"默认",
"强制开启",
"强制关闭"
};
public enum FxLightMode
{
UnLit,
BlinnPhong,
HalfLambert,
PBR,
SixWay,
UnKnownOrMixedValue = -1
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
private string[] _fxLightModeNames =
{
"默认无光(Unlit)",
"简单光照(BlinnPhong)",
"简单光照通透(HalfLambert)",
"高级光照(PBR)",
"六路光照(SixWay)"
};
perf
2025-07-21 05:42:20 -04:00
public string[] transparentModeNames =
{
"不透明Opaque",
"半透明Transparent",
"不透明裁剪CutOff"
};
public enum TransparentMode
{
Opaque = 0,
Transparent = 1,
111
2025-08-27 21:45:18 -04:00
CutOff = 2,
UnKnowOrMixed = -1
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
private string[] matCapBlendModeNames =
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
"相加Add",
"相乘Multiply",
perf
2025-07-21 05:42:20 -04:00
};
111
2025-08-27 21:45:18 -04:00
private string[] dissolveRampBlendModeNames =
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
"线性差值Lerp",
"相乘Multiply",
perf
2025-07-21 05:42:20 -04:00
};
111
2025-08-27 21:45:18 -04:00
private string[] colorBlendAlphaMode = new[]
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
"颜色渐变强度",
"遮罩(乘以主贴图Alpha)"
perf
2025-07-21 05:42:20 -04:00
};
111
2025-08-27 21:45:18 -04:00
private string[] rampColorSourceMode =
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
"UV",
"映射贴图"
perf
2025-07-21 05:42:20 -04:00
};
111
2025-08-27 21:45:18 -04:00
private string[] dissolveRampSourceMode =
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
"渐变控件",
"Ramp贴图"
perf
2025-07-21 05:42:20 -04:00
};
111
2025-08-27 21:45:18 -04:00
private string[] rampColorBlendMode =
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
"相乘Multiply",
"相加Add"
perf
2025-07-21 05:42:20 -04:00
};
void DoAfterDraw()
{
111
2025-08-27 21:45:18 -04:00
// Debug.Log(mats[0].name + " MaterialEditorDoAfterDraw!");
perf
2025-07-21 05:42:20 -04:00
for (int i = 0; i < mats.Count; i++)
{
111
2025-08-27 21:45:18 -04:00
perf
2025-07-21 05:42:20 -04:00
switch (_meshSourceMode)
{
case MeshSourceMode.Particle:
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_IS_PARTICLE_SYSTEM, index: 1);
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_UV_FROM_MESH, index: 1);
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_UIEFFECT_ON, index: 0);
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_UIEFFECT_SPRITE_MODE,
index: 1);
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_UIEFFECT_BASEMAP_MODE,
index: 1);
//如果是粒子系统，则不需要走AnimationSheetHelper
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_ANIMATION_SHEET_HELPER);
break;
case MeshSourceMode.Mesh:
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_IS_PARTICLE_SYSTEM,
index: 1);
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_UV_FROM_MESH, index: 1);
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_UIEFFECT_ON, index: 0);
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_UIEFFECT_SPRITE_MODE,
index: 1);
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_UIEFFECT_BASEMAP_MODE,
index: 1);
break;
case MeshSourceMode.UIEffectRawImage:
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_IS_PARTICLE_SYSTEM,
index: 1);
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_UV_FROM_MESH, index: 1);
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_UIEFFECT_ON, index: 0);
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_UIEFFECT_SPRITE_MODE,
index: 1);
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_UIEFFECT_BASEMAP_MODE,
index: 1);
break;
case MeshSourceMode.UIEffectSprite:
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_IS_PARTICLE_SYSTEM,
index: 1);
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_UV_FROM_MESH, index: 1);
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_UIEFFECT_ON, index: 0);
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_UIEFFECT_SPRITE_MODE,
index: 1);
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_UIEFFECT_BASEMAP_MODE,
index: 1);
break;
case MeshSourceMode.UIEffectBaseMap:
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_IS_PARTICLE_SYSTEM,
index: 1);
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_UV_FROM_MESH, index: 1);
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_UIEFFECT_ON, index: 0);
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_UIEFFECT_SPRITE_MODE,
index: 1);
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_UIEFFECT_BASEMAP_MODE,
index: 1);
break;
}
111
2025-08-27 21:45:18 -04:00
if (_meshSourceModeIsParticle > 0.5f)
{
if (shaderFlags[i].IsCustomData1On())
{
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_CUSTOMDATA1_ON);
}
else
{
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_CUSTOMDATA1_ON);
}
if (shaderFlags[i].IsCustomData2On())
{
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_CUSTOMDATA2_ON);
}
else
{
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_CUSTOMDATA2_ON);
}
}
switch (_fxLightMode)
{
case FxLightMode.UnLit:
mats[i].EnableKeyword("_FX_LIGHT_MODE_UNLIT");
mats[i].DisableKeyword("_FX_LIGHT_MODE_BLINN_PHONG");
mats[i].DisableKeyword("_FX_LIGHT_MODE_HALF_LAMBERT");
mats[i].DisableKeyword("_FX_LIGHT_MODE_PBR");
mats[i].DisableKeyword("_FX_LIGHT_MODE_SIX_WAY");
mats[i].DisableKeyword("EVALUATE_SH_VERTEX");
break;
case FxLightMode.BlinnPhong:
mats[i].DisableKeyword("_FX_LIGHT_MODE_UNLIT");
mats[i].EnableKeyword("_FX_LIGHT_MODE_BLINN_PHONG");
mats[i].DisableKeyword("_FX_LIGHT_MODE_HALF_LAMBERT");
mats[i].DisableKeyword("_FX_LIGHT_MODE_PBR");
mats[i].DisableKeyword("_FX_LIGHT_MODE_SIX_WAY");
mats[i].DisableKeyword("EVALUATE_SH_VERTEX");
break;
case FxLightMode.HalfLambert:
mats[i].DisableKeyword("_FX_LIGHT_MODE_UNLIT");
mats[i].DisableKeyword("_FX_LIGHT_MODE_BLINN_PHONG");
mats[i].EnableKeyword("_FX_LIGHT_MODE_HALF_LAMBERT");
mats[i].DisableKeyword("_FX_LIGHT_MODE_PBR");
mats[i].DisableKeyword("_FX_LIGHT_MODE_SIX_WAY");
mats[i].DisableKeyword("EVALUATE_SH_VERTEX");
break;
case FxLightMode.PBR:
mats[i].DisableKeyword("_FX_LIGHT_MODE_UNLIT");
mats[i].DisableKeyword("_FX_LIGHT_MODE_BLINN_PHONG");
mats[i].DisableKeyword("_FX_LIGHT_MODE_HALF_LAMBERT");
mats[i].EnableKeyword("_FX_LIGHT_MODE_PBR");
mats[i].DisableKeyword("_FX_LIGHT_MODE_SIX_WAY");
mats[i].DisableKeyword("EVALUATE_SH_VERTEX");
break;
case FxLightMode.SixWay:
mats[i].DisableKeyword("_FX_LIGHT_MODE_UNLIT");
mats[i].DisableKeyword("_FX_LIGHT_MODE_BLINN_PHONG");
mats[i].DisableKeyword("_FX_LIGHT_MODE_HALF_LAMBERT");
mats[i].DisableKeyword("_FX_LIGHT_MODE_PBR");
mats[i].EnableKeyword("_FX_LIGHT_MODE_SIX_WAY");
mats[i].EnableKeyword("EVALUATE_SH_VERTEX");//强制六面体使用顶点SH。
break;
}
perf
2025-07-21 05:42:20 -04:00
if (!shaderFlags[i].CheckIsUVModeOn(W9ParticleShaderFlags.UVMode.SpecialUVChannel))
{
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_USE_TEXCOORD1, index: 1);
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_USE_TEXCOORD2, index: 1);
}
if (!shaderFlags[i].CheckIsUVModeOn(W9ParticleShaderFlags.UVMode.Cylinder))
{
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_CYLINDER_CORDINATE, index: 1);
}
TransparentMode transparentMode = (TransparentMode)mats[i].GetFloat("_TransparentMode");
111
2025-08-27 21:45:18 -04:00
int queueBias = (int)mats[i].GetFloat("_QueueBias");
switch (transparentMode)
perf
2025-07-21 05:42:20 -04:00
{
case TransparentMode.Opaque:
mats[i].SetInt("_ZWrite", (int)1);
111
2025-08-27 21:45:18 -04:00
mats[i].renderQueue = 2100 + queueBias; //3D粒子永远最前显示
perf
2025-07-21 05:42:20 -04:00
mats[i].SetInt("_Blend", (int)BlendMode.Opaque);
break;
case TransparentMode.Transparent:
111
2025-08-27 21:45:18 -04:00
mats[i].SetInt("_ZWrite", (int)0);
perf
2025-07-21 05:42:20 -04:00
int defaultQueue = 3100;
111
2025-08-27 21:45:18 -04:00
if (_uiEffectEnabled == 1)
perf
2025-07-21 05:42:20 -04:00
{
defaultQueue = 3000;
}
111
2025-08-27 21:45:18 -04:00
mats[i].renderQueue = defaultQueue + queueBias; //3D粒子永远最前显示
perf
2025-07-21 05:42:20 -04:00
BlendMode bm = (BlendMode)mats[i].GetFloat("_Blend");
if (bm == BlendMode.Opaque)
{
mats[i].SetFloat("_Blend", (float)BlendMode.Alpha); //如果设置错误则强制设置。
}
break;
case TransparentMode.CutOff:
mats[i].SetInt("_ZWrite", (int)1);
111
2025-08-27 21:45:18 -04:00
mats[i].renderQueue = 2450 + queueBias; //3D粒子永远最前显示
perf
2025-07-21 05:42:20 -04:00
mats[i].SetInt("_Blend", (int)BlendMode.Opaque);
break;
}
111
2025-08-27 21:45:18 -04:00
float forceZWriteToggle = mats[i].GetFloat("_ForceZWriteToggle");
if ( forceZWriteToggle > 0.5f&& forceZWriteToggle<1.5f)
{
mats[i].SetInt("_ZWrite", (int)1);
}
else if(forceZWriteToggle > 1.5f)
{
mats[i].SetInt("_ZWrite", (int)0);
}
perf
2025-07-21 05:42:20 -04:00
if (_transparentMode == TransparentMode.CutOff)
{
mats[i].EnableKeyword("_ALPHATEST_ON");
}
else
{
mats[i].DisableKeyword("_ALPHATEST_ON");
}
// blendMode
BlendMode blendMode = (BlendMode)mats[i].GetFloat("_Blend");
switch (blendMode)
{
case BlendMode.Alpha:
mats[i].SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
mats[i].SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
111
2025-08-27 21:45:18 -04:00
mats[i].DisableKeyword("_ALPHAPREMULTIPLY_ON");
mats[i].DisableKeyword("_ALPHAMODULATE_ON");
perf
2025-07-21 05:42:20 -04:00
break;
case BlendMode.Premultiply:
mats[i].SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
mats[i].SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
111
2025-08-27 21:45:18 -04:00
mats[i].EnableKeyword("_ALPHAPREMULTIPLY_ON");
mats[i].DisableKeyword("_ALPHAMODULATE_ON");
perf
2025-07-21 05:42:20 -04:00
break;
case BlendMode.Additive:
111
2025-08-27 21:45:18 -04:00
mats[i].SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
mats[i].SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
mats[i].EnableKeyword("_ALPHAPREMULTIPLY_ON");
mats[i].DisableKeyword("_ALPHAMODULATE_ON");
perf
2025-07-21 05:42:20 -04:00
break;
case BlendMode.Multiply:
mats[i].SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.DstColor);
111
2025-08-27 21:45:18 -04:00
mats[i].SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
mats[i].DisableKeyword("_ALPHAPREMULTIPLY_ON");
mats[i].EnableKeyword("_ALPHAMODULATE_ON");
perf
2025-07-21 05:42:20 -04:00
break;
case BlendMode.Opaque:
mats[i].SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
mats[i].SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
111
2025-08-27 21:45:18 -04:00
mats[i].DisableKeyword("_ALPHAPREMULTIPLY_ON");
perf
2025-07-21 05:42:20 -04:00
break;
}
TimeMode timeMode = (TimeMode)mats[i].GetFloat("_TimeMode");
switch (timeMode)
{
case TimeMode.Default:
// setMaterialFlags(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_UNSCALETIME_ON, false);
// setMaterialFlags(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_SCRIPTABLETIME_ON, false);
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_UNSCALETIME_ON);
shaderFlags[i].CheckFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_SCRIPTABLETIME_ON);
break;
case TimeMode.UnScaleTime:
// setMaterialFlags(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_UNSCALETIME_ON, true);
// setMaterialFlags(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_SCRIPTABLETIME_ON, false);
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_UNSCALETIME_ON);
shaderFlags[i].CheckFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_SCRIPTABLETIME_ON);
break;
case TimeMode.ScriptableTime:
// setMaterialFlags(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_UNSCALETIME_ON, false);
// setMaterialFlags(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_SCRIPTABLETIME_ON, true);
shaderFlags[i].CheckFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_UNSCALETIME_ON);
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_SCRIPTABLETIME_ON);
break;
}
}
}
public static GUIContent VertexStreams = new GUIContent("顶点流统计",
"The vertex streams needed for this Material to function properly.");
public static string streamPositionText = "Position (POSITION.xyz)";
public static string streamNormalText = "Normal (NORMAL.xyz)";
public static string streamColorText = "Color (COLOR.xyzw)";
public static string streamUVText = "UV (TEXCOORD0.xy)";
public static string streamUV3Text = "UV3 (TEXCOORD0.zw)";
public static string streamUV2Text = "UV2 (TEXCOORD0.zw)";
public static string streamUV2AndAnimBlendText = "UV2 (TEXCOORD3.zw)";
public static string streamUV3AndAnimBlendText = "UV3 (TEXCOORD3.zw)";
public static string streamAnimBlendText = "AnimBlend (TEXCOORD3.x)";
public static string streamTangentText = "Tangent (TANGENT.xyzw)";
public static string streamCustom1Text = "Custom1.xyzw(TEXCOORD1.xyzw)";
public static string streamCustom2Text = "Custom2.xyzw(TEXCOORD2.xyzw)";
public static GUIContent streamApplyToAllSystemsText = new GUIContent("使粒子与材质顶点流相同",
"Apply the vertex stream layout to all Particle Systems using this material");
public static string undoApplyCustomVertexStreams = L10n.Tr("Apply custom vertex streams from material");
111
2025-08-27 21:45:18 -04:00
List<ParticleSystemRenderer> m_ParticleRenderersUsingThisMaterial = new List<ParticleSystemRenderer>();
List<Renderer> m_RenderersUsingThisMaterial = new List<Renderer>();
perf
2025-07-21 05:42:20 -04:00
private bool checkIsParicleSystem = false;
void CacheRenderersUsingThisMaterial(Material material, int matID)
{
checkIsParicleSystem = false;
111
2025-08-27 21:45:18 -04:00
m_ParticleRenderersUsingThisMaterial.Clear();
perf
2025-07-21 05:42:20 -04:00
m_RenderersUsingThisMaterial.Clear();
111
2025-08-27 21:45:18 -04:00
// #if UNITY_2022_1_OR_NEWER
// ParticleSystemRenderer[] renderers =
// UnityEngine.Object.FindObjectsByType(typeof(ParticleSystemRenderer),FindObjectsSortMode.None) as ParticleSystemRenderer[];
// #else
Renderer[] renderers =
UnityEngine.Object.FindObjectsOfType(typeof(Renderer)) as Renderer[];//为了兼容性使用较慢版本
if (renderers != null)
{
m_RenderersUsingThisMaterial = renderers.ToList();
_helper.renderersUsingThisMaterial = m_RenderersUsingThisMaterial;
}
// #endif
foreach (Renderer renderer in renderers)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
if (renderer is ParticleSystemRenderer)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
ParticleSystemRenderer psr = renderer as ParticleSystemRenderer;
if (psr.sharedMaterial == material || psr.trailMaterial == material)
{
checkIsParicleSystem = true;
shaderFlags[matID].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_ANIMATION_SHEET_HELPER,index:1);//如果是粒子系统用，就主动关掉Helper的类型。
m_ParticleRenderersUsingThisMaterial.Add(psr);
}
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
perf
2025-07-21 05:42:20 -04:00
}
}
//雨轩：UnityEditorInternal命名空间下提供 一个类ReorderableList可以实现通过拖曳来达到列表元素的重新排序。
private static ReorderableList vertexStreamList;
//构建粒子系统顶点流界面
public void DoVertexStreamsArea(Material material, List<ParticleSystemRenderer> renderers,
int matID, bool useLighting = false)
{
EditorGUILayout.Space();
// bool useFlipbookBlending = (material.GetFloat("_FlipbookBlending") > 0.0f);
bool useFlipbookBlending = material.IsKeywordEnabled("_FLIPBOOKBLENDING_ON");
bool useSpecialUVChannel = shaderFlags[matID].CheckIsUVModeOn(W9ParticleShaderFlags.UVMode.SpecialUVChannel);
bool isUseUV3ForSpecialUV =
shaderFlags[matID].CheckFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_USE_TEXCOORD2, index:1);
// bool CustomDataEnabled = (material.GetFloat("_CustomData") > 0.0f);
bool isCustomData1 = shaderFlags[matID].CheckFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_CUSTOMDATA1_ON);
bool isCustomData2 = shaderFlags[matID].CheckFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_CUSTOMDATA2_ON);
// Build the list of expected vertex streams
List<ParticleSystemVertexStream> streams = new List<ParticleSystemVertexStream>();
List<string> streamList = new List<string>();
streams.Add(ParticleSystemVertexStream.Position); //必然会传递有顶点位置信息
streamList.Add(streamPositionText); //记录顶点位置信息，给GUI面板用
bool needTangent = false;
bool needNormal = false;
needNormal = (material.GetFloat("_VertexOffset_NormalDir_Toggle") > 0.5f);
//如果有灯光，必有法线信息。如果有法线贴图，必有顶点切线法线信息。
//菲涅尔效果需要用到法线内容。
if (material.GetFloat("_fresnelEnabled") > 0.5f)
{
needNormal = true;
needTangent = true;
}
if (material.GetFloat("_ParallaxMapping_Toggle") > 0.5f)
{
needTangent = true;
}
111
2025-08-27 21:45:18 -04:00
if (_fxLightMode != FxLightMode.UnLit || material.GetFloat("_BumpMapToggle") > 0.5f)
{
needNormal = true;
needTangent = true;
}
perf
2025-07-21 05:42:20 -04:00
bool useUV3AsMainUV = shaderFlags[matID].CheckFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_USETEXCOORD2);
if (needTangent)
{
streams.Add(ParticleSystemVertexStream.Tangent);
streamList.Add(streamTangentText);
}
if (needNormal)
{
streams.Add(ParticleSystemVertexStream.Normal);
streamList.Add(streamNormalText);
}
//粒子着色器，必有顶点颜色信息。
streams.Add(ParticleSystemVertexStream.Color);
streamList.Add(streamColorText);
//TEXCOORD0填充
//必有顶点第一套UV信息。
streams.Add(ParticleSystemVertexStream.UV);
streamList.Add(streamUVText);
//在做动画序列帧时，需要:TEXCOORD1(xy为正常uv，zw为Blend用的第二套uv)，:TEXCOORD2(x为Blend混合值)
if (useFlipbookBlending && useSpecialUVChannel)
{
streams.Add(ParticleSystemVertexStream.UV2);
streamList.Add(streamUV2Text);
}
else if (useSpecialUVChannel & !useFlipbookBlending)
{
if (isUseUV3ForSpecialUV)
{
streams.Add(ParticleSystemVertexStream.UV3);
streamList.Add(streamUV3Text);
}
else
{
streams.Add(ParticleSystemVertexStream.UV2);
streamList.Add(streamUV2Text);
}
}
else if (useFlipbookBlending & !useSpecialUVChannel)
{
if (!streams.Contains(ParticleSystemVertexStream.UV2))
{
streams.Add(ParticleSystemVertexStream.UV2);
streamList.Add(streamUV2Text);
}
}
else if(isCustomData1 || isCustomData2)
{
streams.Add(ParticleSystemVertexStream.UV2);
streamList.Add(streamUV2Text);
}
//填充TEXCOORD1
bool isFillSkipUV2 = false;//因为如果要使用UV3，粒子系统必须填充UV2才能激活
if (isCustomData1 || isCustomData2 || useFlipbookBlending)
{
streams.Add(ParticleSystemVertexStream.Custom1XYZW);
streamList.Add(streamCustom1Text);
}
else if(useSpecialUVChannel & isUseUV3ForSpecialUV)
{
streams.Add(ParticleSystemVertexStream.UV2);
streamList.Add("TEXCOORD1.xy");
isFillSkipUV2 = true;
}
//填充TEXCOORD2
if (isCustomData2 || useFlipbookBlending)
{
streams.Add(ParticleSystemVertexStream.Custom2XYZW);
streamList.Add(streamCustom2Text);
}
else if(useSpecialUVChannel & isUseUV3ForSpecialUV & !isFillSkipUV2)
{
streams.Add(ParticleSystemVertexStream.UV2);
streamList.Add("TEXCOORD2.xy");
isFillSkipUV2 = true;
}
//填充TEXCOORD3
if (useFlipbookBlending)
{
streams.Add(ParticleSystemVertexStream.AnimBlend);
streamList.Add(streamAnimBlendText);
if (useSpecialUVChannel)
{
if (isUseUV3ForSpecialUV)
{
streams.Add(ParticleSystemVertexStream.UV3);
streamList.Add(streamUV3AndAnimBlendText);
}
}
}
else if(useSpecialUVChannel & isUseUV3ForSpecialUV & !isFillSkipUV2)
{
streams.Add(ParticleSystemVertexStream.UV2);
streamList.Add("TEXCOORD3.xy");
}
//可排序列表绘制。
//创建一个可排序列表
vertexStreamList = new ReorderableList(streamList, typeof(string), false, true, false, false);
//创建表头。ReorderableList下面还有很多回调。可以按需选择。
vertexStreamList.drawHeaderCallback = (Rect rect) => { EditorGUI.LabelField(rect, "Vertex Streams"); };
vertexStreamList.DoLayoutList(); //执行表格绘制。
// Display a warning if any renderers have incorrect vertex streams
string Warnings = "";
List<ParticleSystemVertexStream> rendererStreams = new List<ParticleSystemVertexStream>();
foreach (ParticleSystemRenderer renderer in renderers) //每个使用该材质的粒子系统都会进行比较
{
renderer.GetActiveVertexStreams(rendererStreams); //获得ParticleSystemRenderer的顶点流
if (!rendererStreams.SequenceEqual(streams)) //重点！是否和我们拼装的顶点流一致。
Warnings += "-" + renderer.name + "\n";
}
//
if (!string.IsNullOrEmpty(Warnings))
{
//如果有Warning
EditorGUILayout.HelpBox(
"下面的粒子系统Renderer顶点流不正确:\n" +
Warnings, MessageType.Error, true);
// Set the streams on all systems using this materialz
if (GUILayout.Button("使粒子与材质顶点流相同", EditorStyles.miniButton,
GUILayout.ExpandWidth(true)))
{
//做一个撤回记录。
Undo.RecordObjects(renderers.Where(r => r != null).ToArray(), "Apply custom vertex streams from material");
//重点！直接赋值我们拼装好的顶点流。
foreach (ParticleSystemRenderer renderer in renderers)
{
renderer.SetActiveVertexStreams(streams);
}
}
}
//从2022.3.11开始添加这个功能。
#if UNITY_2022_3_OR_NEWER && !(UNITY_2022_3_0 ||UNITY_2022_3_1||UNITY_2022_3_2||UNITY_2022_3_3||UNITY_2022_3_4||UNITY_2022_3_5||UNITY_2022_3_6||UNITY_2022_3_7||UNITY_2022_3_8||UNITY_2022_3_9||UNITY_2022_3_10)
// Display a warning if any renderers have incorrect vertex streams
string trailWarnings = "";
List<ParticleSystemVertexStream> trailRendererStreams = new List<ParticleSystemVertexStream>();
foreach (ParticleSystemRenderer renderer in renderers) //每个使用该材质的粒子系统都会进行比较
{
renderer.GetActiveTrailVertexStreams(trailRendererStreams); //获得ParticleSystemRenderer的顶点流
if (!trailRendererStreams.SequenceEqual(streams)) //重点！是否和我们拼装的顶点流一致。
trailWarnings += "-" + renderer.name + "\n";
}
if (!string.IsNullOrEmpty(trailWarnings))
{
//如果有Warning
EditorGUILayout.HelpBox(
"下面的粒子系统Renderer拖尾顶点流不正确:\n" +
trailWarnings, MessageType.Error, true);
// Set the streams on all systems using this material
if (GUILayout.Button("使粒子拖尾与材质顶点流相同", EditorStyles.miniButton,
GUILayout.ExpandWidth(true)))
{
//做一个撤回记录。
Undo.RecordObjects(renderers.Where(r => r != null).ToArray(), "Apply custom vertex streams from material");
//重点！直接赋值我们拼装好的顶点流。
foreach (ParticleSystemRenderer renderer in renderers)
{
renderer.SetActiveTrailVertexStreams(streams);
}
}
}
#endif
}
private string[] _customDataOptions =
{
"**不使用**",
"CustomData1_X",
"CustomData1_Y",
"CustomData1_Z",
"CustomData1_W",
"CustomData2_X",
"CustomData2_Y",
"CustomData2_Z",
"CustomData2_W"
};
111
2025-08-27 21:45:18 -04:00
bool CustomDataHasMixedValue(int dataBitPos, int dataIndex)
{
W9ParticleShaderFlags.CutomDataComponent
component = W9ParticleShaderFlags.CutomDataComponent.UnKnownOrMixed;
for (int i = 0; i < shaderFlags.Count; i++)
{
W9ParticleShaderFlags.CutomDataComponent curComponent =
shaderFlags[i].GetCustomDataFlag(dataBitPos, dataIndex);
if (i == 0)
{
component = curComponent;
}
else
{
if (component != curComponent) return true;
}
}
return false;
}
perf
2025-07-21 05:42:20 -04:00
public void DrawCustomDataSelect(string label, int dataBitPos, int dataIndex)
{
// if(!_isUseParticleSystem)return;//只有粒子系统才会处理相关内容。
111
2025-08-27 21:45:18 -04:00
// if (mats.Count != 1) return; //仅单选触发
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
if(_meshSourceModeIsParticle <=0 ) return;
(string, string) nameTuple = (label, "");
//-------------这里需要处理多选情况--------------
EditorGUI.showMixedValue = CustomDataHasMixedValue(dataBitPos, dataIndex);
perf
2025-07-21 05:42:20 -04:00
W9ParticleShaderFlags.CutomDataComponent component = shaderFlags[0].GetCustomDataFlag(dataBitPos, dataIndex);
EditorGUI.BeginChangeCheck();
111
2025-08-27 21:45:18 -04:00
EditorGUILayout.BeginHorizontal();
component = (W9ParticleShaderFlags.CutomDataComponent)EditorGUILayout.Popup(new GUIContent(label), (int)component, _customDataOptions);
EditorGUI.showMixedValue = false;
Action customDataDrawEndChangeCheck = () =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
for (int i = 0; i < shaderFlags.Count; i++)
{
shaderFlags[i].SetCustomDataFlag(component,dataBitPos,dataIndex);
}
_helper.ResetTool.CheckOnValueChange(nameTuple);
};
perf
2025-07-21 05:42:20 -04:00
if (EditorGUI.EndChangeCheck())
{
111
2025-08-27 21:45:18 -04:00
customDataDrawEndChangeCheck();
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
_helper.ResetTool.DrawResetModifyButton(new Rect(),nameTuple,
resetCallBack:()=>
{
component = 0;
customDataDrawEndChangeCheck();
},onValueChangedCallBack:customDataDrawEndChangeCheck,
checkHasModifyOnValueChange: () => shaderFlags[0].GetCustomDataFlag(dataBitPos, dataIndex)!= 0 ,
checkHasMixedValueOnValueChange:()=>CustomDataHasMixedValue(dataBitPos, dataIndex));
EditorGUILayout.EndHorizontal();
_helper.ResetTool.EndResetModifyButtonScope();
perf
2025-07-21 05:42:20 -04:00
}
private string[] _uvModeNames =
{
"默认UV通道",
"特殊UV通道",
"极坐标|旋转",
"圆柱无缝"
};
enum SpecialUVChannelMode
{
UV2_Texcoord1,
UV3_Texcoord2
}
111
2025-08-27 21:45:18 -04:00
bool UvModeHasMixedValue(int uvModeBitPos, int uvModeFlagIndex)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
W9ParticleShaderFlags.UVMode uvMode = W9ParticleShaderFlags.UVMode.UnknownOrMixed;
for (int i = 0; i < shaderFlags.Count; i++)
{
if (i == 0)
{
uvMode = shaderFlags[i].GetUVMode(uvModeBitPos, uvModeFlagIndex);
}
else
{
if (uvMode != shaderFlags[i].GetUVMode(uvModeBitPos, uvModeFlagIndex))
{
return true;
}
}
}
return false;
}
public void DrawUVModeSelect(int foldOutFlagBit, int foldOutFlagIndex,string label, int uvModeBitPos, int uvModeFlagIndex,MaterialProperty textureProp = null,bool forceEnable = false)
{
// if(textureProp.hasMixedValue) return;
if(forceEnable)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
EditorGUI.BeginDisabledGroup(false);
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
else if (textureProp != null)
{
EditorGUI.BeginDisabledGroup(!textureProp.textureValue);
}
else
{
EditorGUI.BeginDisabledGroup(false);
}
bool uvModeHasMixedValue = UvModeHasMixedValue(uvModeBitPos, uvModeFlagIndex);
EditorGUI.showMixedValue = uvModeHasMixedValue;
(string, string) wrapModeNameTuple = (label, "");
perf
2025-07-21 05:42:20 -04:00
EditorGUILayout.BeginHorizontal();
Rect rect = EditorGUILayout.GetControlRect();
111
2025-08-27 21:45:18 -04:00
var labelRect = new Rect(rect.x , rect.y, rect.width, rect.height);
var popUpRect = _helper.GetRectAfterLabelWidth(rect,true);
bool isChangeUVMode = false;
EditorGUI.BeginChangeCheck();
W9ParticleShaderFlags.UVMode uvMode = shaderFlags[0].GetUVMode(uvModeBitPos, uvModeFlagIndex);
Action drawUVModeEndChangeCheck = () =>
{
isChangeUVMode = true;
for (int i = 0; i < shaderFlags.Count; i++)
{
shaderFlags[i].SetUVMode(uvMode, uvModeBitPos, uvModeFlagIndex);
}
_helper.ResetTool.CheckOnValueChange(wrapModeNameTuple);
};
uvMode = (W9ParticleShaderFlags.UVMode) EditorGUI.Popup(popUpRect, (int)uvMode, _uvModeNames);
if (EditorGUI.EndChangeCheck())
{
drawUVModeEndChangeCheck();
}
perf
2025-07-21 05:42:20 -04:00
bool foldOutState = shaderFlags[0].CheckFlagBits(foldOutFlagBit, index: foldOutFlagIndex);
111
2025-08-27 21:45:18 -04:00
AnimBool animBool = _helper.GetAnimBool(foldOutFlagBit, foldOutFlagIndex-3, foldOutFlagIndex);
perf
2025-07-21 05:42:20 -04:00
animBool.target = foldOutState;
111
2025-08-27 21:45:18 -04:00
if (!uvModeHasMixedValue && uvMode == W9ParticleShaderFlags.UVMode.DefaultUVChannel)
{
animBool.target = false;
}
else
{
animBool.target = EditorGUI.Foldout(rect, animBool.target, string.Empty, true);
if (isChangeUVMode)
{
animBool.target = true;
}
}
perf
2025-07-21 05:42:20 -04:00
foldOutState = animBool.target;
if (foldOutState)
{
shaderFlags[0].SetFlagBits(foldOutFlagBit, index: foldOutFlagIndex);
}
else
{
shaderFlags[0].ClearFlagBits(foldOutFlagBit, index: foldOutFlagIndex);
}
EditorGUI.LabelField(labelRect,label);
111
2025-08-27 21:45:18 -04:00
_helper.ResetTool.DrawResetModifyButton(new Rect(),wrapModeNameTuple,
resetCallBack: () =>
{
uvMode = 0;
drawUVModeEndChangeCheck();
},onValueChangedCallBack: drawUVModeEndChangeCheck,checkHasModifyOnValueChange: () =>
{
return shaderFlags[0].GetUVMode(uvModeBitPos, uvModeFlagIndex) != 0;
},checkHasMixedValueOnValueChange:()=>UvModeHasMixedValue(uvModeBitPos, uvModeFlagIndex));
perf
2025-07-21 05:42:20 -04:00
EditorGUILayout.EndHorizontal();
111
2025-08-27 21:45:18 -04:00
_helper.ResetTool.EndResetModifyButtonScope();
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
perf
2025-07-21 05:42:20 -04:00
EditorGUI.showMixedValue = false;
111
2025-08-27 21:45:18 -04:00
if (!uvModeHasMixedValue)
{
EditorGUI.indentLevel++;
float faded = animBool.faded;
if (faded == 0) faded = 0.0001f;
EditorGUILayout.BeginFadeGroup(faded);
perf
2025-07-21 05:42:20 -04:00
if (uvMode != W9ParticleShaderFlags.UVMode.DefaultUVChannel)
{
EditorGUILayout.LabelField("以下设置材质内通用:",EditorStyles.boldLabel);
}
111
2025-08-27 21:45:18 -04:00
Action drawSpecialUVChannel = () =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
_helper.DrawPopUp("特殊UV通道选择","_SpecialUVChannelMode", Enum.GetNames(typeof(SpecialUVChannelMode)),
drawOnValueChangedBlock:
specialUVChannelMode =>
{
//在OnValueChange的时候。就已经是一起Set了。
SpecialUVChannelMode spUVMode = (SpecialUVChannelMode)specialUVChannelMode.floatValue;
for (int i = 0; i < shaderFlags.Count; i++)
perf
2025-07-21 05:42:20 -04:00
{
switch (spUVMode)
{
case SpecialUVChannelMode.UV2_Texcoord1:
111
2025-08-27 21:45:18 -04:00
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_USE_TEXCOORD1,index:1);
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_USE_TEXCOORD2,index:1);
perf
2025-07-21 05:42:20 -04:00
break;
case SpecialUVChannelMode.UV3_Texcoord2:
111
2025-08-27 21:45:18 -04:00
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_USE_TEXCOORD1,index:1);
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_USE_TEXCOORD2,index:1);
perf
2025-07-21 05:42:20 -04:00
break;
111
2025-08-27 21:45:18 -04:00
//TODO:如果所有UVMode都没有开启，需要都Clear。
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
}
},isSharedGlobalParent:true);
};
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
Action drawPolarOrTwirl = () =>
{
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBitTwril,3,GetAnimBoolIndex(3),"旋转扭曲","_UTwirlEnabled",flagBitsName:W9ParticleShaderFlags.FLAG_BIT_PARTICLE_UTWIRL_ON,isSharedGlobalParent:true,drawBlock:(isToggle) =>{
_helper.DrawVector4In2Line("_TWParameter","旋转扭曲中心",true);
_helper.DrawFloat("旋转扭曲强度","_TWStrength");
});
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBitPolar,3,GetAnimBoolIndex(3),"极坐标", "_PolarCoordinatesEnabled",W9ParticleShaderFlags.FLAG_BIT_PARTICLE_POLARCOORDINATES_ON,isSharedGlobalParent:true,drawBlock:(isToggle) =>{
// _helper.DrawToggle("极坐标只影响特殊功能","_PolarCordinateOnlySpecialFunciton_Toggle",W9ParticleShaderFlags.FLAG_BIT_PARTICLE_PC_ONLYSPECIALFUNC);
_helper.DrawVector4In2Line("_PCCenter","极坐标中心",true);
_helper.DrawVector4Component("极坐标强度","_PCCenter","z",true,0f,1f);
});
};
if (_helper.ResetTool.IsInitResetData)
{
drawSpecialUVChannel();
drawPolarOrTwirl();
}
else
{
switch (uvMode)
{
case W9ParticleShaderFlags.UVMode.SpecialUVChannel:
drawSpecialUVChannel();
break;
case W9ParticleShaderFlags.UVMode.PolarOrTwirl:
drawPolarOrTwirl();
break;
case W9ParticleShaderFlags.UVMode.Cylinder:
EditorGUILayout.LabelField("圆柱坐标模式尚未开发完成！");
// EditorGUILayout.LabelField("圆柱模式消耗比较大，慎用");
// _helper.DrawVector4XYZComponet("圆柱坐标旋转","_CylinderUVRotate");
// _helper.DrawVector4XYZComponet("圆柱坐标偏移","_CylinderUVPosOffset");
// Matrix4x4 cylinderMatrix =
// Matrix4x4.Translate(_helper.GetProperty("_CylinderUVPosOffset").vectorValue) *
// Matrix4x4.Rotate(Quaternion.Euler(_helper.GetProperty("_CylinderUVRotate").vectorValue));
// _helper.GetProperty("_CylinderMatrix0").vectorValue =cylinderMatrix.GetRow(0);
// _helper.GetProperty("_CylinderMatrix1").vectorValue =cylinderMatrix.GetRow(1);
// _helper.GetProperty("_CylinderMatrix2").vectorValue =cylinderMatrix.GetRow(2);
// _helper.GetProperty("_CylinderMatrix3").vectorValue =cylinderMatrix.GetRow(3);
//
// if (!uvModeHasMixedValue)
// {
// for (int i = 0; i < shaderFlags.Count; i++)
// {
// shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_CYLINDER_CORDINATE,index:1);
// //TODO:如果所有UVMode都没有开启，需要都Clear。
// }
// }
break;
}
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
EditorGUILayout.EndFadeGroup();
EditorGUI.indentLevel--;
}
perf
2025-07-21 05:42:20 -04:00
EditorGUI.EndDisabledGroup();
}
private string[] _meshSourceModeNames =
{
"粒子系统",
"模型（非粒子发射）",
"2D RawImage",
"2D 精灵",
"2D 材质贴图",
"2D UIParticle"
};
enum MeshSourceMode
{
Particle,
Mesh,
UIEffectRawImage,
UIEffectSprite,
UIEffectBaseMap,
111
2025-08-27 21:45:18 -04:00
UIParticle,
UnKnowOrMixed = -1
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
bool ColorChannelHasMixedValue(int colorChannelBitPos)
{
W9ParticleShaderFlags.ColorChannel colorChannel = W9ParticleShaderFlags.ColorChannel.UnKnownOrMixedValue;
for (int i = 0; i < shaderFlags.Count; i++)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
W9ParticleShaderFlags.ColorChannel curChannel = shaderFlags[i].GetColorChanel(colorChannelBitPos);
if (i == 0)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
colorChannel = curChannel;
}
else
{
if(colorChannel != curChannel) return true;
perf
2025-07-21 05:42:20 -04:00
}
}
111
2025-08-27 21:45:18 -04:00
return false;
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
private string[] _colorChannelNames = { "R", "G", "B", "A" };
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
public void DrawColorChannelSelect(string label, int colorChannelBitPos,int defaultChannel = 0)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
bool hasMixedValue = ColorChannelHasMixedValue(colorChannelBitPos);
EditorGUI.showMixedValue = hasMixedValue;
(string, string) nameTuple = (label, "");
perf
2025-07-21 05:42:20 -04:00
111
2025-08-27 21:45:18 -04:00
W9ParticleShaderFlags.ColorChannel chanel = shaderFlags[0].GetColorChanel(colorChannelBitPos);
EditorGUI.BeginChangeCheck();
EditorGUILayout.BeginHorizontal();
int index = EditorGUILayout.Popup(label, (int)chanel,
_colorChannelNames);
Action colorChannelOnEndChangeCheck = () =>
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
for (int i = 0; i < shaderFlags.Count; i++)
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
shaderFlags[i].SetColorChanel((W9ParticleShaderFlags.ColorChannel)index,colorChannelBitPos);
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
_helper.ResetTool.CheckOnValueChange(nameTuple);
};
if (EditorGUI.EndChangeCheck())
perf
2025-07-21 05:42:20 -04:00
{
111
2025-08-27 21:45:18 -04:00
colorChannelOnEndChangeCheck();
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
EditorGUI.showMixedValue = false;
_helper.ResetTool.DrawResetModifyButton(new Rect(),nameTuple,
resetCallBack: () => { index = defaultChannel; },
onValueChangedCallBack: colorChannelOnEndChangeCheck,
checkHasModifyOnValueChange: () => { return shaderFlags[0].GetColorChanel(colorChannelBitPos) != (W9ParticleShaderFlags.ColorChannel)defaultChannel;},
checkHasMixedValueOnValueChange:()=>ColorChannelHasMixedValue(colorChannelBitPos));
EditorGUILayout.EndHorizontal();
_helper.ResetTool.EndResetModifyButtonScope();
perf
2025-07-21 05:42:20 -04:00
}
111
2025-08-27 21:45:18 -04:00
int GetAnimBoolIndex(int foldOutFlagIndex)
{
return foldOutFlagIndex - 3;
}
// private static readonly FieldInfo _validKeywordsField = typeof(Material)
// .GetField("m_ValidKeywords", BindingFlags.NonPublic | BindingFlags.Instance);
//
// public static string[] GetValidKeywordsDirect(Material material)
// {
// if (_validKeywordsField == null)
// {
// Debug.LogError("m_ValidKeywords field not found!");
// return null;
// }
//
// var keywords = _validKeywordsField.GetValue(material) as string[];
// return keywords;
// }
perf
2025-07-21 05:42:20 -04:00
}
}
Reference in New Issue Copy Permalink