2834 lines
146 KiB
C#
2834 lines
146 KiB
C#
using System;
|
||
using System.Linq;
|
||
using System.Collections.Generic;
|
||
using UnityEditorInternal;
|
||
using UnityEngine;
|
||
using UnityEngine.Rendering;
|
||
using stencilTestHelper;
|
||
using UnityEditor.AnimatedValues;
|
||
using System.Reflection;
|
||
using UnityEditor;
|
||
|
||
namespace NBShaderEditor
|
||
{
|
||
public class ParticleBaseGUI : ShaderGUI
|
||
{
|
||
private ShaderGUIHelper _helper = new ShaderGUIHelper();
|
||
public List<Material> mats = new List<Material>();
|
||
private Shader shader;
|
||
private MaterialEditor matEditor;
|
||
public List<W9ParticleShaderFlags> shaderFlags = new List<W9ParticleShaderFlags>();
|
||
|
||
private int lastFlagBit;
|
||
|
||
// private bool isCustomedStencil = false;//isCustomStencil应该各个材质各自控制。
|
||
private readonly int _isCustomedStencilPropID = Shader.PropertyToID("_CustomStencilTest");
|
||
private readonly string _defaultStencilKey = "ParticleBaseDefault";
|
||
|
||
private StencilValuesConfig _stencilValuesConfig;
|
||
|
||
private bool isInit = true;
|
||
|
||
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
|
||
{
|
||
//一定要初始化在第一行
|
||
mats.Clear();
|
||
shaderFlags.Clear();
|
||
for (int i = 0; i < materialEditor.targets.Length; i++)
|
||
{
|
||
var targetMat = materialEditor.targets[i] as Material;
|
||
|
||
mats.Add(targetMat);
|
||
shaderFlags.Add(new W9ParticleShaderFlags(mats[i]));
|
||
|
||
}
|
||
|
||
if (!_stencilValuesConfig)
|
||
{
|
||
_stencilValuesConfig =
|
||
AssetDatabase.LoadAssetAtPath<StencilValuesConfig>(
|
||
"Packages/com.xuanxuan.nb.shaders/Shader/StencilConfig.asset");
|
||
}
|
||
|
||
matEditor = materialEditor;
|
||
EditorGUIUtility.labelWidth = 180f;
|
||
_helper.Init(materialEditor, props, shaderFlags.ToArray(), mats);
|
||
|
||
if (isInit)
|
||
{
|
||
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());
|
||
|
||
EditorGUIUtility.labelWidth = 0f;
|
||
|
||
if (mats.Count == 1)
|
||
{
|
||
if (_meshSourceMode == MeshSourceMode.Particle || _meshSourceMode == MeshSourceMode.UIParticle)
|
||
{
|
||
DoVertexStreamsArea(mats[0], m_ParticleRenderersUsingThisMaterial, 0); //填充stream和stremList
|
||
mats[0].EnableKeyword("_CUSTOMDATA");
|
||
}
|
||
else
|
||
{
|
||
mats[0].DisableKeyword("_CUSTOMDATA");
|
||
}
|
||
}
|
||
|
||
if (EditorGUI.EndChangeCheck())
|
||
{
|
||
CacheRenderersUsingThisMaterial(mats[0], 0);
|
||
|
||
|
||
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));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
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;
|
||
|
||
public void DrawMeshOptions()
|
||
{
|
||
|
||
_helper.DrawPopUp("Mesh来源模式", "_MeshSourceMode", _meshSourceModeNames, drawBlock: modeProp =>
|
||
{
|
||
|
||
if (!modeProp.hasMixedValue)
|
||
{
|
||
_meshSourceMode = (MeshSourceMode)modeProp.floatValue;
|
||
}
|
||
else
|
||
{
|
||
_meshSourceMode = MeshSourceMode.UnKnowOrMixed;
|
||
}
|
||
|
||
for (int i = 0; i < mats.Count; i++)
|
||
{
|
||
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;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (checkIsParicleSystem)
|
||
{
|
||
if (_meshSourceModeIsParticle <= 0)
|
||
{
|
||
EditorGUILayout.HelpBox("检测到材质用在粒子系统上，和设置不匹配", MessageType.Error);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//这个不能Log，因为在Project面板下打开是不知道在不在粒子系统里的。
|
||
// if (_meshSourceMode == MeshSourceMode.Particle)
|
||
// {
|
||
// EditorGUILayout.HelpBox("检测到材质没有用在粒子系统上，和设置不匹配",MessageType.Error);
|
||
// }
|
||
}
|
||
});
|
||
|
||
_helper.DrawPopUp("透明模式", "_TransparentMode", transparentModeNames, drawBlock: transModeProp =>
|
||
{
|
||
if (!transModeProp.hasMixedValue)
|
||
{
|
||
_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;
|
||
}
|
||
});
|
||
}
|
||
}
|
||
else
|
||
{
|
||
_transparentMode = TransparentMode.UnKnowOrMixed;
|
||
}
|
||
|
||
});
|
||
}
|
||
|
||
public void DrawBaseOptions()
|
||
{
|
||
_helper.DrawFloat("整体颜色强度", "_BaseColorIntensityForTimeline");
|
||
_helper.DrawSlider("整体透明度", "_AlphaAll", rangePropertyName:"AlphaAllRangeVec");
|
||
if (_uiEffectEnabled == 0)
|
||
{
|
||
_helper.DrawPopUp("深度测试", "_ZTest", Enum.GetNames(typeof(CompareFunction)));
|
||
}
|
||
else if (_uiEffectEnabled == 1)
|
||
{
|
||
_helper.GetProperty("_ZTest").floatValue = 4.0f; //UI层使用默认值LessEqual
|
||
}
|
||
|
||
// _helper.DrawPopUp("时间模式","_TimeMode",Enum.GetNames(typeof(TimeMode)));
|
||
_helper.DrawPopUp("渲染面向", "_Cull", Enum.GetNames(typeof(RenderFace)));
|
||
|
||
|
||
|
||
if (_uiEffectEnabled == 0)
|
||
{
|
||
|
||
if (_transparentMode == TransparentMode.Transparent)
|
||
{
|
||
_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);
|
||
}
|
||
}
|
||
|
||
if (isBackFirstPass)
|
||
{
|
||
EditorGUILayout.HelpBox("预渲染反面会导致打断动态合批，请谨慎使用。", MessageType.Warning);
|
||
}
|
||
}
|
||
});
|
||
|
||
|
||
}
|
||
_helper.DrawPopUp("深度写入强制控制", "_ForceZWriteToggle",_ForceZWriteToggleNames);
|
||
|
||
|
||
|
||
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBit2BaseBackColor,5,GetAnimBoolIndex(5),"背面颜色", "_BaseBackColor_Toggle", W9ParticleShaderFlags.FLAG_BIT_PARTICLE_BACKCOLOR,
|
||
drawBlock:
|
||
(isToggle) =>
|
||
{
|
||
// matEditor.ColorProperty(_helper.GetProperty("_BaseBackColor"), "");
|
||
_helper.ColorProperty("背面颜色","_BaseBackColor");
|
||
});
|
||
|
||
|
||
}
|
||
|
||
if (_uiEffectEnabled == 0)
|
||
{
|
||
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBitDistanceFade, 3, GetAnimBoolIndex(3), "近距离透明",
|
||
"_DistanceFade_Toggle", W9ParticleShaderFlags.FLAG_BIT_PARTICLE_DISTANCEFADE_ON,
|
||
isIndentBlock: true, drawBlock: (isToggle) =>
|
||
{
|
||
_helper.DrawVector4In2Line("_Fade", "透明过度范围", true);
|
||
});
|
||
}
|
||
else
|
||
{
|
||
for (int i = 0; i < mats.Count; i++)
|
||
{
|
||
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_DISTANCEFADE_ON);
|
||
}
|
||
}
|
||
|
||
if (_uiEffectEnabled == 0)
|
||
{
|
||
_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);
|
||
}
|
||
else if (_uiEffectEnabled == 1)
|
||
{
|
||
_helper.GetProperty("_fogintensity").floatValue = 0;
|
||
}
|
||
}
|
||
|
||
public void DrawMainTexOptions()
|
||
{
|
||
Action drawAfterMainTex = () =>
|
||
{
|
||
DrawColorChannelSelect("主贴图透明度通道", W9ParticleShaderFlags.FLAG_BIT_COLOR_CHANNEL_POS_0_MAINTEX_ALPHA,3);
|
||
if (_meshSourceMode != MeshSourceMode.UIEffectSprite)
|
||
{
|
||
MaterialProperty textureProp = null;
|
||
if (_meshSourceMode == MeshSourceMode.UIEffectRawImage)
|
||
{
|
||
textureProp = _helper.GetProperty("_MainTex");
|
||
}
|
||
else
|
||
{
|
||
textureProp = _helper.GetProperty("_BaseMap");
|
||
}
|
||
|
||
DrawUVModeSelect(W9ParticleShaderFlags.foldOutBit1UVModeMainTex, 4, "主贴图UV来源",
|
||
W9ParticleShaderFlags.FLAG_BIT_UVMODE_POS_0_MAINTEX, 0, textureProp: textureProp);
|
||
}
|
||
|
||
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");
|
||
}
|
||
|
||
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);
|
||
});
|
||
|
||
_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);
|
||
});
|
||
|
||
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBit1MainTexColorRefine, 4, GetAnimBoolIndex(4),
|
||
"主贴图颜色修正", "_BaseMapColorRefine_Toggle",
|
||
W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_MAINTEX_COLOR_REFINE, 1, isIndentBlock: true, drawBlock:
|
||
(isToggle) =>
|
||
{
|
||
_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);
|
||
});
|
||
};
|
||
|
||
Action drawBaseMapFoldOut = () => {
|
||
_helper.DrawTextureFoldOut(W9ParticleShaderFlags.foldOutBitBaseMap, 3, GetAnimBoolIndex(3), "主贴图",
|
||
"_BaseMap", "_BaseColor", drawWrapMode: true,
|
||
flagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_BASEMAP, flagIndex: 2, drawBlock:
|
||
theBaseMap =>
|
||
{
|
||
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();
|
||
}
|
||
else
|
||
{
|
||
if (_useGraphicMainTex <= 0)
|
||
{
|
||
drawBaseMapFoldOut();
|
||
// _helper.DrawTexture("主贴图","_BaseMap","_BaseColor",drawWrapMode:true,flagBitsName:W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_BASEMAP,flagIndex:2);
|
||
}
|
||
else
|
||
{
|
||
drawUITextureModify();
|
||
//实际上贴图来自_MainTex
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
|
||
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 =>
|
||
{
|
||
if (!mode.hasMixedValue)
|
||
{
|
||
_fxLightMode = (FxLightMode)mode.floatValue;
|
||
if (_fxLightMode == FxLightMode.BlinnPhong || _fxLightMode == FxLightMode.PBR ||
|
||
_fxLightMode == FxLightMode.HalfLambert)
|
||
{
|
||
if (_fxLightMode == FxLightMode.BlinnPhong || _fxLightMode == FxLightMode.HalfLambert)
|
||
{
|
||
_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);
|
||
|
||
}
|
||
});
|
||
}
|
||
|
||
if (_fxLightMode == FxLightMode.PBR)
|
||
{
|
||
_helper.DrawVector4Component("金属度", "_MaterialInfo", "x", true, 0, 1);
|
||
_helper.DrawVector4Component("光滑度", "_MaterialInfo", "y", true, 0, 1);
|
||
}
|
||
}
|
||
else if (_fxLightMode == FxLightMode.SixWay)
|
||
{
|
||
_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);
|
||
});
|
||
}
|
||
else if (_fxLightMode == FxLightMode.SixWay)
|
||
{
|
||
//这里应该关掉法线和Matcap的Keyword
|
||
}
|
||
}
|
||
|
||
public void DrawFeatureOptions()
|
||
{
|
||
_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);
|
||
|
||
});
|
||
|
||
_helper.DrawPopUp("遮罩模式", "_MaskMapGradientToggle", _maskMapModeNames,
|
||
drawBlock: maskMapModeProp =>
|
||
{
|
||
Action drawMaskTexturePart = () =>
|
||
{
|
||
_helper.DrawTextureFoldOut(W9ParticleShaderFlags.foldOutBitMaskMap, 3,
|
||
GetAnimBoolIndex(3), "遮罩", "_MaskMap", drawWrapMode: true,
|
||
flagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_MASKMAP, flagIndex: 2,
|
||
drawBlock: theMaskMap =>
|
||
{
|
||
DrawColorChannelSelect("遮罩通道选择", W9ParticleShaderFlags.FLAG_BIT_COLOR_CHANNEL_POS_0_MASKMAP1);
|
||
});
|
||
};
|
||
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();
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
}, drawOnValueChangedBlock: maskMapModeProp =>
|
||
{
|
||
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);
|
||
}
|
||
}
|
||
});
|
||
|
||
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:
|
||
(isToggle) =>
|
||
{
|
||
_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);
|
||
}
|
||
}
|
||
|
||
});
|
||
|
||
});
|
||
_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) =>
|
||
{
|
||
if (isToggle.hasMixedValue)
|
||
{
|
||
_noiseEnabled = -1;
|
||
}
|
||
else
|
||
{
|
||
_noiseEnabled = isToggle.floatValue > 0.5f ? 1 : 0;
|
||
}
|
||
|
||
_helper.DrawToggle("用于屏幕扰动", "_ScreenDistortModeToggle", shaderKeyword: "_SCREEN_DISTORT_MODE",
|
||
drawEndChangeCheck: isScreenDistortToggle =>
|
||
{
|
||
if (!isScreenDistortToggle.hasMixedValue && isScreenDistortToggle.floatValue > 0.5f)
|
||
{
|
||
//强制设置为Clamp模式。
|
||
for (int i = 0; i < mats.Count; i++)
|
||
{
|
||
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_BASEMAP,
|
||
index: 2);
|
||
}
|
||
}
|
||
});
|
||
|
||
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);
|
||
});
|
||
});
|
||
});
|
||
|
||
_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(() =>
|
||
{
|
||
_helper.DrawToggle("色散强度受扭曲强度影响", "_Distortion_Choraticaberrat_WithNoise_Toggle",
|
||
W9ParticleShaderFlags.FLAG_BIT_PARTICLE_NOISE_CHORATICABERRAT_WITH_NOISE);
|
||
});
|
||
_helper.DrawVector4Component("色散强度", "_DistortionDirection", "z", false);
|
||
DrawCustomDataSelect("色散强度自定义曲线",
|
||
W9ParticleShaderFlags.FLAGBIT_POS_0_CUSTOMDATA_CHORATICABERRAT_INTENSITY, 0);
|
||
});
|
||
|
||
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBitEmission, 3, GetAnimBoolIndex(3), "流光(颜色相加)",
|
||
"_EmissionEnabled", shaderKeyword: "_EMISSION", isIndentBlock: true, fontStyle: FontStyle.Bold,
|
||
drawBlock: (isToggle) =>
|
||
{
|
||
MaterialProperty emissionFollowMainTexUVToggle = _helper.GetProperty("_EmissionFollowMainTexUV");
|
||
bool emissionFromMainTexUV = !emissionFollowMainTexUVToggle.hasMixedValue && emissionFollowMainTexUVToggle.floatValue > 0.5 ;
|
||
|
||
_helper.DrawTexture("流光贴图", "_EmissionMap", "_EmissionMapColor", drawWrapMode: !emissionFromMainTexUV,
|
||
wrapModeFlagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_EMISSIONMAP, flagIndex: 2,drawScaleOffset:!emissionFromMainTexUV,
|
||
drawBlock: theEmissionMap =>
|
||
{
|
||
if (!emissionFromMainTexUV)
|
||
{
|
||
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"); });
|
||
}
|
||
});
|
||
|
||
_helper.DrawToggle("流光贴图跟随主贴图UV","_EmissionFollowMainTexUV",flagBitsName:W9ParticleShaderFlags.FLAG_BIT_PARTICLE_EMISSION_FOLLOW_MAINTEX_UV);
|
||
_helper.DrawFloat("流光颜色强度", "_EmissionMapColorIntensity");
|
||
});
|
||
|
||
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutColorBlend, 3, GetAnimBoolIndex(3), "渐变(颜色相乘)",
|
||
"_ColorBlendMap_Toggle", shaderKeyword: "_COLORMAPBLEND", isIndentBlock: true,
|
||
fontStyle: FontStyle.Bold,
|
||
drawBlock: (isToggle) =>
|
||
{
|
||
|
||
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++)
|
||
{
|
||
if (alphaModeProp.floatValue > 0.5)
|
||
{
|
||
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_COLOR_BLEND_ALPHA_MULTIPLY_MODE);
|
||
}
|
||
else
|
||
{
|
||
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_COLOR_BLEND_ALPHA_MULTIPLY_MODE);
|
||
}
|
||
|
||
}
|
||
});
|
||
_helper.DrawVector4Component("颜色渐变图Alpha强度","_ColorBlendVec","z",true,0f,1f);
|
||
|
||
});
|
||
|
||
_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++)
|
||
{
|
||
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);
|
||
}
|
||
}
|
||
});
|
||
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++)
|
||
{
|
||
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);
|
||
}
|
||
}
|
||
});
|
||
matEditor.ShaderProperty(_helper.GetProperty("_RampColorBlendColor"), "颜色映射叠加颜色_hdr");
|
||
|
||
|
||
});
|
||
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutDissolve, 3, GetAnimBoolIndex(3), "溶解",
|
||
"_Dissolve_Toggle", shaderKeyword: "_DISSOLVE", isIndentBlock: true, fontStyle: FontStyle.Bold,
|
||
drawBlock: (isToggle) =>
|
||
{
|
||
|
||
_helper.DrawTextureFoldOut(W9ParticleShaderFlags.foldOutDissolveMap, 3, GetAnimBoolIndex(3), "溶解贴图",
|
||
"_DissolveMap", drawScaleOffset: true, drawWrapMode: true,
|
||
flagBitsName: W9ParticleShaderFlags.FLAG_BIT_WRAPMODE_DISSOLVE_MAP, flagIndex: 2,
|
||
drawBlock: (dissolveTex) =>
|
||
{
|
||
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 =>
|
||
{
|
||
_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();
|
||
});
|
||
|
||
_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 =>
|
||
{
|
||
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);
|
||
}
|
||
}
|
||
});
|
||
});
|
||
|
||
|
||
_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 =>
|
||
{
|
||
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);
|
||
});
|
||
|
||
});
|
||
|
||
|
||
|
||
_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);
|
||
}
|
||
},
|
||
drawOnValueChangedBlock: fresnelModeProp =>
|
||
{
|
||
if (!fresnelModeProp.hasMixedValue)
|
||
{
|
||
FresnelMode fresnelMode = (FresnelMode)fresnelModeProp.floatValue;
|
||
for (int i = 0; i < shaderFlags.Count; i++)
|
||
{
|
||
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;
|
||
}
|
||
}
|
||
|
||
}
|
||
});
|
||
_helper.DrawVector4Component("菲涅尔强度", "_FresnelUnit", "z", true);
|
||
|
||
|
||
if (mats.Count == 1)
|
||
{
|
||
FresnelMode fresnelMode = (FresnelMode)mats[0].GetFloat("_FresnelMode");
|
||
|
||
}
|
||
|
||
_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)
|
||
{
|
||
_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) =>
|
||
{
|
||
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)
|
||
{
|
||
for (int i = 0; i < mats.Count; i++)
|
||
{
|
||
if (isToggle.floatValue > 0.5f)
|
||
{
|
||
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);
|
||
}
|
||
else
|
||
{
|
||
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);
|
||
}
|
||
}
|
||
|
||
}
|
||
});
|
||
|
||
_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;
|
||
}
|
||
|
||
mats[i].SetVector(shaderID, vecValue);
|
||
}
|
||
};
|
||
|
||
_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) =>
|
||
{
|
||
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)
|
||
{
|
||
mat.SetFloat("_TransparentMode", (float)TransparentMode.CutOff);
|
||
}
|
||
|
||
mat.SetFloat("_ZTest", (float)CompareFunction.LessEqual);
|
||
mat.SetFloat("_ForceZWriteToggle",2);
|
||
};
|
||
Action<Material> RestPortal = (mat) =>
|
||
{
|
||
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 =>
|
||
{
|
||
if (!isPortalMaskToggle.hasMixedValue)
|
||
{
|
||
|
||
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]);
|
||
}
|
||
|
||
}
|
||
}
|
||
});
|
||
}, drawEndChangeCheck: (isPortalToggle) =>
|
||
{
|
||
for (int i = 0; i < mats.Count; i++)
|
||
{
|
||
if (isPortalToggle.floatValue > 0.5f)
|
||
{
|
||
if (mats[i].GetFloat("_Portal_MaskToggle") < 0.5f)
|
||
{
|
||
SetPortal(mats[i]);
|
||
}
|
||
else
|
||
{
|
||
SetPortalMask(mats[i]);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
RestPortal(mats[i]);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
//粒子序列帧融帧的逻辑，是将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)
|
||
{
|
||
if (shaderFlags[0].CheckIsUVModeOn(W9ParticleShaderFlags.UVMode.SpecialUVChannel))
|
||
{
|
||
EditorGUILayout.HelpBox("序列帧融帧和特殊UV通道同时开启，粒子序列帧应该影响UV0和UV1两个通道，特殊通道只能使用UV3（原始UV）",
|
||
MessageType.Warning);
|
||
}
|
||
else
|
||
{
|
||
EditorGUILayout.HelpBox("AnimationSheet的AffectUVChannel需要有UV0和UV1",
|
||
MessageType.Info);
|
||
}
|
||
}
|
||
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) =>
|
||
{
|
||
|
||
matEditor.ShaderProperty(_helper.GetProperty("_offsetFactor"), "OffsetFactor");
|
||
matEditor.ShaderProperty(_helper.GetProperty("_offsetUnits"), "Offset单位");
|
||
},
|
||
drawEndChangeCheck: (isToggle) =>
|
||
{
|
||
if (!isToggle.hasMixedValue && isToggle.floatValue < 0.5f)
|
||
{
|
||
for (int i = 0; i < mats.Count; i++)
|
||
{
|
||
mats[i].SetFloat("_offsetFactor", 0f);
|
||
mats[i].SetFloat("_offsetUnits", 0f);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
|
||
_helper.DrawRenderQueue(_helper.GetProperty("_QueueBias"));
|
||
|
||
_helper.DrawToggleFoldOut(W9ParticleShaderFlags.foldOutBit1CustomStencilTest, 4, GetAnimBoolIndex(4),
|
||
"模板手动调试开关", "_CustomStencilTest",
|
||
drawBlock: isToggle =>
|
||
{
|
||
bool hasMixedKeyValue = false;
|
||
int stencilKeyIndexID = Shader.PropertyToID("_StencilKeyIndex");
|
||
string originKey = "";
|
||
for (int i = 0; i < mats.Count; i++)
|
||
{
|
||
string key = _stencilValuesConfig.GetKeyByIndex(mats[i].GetInt(stencilKeyIndexID));
|
||
if (i == 0)
|
||
{
|
||
originKey = key;
|
||
}
|
||
else
|
||
{
|
||
if (originKey != key) hasMixedKeyValue = true;
|
||
}
|
||
|
||
hasMixedKeyValue = false;
|
||
}
|
||
|
||
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)
|
||
{
|
||
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);
|
||
}
|
||
|
||
}
|
||
}
|
||
});
|
||
|
||
|
||
if (mats.Count == 1)
|
||
{
|
||
_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);
|
||
}
|
||
|
||
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);
|
||
}
|
||
|
||
});
|
||
}
|
||
}
|
||
|
||
void DrawNoiseAffectBlock(Action drawBlock)
|
||
{
|
||
|
||
EditorGUI.BeginDisabledGroup(_noiseEnabled == 0);
|
||
EditorGUI.showMixedValue = _noiseEnabled < 0;
|
||
drawBlock();
|
||
EditorGUI.showMixedValue = false;
|
||
EditorGUI.EndDisabledGroup();
|
||
}
|
||
|
||
public string[] blendModeNames =
|
||
{
|
||
"透明度混合AlphaBlend",
|
||
"预乘PreMultiply",
|
||
"叠加Additive",
|
||
"正片叠底Multiply"
|
||
};
|
||
|
||
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
|
||
}
|
||
|
||
public enum TimeMode
|
||
{
|
||
Default,
|
||
UnScaleTime,
|
||
ScriptableTime
|
||
}
|
||
|
||
public enum RenderFace
|
||
{
|
||
Front = 2,
|
||
Back = 1,
|
||
Both = 0
|
||
}
|
||
|
||
public enum FresnelMode
|
||
{
|
||
Color = 0,
|
||
Fade = 1,
|
||
UnkownOrMixed = -1
|
||
}
|
||
|
||
private string[] _fresnelModeNames =
|
||
{
|
||
"颜色|边缘光",
|
||
"半透明|渐隐"
|
||
};
|
||
|
||
private string[] _maskMapModeNames =
|
||
{
|
||
"遮罩贴图",
|
||
"渐变控件"
|
||
};
|
||
|
||
private string[] _ForceZWriteToggleNames =
|
||
{
|
||
"默认",
|
||
"强制开启",
|
||
"强制关闭"
|
||
};
|
||
|
||
|
||
public enum FxLightMode
|
||
{
|
||
UnLit,
|
||
BlinnPhong,
|
||
HalfLambert,
|
||
PBR,
|
||
SixWay,
|
||
UnKnownOrMixedValue = -1
|
||
}
|
||
private string[] _fxLightModeNames =
|
||
{
|
||
"默认无光(Unlit)",
|
||
"简单光照(BlinnPhong)",
|
||
"简单光照通透(HalfLambert)",
|
||
"高级光照(PBR)",
|
||
"六路光照(SixWay)"
|
||
};
|
||
|
||
public string[] transparentModeNames =
|
||
{
|
||
"不透明Opaque",
|
||
"半透明Transparent",
|
||
"不透明裁剪CutOff"
|
||
};
|
||
|
||
public enum TransparentMode
|
||
{
|
||
Opaque = 0,
|
||
Transparent = 1,
|
||
CutOff = 2,
|
||
UnKnowOrMixed = -1
|
||
}
|
||
|
||
private string[] matCapBlendModeNames =
|
||
{
|
||
"相加Add",
|
||
"相乘Multiply",
|
||
};
|
||
|
||
private string[] dissolveRampBlendModeNames =
|
||
{
|
||
"线性差值Lerp",
|
||
"相乘Multiply",
|
||
};
|
||
|
||
private string[] colorBlendAlphaMode = new[]
|
||
{
|
||
"颜色渐变强度",
|
||
"遮罩(乘以主贴图Alpha)"
|
||
};
|
||
|
||
private string[] rampColorSourceMode =
|
||
{
|
||
"UV",
|
||
"映射贴图"
|
||
};
|
||
|
||
private string[] dissolveRampSourceMode =
|
||
{
|
||
"渐变控件",
|
||
"Ramp贴图"
|
||
};
|
||
|
||
private string[] rampColorBlendMode =
|
||
{
|
||
"相乘Multiply",
|
||
"相加Add"
|
||
};
|
||
|
||
void DoAfterDraw()
|
||
{
|
||
// Debug.Log(mats[0].name + " MaterialEditorDoAfterDraw!");
|
||
for (int i = 0; i < mats.Count; i++)
|
||
{
|
||
|
||
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;
|
||
}
|
||
|
||
|
||
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;
|
||
}
|
||
|
||
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");
|
||
int queueBias = (int)mats[i].GetFloat("_QueueBias");
|
||
switch (transparentMode)
|
||
{
|
||
case TransparentMode.Opaque:
|
||
mats[i].SetInt("_ZWrite", (int)1);
|
||
mats[i].renderQueue = 2100 + queueBias; //3D粒子永远最前显示
|
||
mats[i].SetInt("_Blend", (int)BlendMode.Opaque);
|
||
break;
|
||
case TransparentMode.Transparent:
|
||
mats[i].SetInt("_ZWrite", (int)0);
|
||
int defaultQueue = 3100;
|
||
if (_uiEffectEnabled == 1)
|
||
{
|
||
defaultQueue = 3000;
|
||
}
|
||
|
||
mats[i].renderQueue = defaultQueue + queueBias; //3D粒子永远最前显示
|
||
|
||
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);
|
||
mats[i].renderQueue = 2450 + queueBias; //3D粒子永远最前显示
|
||
mats[i].SetInt("_Blend", (int)BlendMode.Opaque);
|
||
break;
|
||
}
|
||
|
||
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);
|
||
}
|
||
|
||
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);
|
||
mats[i].DisableKeyword("_ALPHAPREMULTIPLY_ON");
|
||
mats[i].DisableKeyword("_ALPHAMODULATE_ON");
|
||
break;
|
||
case BlendMode.Premultiply:
|
||
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");
|
||
break;
|
||
case BlendMode.Additive:
|
||
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");
|
||
break;
|
||
case BlendMode.Multiply:
|
||
mats[i].SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.DstColor);
|
||
mats[i].SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
|
||
mats[i].DisableKeyword("_ALPHAPREMULTIPLY_ON");
|
||
mats[i].EnableKeyword("_ALPHAMODULATE_ON");
|
||
break;
|
||
case BlendMode.Opaque:
|
||
mats[i].SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
|
||
mats[i].SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
|
||
mats[i].DisableKeyword("_ALPHAPREMULTIPLY_ON");
|
||
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");
|
||
|
||
List<ParticleSystemRenderer> m_ParticleRenderersUsingThisMaterial = new List<ParticleSystemRenderer>();
|
||
List<Renderer> m_RenderersUsingThisMaterial = new List<Renderer>();
|
||
|
||
private bool checkIsParicleSystem = false;
|
||
void CacheRenderersUsingThisMaterial(Material material, int matID)
|
||
{
|
||
checkIsParicleSystem = false;
|
||
m_ParticleRenderersUsingThisMaterial.Clear();
|
||
m_RenderersUsingThisMaterial.Clear();
|
||
// #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)
|
||
{
|
||
if (renderer is ParticleSystemRenderer)
|
||
{
|
||
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);
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
//雨轩：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;
|
||
}
|
||
|
||
if (_fxLightMode != FxLightMode.UnLit || material.GetFloat("_BumpMapToggle") > 0.5f)
|
||
{
|
||
needNormal = true;
|
||
needTangent = true;
|
||
}
|
||
|
||
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"
|
||
};
|
||
|
||
|
||
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;
|
||
}
|
||
public void DrawCustomDataSelect(string label, int dataBitPos, int dataIndex)
|
||
{
|
||
// if(!_isUseParticleSystem)return;//只有粒子系统才会处理相关内容。
|
||
// if (mats.Count != 1) return; //仅单选触发
|
||
|
||
if(_meshSourceModeIsParticle <=0 ) return;
|
||
(string, string) nameTuple = (label, "");
|
||
//-------------这里需要处理多选情况--------------
|
||
EditorGUI.showMixedValue = CustomDataHasMixedValue(dataBitPos, dataIndex);
|
||
W9ParticleShaderFlags.CutomDataComponent component = shaderFlags[0].GetCustomDataFlag(dataBitPos, dataIndex);
|
||
EditorGUI.BeginChangeCheck();
|
||
EditorGUILayout.BeginHorizontal();
|
||
component = (W9ParticleShaderFlags.CutomDataComponent)EditorGUILayout.Popup(new GUIContent(label), (int)component, _customDataOptions);
|
||
EditorGUI.showMixedValue = false;
|
||
Action customDataDrawEndChangeCheck = () =>
|
||
{
|
||
for (int i = 0; i < shaderFlags.Count; i++)
|
||
{
|
||
shaderFlags[i].SetCustomDataFlag(component,dataBitPos,dataIndex);
|
||
}
|
||
_helper.ResetTool.CheckOnValueChange(nameTuple);
|
||
};
|
||
if (EditorGUI.EndChangeCheck())
|
||
{
|
||
customDataDrawEndChangeCheck();
|
||
}
|
||
_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();
|
||
|
||
}
|
||
|
||
|
||
private string[] _uvModeNames =
|
||
{
|
||
"默认UV通道",
|
||
"特殊UV通道",
|
||
"极坐标|旋转",
|
||
"圆柱无缝"
|
||
};
|
||
|
||
enum SpecialUVChannelMode
|
||
{
|
||
UV2_Texcoord1,
|
||
UV3_Texcoord2
|
||
}
|
||
|
||
bool UvModeHasMixedValue(int uvModeBitPos, int uvModeFlagIndex)
|
||
{
|
||
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)
|
||
{
|
||
EditorGUI.BeginDisabledGroup(false);
|
||
}
|
||
else if (textureProp != null)
|
||
{
|
||
EditorGUI.BeginDisabledGroup(!textureProp.textureValue);
|
||
}
|
||
else
|
||
{
|
||
EditorGUI.BeginDisabledGroup(false);
|
||
}
|
||
bool uvModeHasMixedValue = UvModeHasMixedValue(uvModeBitPos, uvModeFlagIndex);
|
||
EditorGUI.showMixedValue = uvModeHasMixedValue;
|
||
(string, string) wrapModeNameTuple = (label, "");
|
||
|
||
EditorGUILayout.BeginHorizontal();
|
||
|
||
|
||
Rect rect = EditorGUILayout.GetControlRect();
|
||
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();
|
||
}
|
||
|
||
bool foldOutState = shaderFlags[0].CheckFlagBits(foldOutFlagBit, index: foldOutFlagIndex);
|
||
AnimBool animBool = _helper.GetAnimBool(foldOutFlagBit, foldOutFlagIndex-3, foldOutFlagIndex);
|
||
animBool.target = foldOutState;
|
||
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;
|
||
}
|
||
}
|
||
foldOutState = animBool.target;
|
||
if (foldOutState)
|
||
{
|
||
shaderFlags[0].SetFlagBits(foldOutFlagBit, index: foldOutFlagIndex);
|
||
}
|
||
else
|
||
{
|
||
shaderFlags[0].ClearFlagBits(foldOutFlagBit, index: foldOutFlagIndex);
|
||
}
|
||
EditorGUI.LabelField(labelRect,label);
|
||
|
||
_helper.ResetTool.DrawResetModifyButton(new Rect(),wrapModeNameTuple,
|
||
resetCallBack: () =>
|
||
{
|
||
uvMode = 0;
|
||
drawUVModeEndChangeCheck();
|
||
},onValueChangedCallBack: drawUVModeEndChangeCheck,checkHasModifyOnValueChange: () =>
|
||
{
|
||
return shaderFlags[0].GetUVMode(uvModeBitPos, uvModeFlagIndex) != 0;
|
||
},checkHasMixedValueOnValueChange:()=>UvModeHasMixedValue(uvModeBitPos, uvModeFlagIndex));
|
||
EditorGUILayout.EndHorizontal();
|
||
_helper.ResetTool.EndResetModifyButtonScope();
|
||
|
||
|
||
|
||
EditorGUI.showMixedValue = false;
|
||
|
||
if (!uvModeHasMixedValue)
|
||
{
|
||
EditorGUI.indentLevel++;
|
||
|
||
float faded = animBool.faded;
|
||
if (faded == 0) faded = 0.0001f;
|
||
EditorGUILayout.BeginFadeGroup(faded);
|
||
if (uvMode != W9ParticleShaderFlags.UVMode.DefaultUVChannel)
|
||
{
|
||
EditorGUILayout.LabelField("以下设置材质内通用:",EditorStyles.boldLabel);
|
||
}
|
||
|
||
Action drawSpecialUVChannel = () =>
|
||
{
|
||
_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++)
|
||
{
|
||
switch (spUVMode)
|
||
{
|
||
case SpecialUVChannelMode.UV2_Texcoord1:
|
||
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_USE_TEXCOORD1,index:1);
|
||
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_USE_TEXCOORD2,index:1);
|
||
break;
|
||
case SpecialUVChannelMode.UV3_Texcoord2:
|
||
shaderFlags[i].ClearFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_USE_TEXCOORD1,index:1);
|
||
shaderFlags[i].SetFlagBits(W9ParticleShaderFlags.FLAG_BIT_PARTICLE_1_USE_TEXCOORD2,index:1);
|
||
break;
|
||
//TODO:如果所有UVMode都没有开启，需要都Clear。
|
||
}
|
||
}
|
||
},isSharedGlobalParent:true);
|
||
};
|
||
|
||
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;
|
||
}
|
||
}
|
||
|
||
EditorGUILayout.EndFadeGroup();
|
||
EditorGUI.indentLevel--;
|
||
}
|
||
EditorGUI.EndDisabledGroup();
|
||
|
||
}
|
||
|
||
private string[] _meshSourceModeNames =
|
||
{
|
||
"粒子系统",
|
||
"模型（非粒子发射）",
|
||
"2D RawImage",
|
||
"2D 精灵",
|
||
"2D 材质贴图",
|
||
"2D UIParticle"
|
||
};
|
||
|
||
enum MeshSourceMode
|
||
{
|
||
Particle,
|
||
Mesh,
|
||
UIEffectRawImage,
|
||
UIEffectSprite,
|
||
UIEffectBaseMap,
|
||
UIParticle,
|
||
UnKnowOrMixed = -1
|
||
}
|
||
|
||
bool ColorChannelHasMixedValue(int colorChannelBitPos)
|
||
{
|
||
W9ParticleShaderFlags.ColorChannel colorChannel = W9ParticleShaderFlags.ColorChannel.UnKnownOrMixedValue;
|
||
for (int i = 0; i < shaderFlags.Count; i++)
|
||
{
|
||
W9ParticleShaderFlags.ColorChannel curChannel = shaderFlags[i].GetColorChanel(colorChannelBitPos);
|
||
if (i == 0)
|
||
{
|
||
colorChannel = curChannel;
|
||
}
|
||
else
|
||
{
|
||
if(colorChannel != curChannel) return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
private string[] _colorChannelNames = { "R", "G", "B", "A" };
|
||
|
||
public void DrawColorChannelSelect(string label, int colorChannelBitPos,int defaultChannel = 0)
|
||
{
|
||
bool hasMixedValue = ColorChannelHasMixedValue(colorChannelBitPos);
|
||
EditorGUI.showMixedValue = hasMixedValue;
|
||
(string, string) nameTuple = (label, "");
|
||
|
||
W9ParticleShaderFlags.ColorChannel chanel = shaderFlags[0].GetColorChanel(colorChannelBitPos);
|
||
EditorGUI.BeginChangeCheck();
|
||
EditorGUILayout.BeginHorizontal();
|
||
int index = EditorGUILayout.Popup(label, (int)chanel,
|
||
_colorChannelNames);
|
||
Action colorChannelOnEndChangeCheck = () =>
|
||
{
|
||
for (int i = 0; i < shaderFlags.Count; i++)
|
||
{
|
||
shaderFlags[i].SetColorChanel((W9ParticleShaderFlags.ColorChannel)index,colorChannelBitPos);
|
||
}
|
||
_helper.ResetTool.CheckOnValueChange(nameTuple);
|
||
};
|
||
if (EditorGUI.EndChangeCheck())
|
||
{
|
||
colorChannelOnEndChangeCheck();
|
||
}
|
||
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();
|
||
}
|
||
|
||
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;
|
||
// }
|
||
}
|
||
} |