597 lines
20 KiB
C#
597 lines
20 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
using NBShader;
|
|
|
|
namespace NBShaderEditor
|
|
{
|
|
internal sealed class ParticleBaseHoudiniVATGUI
|
|
{
|
|
private readonly ShaderGUIHelper _helper;
|
|
|
|
private static readonly string[] SubModeNames =
|
|
{
|
|
"SoftBody (Deformation)",
|
|
"RigidBody (Pieces)",
|
|
"Dynamic Remeshing (Lookup)",
|
|
"Particle Sprites (Billboard)"
|
|
};
|
|
|
|
private static readonly string[] SubModeKeywords =
|
|
{
|
|
"_HOUDINI_VAT_SOFTBODY",
|
|
"_HOUDINI_VAT_RIGIDBODY",
|
|
"_HOUDINI_VAT_DYNAMIC_REMESH",
|
|
"_HOUDINI_VAT_PARTICLE_SPRITE"
|
|
};
|
|
|
|
public ParticleBaseHoudiniVATGUI(ShaderGUIHelper helper)
|
|
{
|
|
_helper = helper;
|
|
}
|
|
|
|
public void Draw()
|
|
{
|
|
DrawSubModeSelector();
|
|
DrawPlaybackSection();
|
|
DrawBoundsSection();
|
|
DrawTextureSection();
|
|
DrawScaleSection();
|
|
DrawParticleSpriteSection();
|
|
DrawFlagsSection();
|
|
SyncKeywords();
|
|
}
|
|
|
|
public static void AppendRequiredVertexStreams(
|
|
Material material,
|
|
List<ParticleSystemVertexStream> streams,
|
|
List<string> streamList)
|
|
{
|
|
if (material.GetFloat("_VAT_Toggle") <= 0.5f)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int subMode = GetMaterialSubMode(material);
|
|
bool isParticleMode = IsHoudiniParticleModeEnabled(material);
|
|
|
|
AddStream(streams, streamList, ParticleSystemVertexStream.Position, ParticleBaseGUI.streamPositionText);
|
|
AddStream(streams, streamList, ParticleSystemVertexStream.Normal, ParticleBaseGUI.streamNormalText);
|
|
|
|
switch (subMode)
|
|
{
|
|
case 0: // SoftBody needs VAT UV1.
|
|
AddVatUV1Stream(streams, streamList, isParticleMode);
|
|
break;
|
|
|
|
case 1: // RigidBody needs VAT UV1, UV2, UV3 (Custom2, vatTexcoord5)
|
|
if (isParticleMode)
|
|
{
|
|
break;
|
|
}
|
|
|
|
AddVatUV1Stream(streams, streamList, isParticleMode);
|
|
AddStream(streams, streamList, ParticleSystemVertexStream.Custom2XYZW, ParticleBaseGUI.streamCustom2Text);
|
|
AddStream(streams, streamList, ParticleSystemVertexStream.UV, ParticleBaseGUI.streamUVText);
|
|
break;
|
|
|
|
case 2: // DynamicRemeshing needs UV0 (texcoords)
|
|
AddStream(streams, streamList, ParticleSystemVertexStream.UV, ParticleBaseGUI.streamUVText);
|
|
break;
|
|
|
|
case 3: // ParticleSprite needs UV0 (corner) + VAT UV1 (particle U/V)
|
|
AddStream(streams, streamList, ParticleSystemVertexStream.UV, ParticleBaseGUI.streamUVText);
|
|
AddVatUV1Stream(streams, streamList, isParticleMode);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private List<Material> mats => _helper.mats;
|
|
|
|
private bool IsResetToolInitializing()
|
|
{
|
|
return _helper.ResetTool != null && _helper.ResetTool.IsInitResetData;
|
|
}
|
|
|
|
private bool TryGetCurrentSubMode(out int subMode)
|
|
{
|
|
MaterialProperty property = _helper.GetProperty("_HoudiniVATSubMode");
|
|
if (property == null || property.hasMixedValue)
|
|
{
|
|
subMode = -1;
|
|
return false;
|
|
}
|
|
|
|
subMode = Mathf.Clamp(Mathf.RoundToInt(property.floatValue), 0, SubModeNames.Length - 1);
|
|
return true;
|
|
}
|
|
|
|
private bool IsSubMode(params int[] subModes)
|
|
{
|
|
if (IsResetToolInitializing())
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (!TryGetCurrentSubMode(out int currentSubMode))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < subModes.Length; i++)
|
|
{
|
|
if (currentSubMode == subModes[i])
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private bool TryGetFloatProperty(string propertyName, out MaterialProperty property)
|
|
{
|
|
property = _helper.GetProperty(propertyName);
|
|
return property != null && !property.hasMixedValue;
|
|
}
|
|
|
|
private bool IsFloatPropertyOn(string propertyName)
|
|
{
|
|
return TryGetFloatProperty(propertyName, out MaterialProperty property) && property.floatValue > 0.5f;
|
|
}
|
|
|
|
private bool IsFloatPropertyOff(string propertyName)
|
|
{
|
|
return TryGetFloatProperty(propertyName, out MaterialProperty property) && property.floatValue <= 0.5f;
|
|
}
|
|
|
|
private bool IsFloatPropertyMixed(string propertyName)
|
|
{
|
|
MaterialProperty property = _helper.GetProperty(propertyName);
|
|
return property != null && property.hasMixedValue;
|
|
}
|
|
|
|
private bool ShouldDrawWhenFloatOn(string propertyName)
|
|
{
|
|
return IsResetToolInitializing() || IsFloatPropertyMixed(propertyName) || IsFloatPropertyOn(propertyName);
|
|
}
|
|
|
|
private bool ShouldDrawWhenFloatOff(string propertyName)
|
|
{
|
|
return IsResetToolInitializing() || IsFloatPropertyMixed(propertyName) || IsFloatPropertyOff(propertyName);
|
|
}
|
|
|
|
private static int GetMaterialSubMode(Material material)
|
|
{
|
|
if (!material.HasProperty("_HoudiniVATSubMode"))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return Mathf.Clamp(Mathf.RoundToInt(material.GetFloat("_HoudiniVATSubMode")), 0, SubModeNames.Length - 1);
|
|
}
|
|
|
|
private static bool IsHoudiniParticleModeEnabled(Material material)
|
|
{
|
|
if (material == null ||
|
|
!material.HasProperty("_VAT_Toggle") ||
|
|
!material.HasProperty("_VATMode") ||
|
|
!material.HasProperty("_MeshSourceMode") ||
|
|
material.GetFloat("_VAT_Toggle") <= 0.5f ||
|
|
Mathf.RoundToInt(material.GetFloat("_VATMode")) != (int)ParticleBaseGUI.VATMode.Houdini)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
ParticleBaseGUI.MeshSourceMode meshSourceMode = (ParticleBaseGUI.MeshSourceMode)Mathf.RoundToInt(material.GetFloat("_MeshSourceMode"));
|
|
return meshSourceMode == ParticleBaseGUI.MeshSourceMode.Particle ||
|
|
meshSourceMode == ParticleBaseGUI.MeshSourceMode.UIParticle;
|
|
}
|
|
|
|
private void DrawSubModeSelector()
|
|
{
|
|
_helper.DrawPopUp("Houdini VAT Sub Mode", "_HoudiniVATSubMode", SubModeNames);
|
|
if (HasUnsupportedParticleMode())
|
|
{
|
|
EditorGUILayout.HelpBox("该 Houdini VAT 类型需要 Mesh 多 UV 数据，不支持 ParticleSystem VertexStream 模式。", MessageType.Warning);
|
|
}
|
|
}
|
|
|
|
private void DrawPlaybackSection()
|
|
{
|
|
EditorGUILayout.Space();
|
|
EditorGUILayout.LabelField("Playback", EditorStyles.boldLabel);
|
|
|
|
_helper.DrawToggle("Auto Playback", "_B_autoPlayback");
|
|
|
|
if (ShouldDrawWhenFloatOff("_B_autoPlayback"))
|
|
{
|
|
_helper.DrawFloat("Display Frame", "_displayFrame");
|
|
}
|
|
|
|
DrawFrameCustomDataSelect();
|
|
|
|
_helper.DrawFloat("Game Time at First Frame", "_gameTimeAtFirstFrame");
|
|
_helper.DrawFloat("Playback Speed", "_playbackSpeed");
|
|
_helper.DrawFloat("Houdini FPS", "_houdiniFPS");
|
|
_helper.DrawToggle("Interframe Interpolation", "_B_interpolate");
|
|
|
|
if (IsSubMode(1)) // RigidBody
|
|
{
|
|
_helper.DrawToggle("Animate First Frame", "_animateFirstFrame");
|
|
}
|
|
}
|
|
|
|
private void DrawBoundsSection()
|
|
{
|
|
EditorGUILayout.Space();
|
|
EditorGUILayout.LabelField("Bounds Metadata", EditorStyles.boldLabel);
|
|
|
|
_helper.DrawFloat("Bound Min X", "_boundMinX");
|
|
_helper.DrawFloat("Bound Min Y", "_boundMinY");
|
|
_helper.DrawFloat("Bound Min Z", "_boundMinZ");
|
|
_helper.DrawFloat("Bound Max X", "_boundMaxX");
|
|
_helper.DrawFloat("Bound Max Y", "_boundMaxY");
|
|
_helper.DrawFloat("Bound Max Z", "_boundMaxZ");
|
|
}
|
|
|
|
private void DrawFrameCustomDataSelect()
|
|
{
|
|
const int dataBitPos = W9ParticleShaderFlags.FLAGBIT_POS_2_CUSTOMDATA_VAT_FRAME;
|
|
const int dataIndex = 2;
|
|
W9ParticleShaderFlags.CutomDataComponent component = GetCurrentCustomDataComponent(dataBitPos, dataIndex);
|
|
if (!IsAnyHoudiniParticleModeEnabled() || _helper.shaderFlags == null || _helper.shaderFlags.Length == 0)
|
|
{
|
|
ClearFrameCustomData(dataBitPos, dataIndex);
|
|
return;
|
|
}
|
|
|
|
(string, string) nameTuple = ("VATFrameCustomData", "");
|
|
|
|
EditorGUI.showMixedValue = CustomDataHasMixedValue(dataBitPos, dataIndex);
|
|
EditorGUI.BeginChangeCheck();
|
|
EditorGUILayout.BeginHorizontal();
|
|
component = (W9ParticleShaderFlags.CutomDataComponent)EditorGUILayout.Popup(new GUIContent("VAT Frame CustomData"), (int)component, ParticleBaseGUI.CustomDataOptions);
|
|
EditorGUI.showMixedValue = false;
|
|
|
|
Action applySelection = () =>
|
|
{
|
|
for (int i = 0; i < _helper.shaderFlags.Length; i++)
|
|
{
|
|
if (_helper.shaderFlags[i] is W9ParticleShaderFlags flags)
|
|
{
|
|
flags.SetCustomDataFlag(component, dataBitPos, dataIndex);
|
|
}
|
|
}
|
|
|
|
_helper.ResetTool.CheckOnValueChange(nameTuple);
|
|
};
|
|
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
applySelection();
|
|
}
|
|
|
|
_helper.ResetTool.DrawResetModifyButton(
|
|
new Rect(),
|
|
nameTuple,
|
|
resetCallBack: () =>
|
|
{
|
|
component = W9ParticleShaderFlags.CutomDataComponent.Off;
|
|
applySelection();
|
|
},
|
|
onValueChangedCallBack: applySelection,
|
|
checkHasModifyOnValueChange: () => GetCurrentCustomDataComponent(dataBitPos, dataIndex) != W9ParticleShaderFlags.CutomDataComponent.Off,
|
|
checkHasMixedValueOnValueChange: () => CustomDataHasMixedValue(dataBitPos, dataIndex));
|
|
EditorGUILayout.EndHorizontal();
|
|
_helper.ResetTool.EndResetModifyButtonScope();
|
|
}
|
|
|
|
private void ClearFrameCustomData(int dataBitPos, int dataIndex)
|
|
{
|
|
if (_helper.shaderFlags == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < _helper.shaderFlags.Length; i++)
|
|
{
|
|
if (_helper.shaderFlags[i] is W9ParticleShaderFlags flags)
|
|
{
|
|
flags.SetCustomDataFlag(W9ParticleShaderFlags.CutomDataComponent.Off, dataBitPos, dataIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
private W9ParticleShaderFlags.CutomDataComponent GetCurrentCustomDataComponent(int dataBitPos, int dataIndex)
|
|
{
|
|
if (_helper.shaderFlags == null || _helper.shaderFlags.Length == 0)
|
|
{
|
|
return W9ParticleShaderFlags.CutomDataComponent.Off;
|
|
}
|
|
|
|
if (_helper.shaderFlags[0] is W9ParticleShaderFlags flags)
|
|
{
|
|
return flags.GetCustomDataFlag(dataBitPos, dataIndex);
|
|
}
|
|
|
|
return W9ParticleShaderFlags.CutomDataComponent.Off;
|
|
}
|
|
|
|
private bool CustomDataHasMixedValue(int dataBitPos, int dataIndex)
|
|
{
|
|
if (_helper.shaderFlags == null || _helper.shaderFlags.Length == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
W9ParticleShaderFlags.CutomDataComponent component = W9ParticleShaderFlags.CutomDataComponent.UnKnownOrMixed;
|
|
for (int i = 0; i < _helper.shaderFlags.Length; i++)
|
|
{
|
|
if (!(_helper.shaderFlags[i] is W9ParticleShaderFlags flags))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
W9ParticleShaderFlags.CutomDataComponent current = flags.GetCustomDataFlag(dataBitPos, dataIndex);
|
|
if (component == W9ParticleShaderFlags.CutomDataComponent.UnKnownOrMixed)
|
|
{
|
|
component = current;
|
|
continue;
|
|
}
|
|
|
|
if (component != current)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private bool IsAnyHoudiniParticleModeEnabled()
|
|
{
|
|
if (_helper.mats == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < _helper.mats.Count; i++)
|
|
{
|
|
if (IsHoudiniParticleModeEnabled(_helper.mats[i]))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private bool HasUnsupportedParticleMode()
|
|
{
|
|
if (_helper.mats == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < _helper.mats.Count; i++)
|
|
{
|
|
if (IsUnsupportedParticleMode(_helper.mats[i]))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static bool IsUnsupportedParticleMode(Material material)
|
|
{
|
|
return IsHoudiniParticleModeEnabled(material) && GetMaterialSubMode(material) == 1;
|
|
}
|
|
|
|
private void DrawTextureSection()
|
|
{
|
|
EditorGUILayout.Space();
|
|
EditorGUILayout.LabelField("Textures", EditorStyles.boldLabel);
|
|
|
|
_helper.DrawTexture("Position Texture", "_posTexture", drawScaleOffset: false, drawWrapMode: false);
|
|
|
|
if (ShouldDrawWhenFloatOn("_B_LOAD_POS_TWO_TEX"))
|
|
{
|
|
_helper.DrawTexture("Position Texture 2", "_posTexture2", drawScaleOffset: false, drawWrapMode: false);
|
|
}
|
|
|
|
if (ShouldDrawRotationTexture())
|
|
{
|
|
_helper.DrawTexture("Rotation Texture", "_rotTexture", drawScaleOffset: false, drawWrapMode: false);
|
|
}
|
|
|
|
if (ShouldDrawWhenFloatOn("_B_LOAD_COL_TEX"))
|
|
{
|
|
_helper.DrawTexture("Color Texture", "_colTexture", drawScaleOffset: false, drawWrapMode: false);
|
|
}
|
|
|
|
if (IsSubMode(2) || ShouldDrawWhenFloatOn("_B_LOAD_LOOKUP_TABLE"))
|
|
{
|
|
_helper.DrawTexture("Lookup Table", "_lookupTable", drawScaleOffset: false, drawWrapMode: false);
|
|
}
|
|
}
|
|
|
|
private void DrawScaleSection()
|
|
{
|
|
if (IsSubMode(1, 3))
|
|
{
|
|
EditorGUILayout.Space();
|
|
EditorGUILayout.LabelField("Scale", EditorStyles.boldLabel);
|
|
|
|
_helper.DrawFloat("Global Piece Scale Multiplier", "_globalPscaleMul");
|
|
_helper.DrawToggle("Piece Scales in Position Alpha", "_B_pscaleAreInPosA");
|
|
}
|
|
}
|
|
|
|
private void DrawParticleSpriteSection()
|
|
{
|
|
if (!IsSubMode(3))
|
|
{
|
|
return;
|
|
}
|
|
|
|
EditorGUILayout.Space();
|
|
EditorGUILayout.LabelField("Particle Sprite", EditorStyles.boldLabel);
|
|
|
|
_helper.DrawFloat("Width Base Scale", "_widthBaseScale");
|
|
_helper.DrawFloat("Height Base Scale", "_heightBaseScale");
|
|
|
|
_helper.DrawToggle("Hide Overlapping Origin", "_B_hideOverlappingOrigin");
|
|
if (ShouldDrawWhenFloatOn("_B_hideOverlappingOrigin"))
|
|
{
|
|
_helper.DrawFloat("Origin Effective Radius", "_originRadius");
|
|
}
|
|
|
|
_helper.DrawToggle("Particles Can Spin", "_B_CAN_SPIN");
|
|
|
|
if (ShouldDrawWhenFloatOn("_B_CAN_SPIN"))
|
|
{
|
|
_helper.DrawToggle("Compute Spin from Heading", "_B_spinFromHeading");
|
|
|
|
if (ShouldDrawWhenFloatOff("_B_spinFromHeading"))
|
|
{
|
|
_helper.DrawFloat("Particle Spin Phase", "_spinPhase");
|
|
}
|
|
|
|
_helper.DrawFloat("Scale by Velocity Amount", "_scaleByVelAmount");
|
|
}
|
|
|
|
_helper.DrawFloat("Particle Texture U Scale", "_particleTexUScale");
|
|
_helper.DrawFloat("Particle Texture V Scale", "_particleTexVScale");
|
|
}
|
|
|
|
private void DrawFlagsSection()
|
|
{
|
|
EditorGUILayout.Space();
|
|
EditorGUILayout.LabelField("Flags", EditorStyles.boldLabel);
|
|
|
|
_helper.DrawToggle("Positions Require Two Textures", "_B_LOAD_POS_TWO_TEX");
|
|
|
|
if (ShouldDrawCompressedNormalsToggle())
|
|
{
|
|
_helper.DrawToggle("Use Compressed Normals (no rotTex)", "_B_UNLOAD_ROT_TEX");
|
|
}
|
|
|
|
_helper.DrawToggle("Load Color Texture", "_B_LOAD_COL_TEX");
|
|
|
|
if (IsSubMode(2))
|
|
{
|
|
_helper.DrawToggle("Load Lookup Table", "_B_LOAD_LOOKUP_TABLE");
|
|
}
|
|
}
|
|
|
|
private bool ShouldDrawRotationTexture()
|
|
{
|
|
if (IsResetToolInitializing())
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (!TryGetCurrentSubMode(out int subMode) || subMode == 3)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return IsFloatPropertyMixed("_B_UNLOAD_ROT_TEX") || IsFloatPropertyOff("_B_UNLOAD_ROT_TEX");
|
|
}
|
|
|
|
private bool ShouldDrawCompressedNormalsToggle()
|
|
{
|
|
if (IsResetToolInitializing())
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return TryGetCurrentSubMode(out int subMode) && subMode != 3;
|
|
}
|
|
|
|
private void SyncKeywords()
|
|
{
|
|
if (mats == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
foreach (Material mat in mats)
|
|
{
|
|
if (mat == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
SyncKeywords(mat);
|
|
}
|
|
}
|
|
|
|
internal static void SyncKeywords(Material mat)
|
|
{
|
|
if (mat == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SetSubModeKeyword(mat, GetMaterialSubMode(mat));
|
|
}
|
|
|
|
internal static void ClearKeywords(Material mat)
|
|
{
|
|
if (mat == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SetSubModeKeyword(mat, -1);
|
|
}
|
|
|
|
private static void SetSubModeKeyword(Material mat, int enabledIndex)
|
|
{
|
|
for (int i = 0; i < SubModeKeywords.Length; i++)
|
|
{
|
|
mat.DisableKeyword(SubModeKeywords[i]);
|
|
}
|
|
|
|
if (enabledIndex >= 0 && enabledIndex < SubModeKeywords.Length)
|
|
{
|
|
mat.EnableKeyword(SubModeKeywords[enabledIndex]);
|
|
}
|
|
}
|
|
|
|
private static void AddStream(
|
|
List<ParticleSystemVertexStream> streams,
|
|
List<string> streamList,
|
|
ParticleSystemVertexStream stream,
|
|
string streamLabel)
|
|
{
|
|
if (streams.Contains(stream))
|
|
{
|
|
return;
|
|
}
|
|
|
|
streams.Add(stream);
|
|
streamList.Add(streamLabel);
|
|
}
|
|
|
|
private static void AddVatUV1Stream(
|
|
List<ParticleSystemVertexStream> streams,
|
|
List<string> streamList,
|
|
bool isParticleMode)
|
|
{
|
|
if (isParticleMode)
|
|
{
|
|
AddStream(streams, streamList, ParticleSystemVertexStream.UV2, ParticleBaseGUI.streamUV2Text);
|
|
return;
|
|
}
|
|
|
|
AddStream(streams, streamList, ParticleSystemVertexStream.Custom1XYZW, ParticleBaseGUI.streamCustom1Text);
|
|
}
|
|
}
|
|
}
|