diff options
Diffstat (limited to 'Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Templates/TemplateDepthModule.cs')
| -rw-r--r-- | Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Templates/TemplateDepthModule.cs | 391 |
1 files changed, 391 insertions, 0 deletions
diff --git a/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Templates/TemplateDepthModule.cs b/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Templates/TemplateDepthModule.cs new file mode 100644 index 00000000..0ce4a1c1 --- /dev/null +++ b/Assets/ThirdParty/AmplifyShaderEditor/Plugins/Editor/Templates/TemplateDepthModule.cs @@ -0,0 +1,391 @@ +// Amplify Shader Editor - Visual Shader Editing Tool +// Copyright (c) Amplify Creations, Lda <info@amplify.pt> + +using System; +using System.Collections.Generic; +using UnityEngine; +using UnityEditor; + +namespace AmplifyShaderEditor +{ + [Serializable] + public sealed class TemplateDepthModule : TemplateModuleParent + { + private const string ZWriteFormatter = "ZWrite {0}\n"; + private const string ZTestFormatter = "ZTest {0}\n"; + + [SerializeField] + private bool m_validZTest = false; + + [SerializeField] + private InlineProperty m_zTestMode = new InlineProperty( 0 ); + + [SerializeField] + private bool m_validZWrite = false; + + [SerializeField] + private InlineProperty m_zWriteMode = new InlineProperty( 0 ); + + [SerializeField] + private InlineProperty m_offsetFactor = new InlineProperty( 0 ); + + [SerializeField] + private InlineProperty m_offsetUnits = new InlineProperty( 0 ); + + [SerializeField] + private bool m_offsetEnabled = false; + + [SerializeField] + private bool m_validOffset = false; + + public TemplateDepthModule() : base( "Depth" ) { } + + public void CopyFrom( TemplateDepthModule other, bool allData ) + { + if( allData ) + { + m_independentModule = other.IndependentModule; + m_validZTest = other.ValidZTest; + m_validZWrite = other.ValidZWrite; + m_validOffset = other.ValidOffset; + } + + m_zTestMode.CopyFrom( other.ZTestMode ); + m_zWriteMode.CopyFrom( other.ZWriteMode ); + m_offsetFactor.CopyFrom( other.OffsetFactor ); + m_offsetUnits.CopyFrom( other.OffsetUnits ); + m_offsetEnabled = other.OffsetEnabled; + } + + public void ConfigureFromTemplateData( TemplateDepthData depthData ) + { + m_independentModule = depthData.IndependentModule; + if( depthData.ValidZTest && m_validZTest != depthData.ValidZTest ) + { + if( string.IsNullOrEmpty( depthData.ZTestInlineValue ) ) + { + m_zTestMode.IntValue = ZBufferOpHelper.ZTestModeDict[ depthData.ZTestModeValue ]; + m_zTestMode.ResetProperty(); + } + else + { + m_zTestMode.SetInlineByName( depthData.ZTestInlineValue ); + } + } + + + + if( depthData.ValidZWrite && m_validZWrite != depthData.ValidZWrite ) + { + if( string.IsNullOrEmpty( depthData.ZWriteInlineValue ) ) + { + m_zWriteMode.IntValue = ZBufferOpHelper.ZWriteModeDict[ depthData.ZWriteModeValue ]; + m_zWriteMode.ResetProperty(); + } + else + { + m_zWriteMode.SetInlineByName( depthData.ZWriteInlineValue ); + } + } + + if( depthData.ValidOffset && m_validOffset != depthData.ValidOffset ) + { + if( string.IsNullOrEmpty( depthData.OffsetFactorInlineValue ) ) + { + m_offsetFactor.FloatValue = depthData.OffsetFactor; + m_offsetFactor.ResetProperty(); + } + else + { + m_offsetFactor.SetInlineByName( depthData.OffsetFactorInlineValue ); + } + + if( string.IsNullOrEmpty( depthData.OffsetUnitsInlineValue ) ) + { + m_offsetUnits.FloatValue = depthData.OffsetUnits; + m_offsetUnits.ResetProperty(); + } + else + { + m_offsetUnits.SetInlineByName( depthData.OffsetUnitsInlineValue ); + } + m_offsetEnabled = depthData.ValidOffset; + } + + m_validZTest = depthData.ValidZTest; + m_validZWrite = depthData.ValidZWrite; + m_validOffset = depthData.ValidOffset; + m_validData = m_validZTest || m_validZWrite || m_validOffset; + } + + public override void ShowUnreadableDataMessage( ParentNode owner ) + { + bool foldoutValue = owner.ContainerGraph.ParentWindow.InnerWindowVariables.ExpandedDepth; + NodeUtils.DrawPropertyGroup( ref foldoutValue, ZBufferOpHelper.DepthParametersStr, base.ShowUnreadableDataMessage ); + owner.ContainerGraph.ParentWindow.InnerWindowVariables.ExpandedDepth = foldoutValue; + } + + public override void Draw( UndoParentNode owner, bool style = true ) + { + bool foldout = owner.ContainerGraph.ParentWindow.InnerWindowVariables.ExpandedDepth; + if( style ) + { + NodeUtils.DrawPropertyGroup( ref foldout, ZBufferOpHelper.DepthParametersStr, () => + { + EditorGUI.indentLevel++; + DrawBlock( owner ); + EditorGUI.indentLevel--; + } ); + } + else + { + NodeUtils.DrawNestedPropertyGroup( ref foldout, ZBufferOpHelper.DepthParametersStr, () => + { + DrawBlock( owner ); + } ); + } + owner.ContainerGraph.ParentWindow.InnerWindowVariables.ExpandedDepth = foldout; + } + + void DrawBlock( UndoParentNode owner ) + { + EditorGUI.BeginChangeCheck(); + Color cachedColor = GUI.color; + GUI.color = new Color( cachedColor.r, cachedColor.g, cachedColor.b, ( EditorGUIUtility.isProSkin ? 0.5f : 0.25f ) ); + //EditorGUILayout.BeginVertical( UIUtils.MenuItemBackgroundStyle ); + GUI.color = cachedColor; + + EditorGUILayout.Separator(); + + if( m_validZWrite ) + m_zWriteMode.EnumTypePopup( ref owner, ZBufferOpHelper.ZWriteModeStr, ZBufferOpHelper.ZWriteModeValues ); + + if( m_validZTest ) + m_zTestMode.EnumTypePopup( ref owner, ZBufferOpHelper.ZTestModeStr, ZBufferOpHelper.ZTestModeLabels ); + + + if( m_validOffset ) + { + m_offsetEnabled = owner.EditorGUILayoutToggle( ZBufferOpHelper.OffsetStr, m_offsetEnabled ); + if( m_offsetEnabled ) + { + EditorGUI.indentLevel++; + m_offsetFactor.FloatField( ref owner, ZBufferOpHelper.OffsetFactorStr ); + m_offsetUnits.FloatField( ref owner, ZBufferOpHelper.OffsetUnitsStr ); + EditorGUI.indentLevel--; + } + } + EditorGUILayout.Separator(); + + //EditorGUILayout.EndVertical(); + if( EditorGUI.EndChangeCheck() ) + { + m_isDirty = true; + } + } + + public void ReadZWriteFromString( ref uint index, ref string[] nodeParams ) + { + bool validDataOnMeta = m_validZWrite; + if( UIUtils.CurrentShaderVersion() > TemplatesManager.MPShaderVersion ) + { + validDataOnMeta = Convert.ToBoolean( nodeParams[ index++ ] ); + } + + if( validDataOnMeta ) + { + if( UIUtils.CurrentShaderVersion() < 15304 ) + { + m_zWriteMode.IntValue = Convert.ToInt32( nodeParams[ index++ ] ); + } + else + { + m_zWriteMode.ReadFromString( ref index, ref nodeParams ); + } + } + } + + public void ReadZTestFromString( ref uint index, ref string[] nodeParams ) + { + bool validDataOnMeta = m_validZTest; + if( UIUtils.CurrentShaderVersion() > TemplatesManager.MPShaderVersion ) + { + validDataOnMeta = Convert.ToBoolean( nodeParams[ index++ ] ); + } + + if( validDataOnMeta ) + { + if( UIUtils.CurrentShaderVersion() < 15304 ) + { + m_zTestMode.IntValue = Convert.ToInt32( nodeParams[ index++ ] ); + } + else + { + m_zTestMode.ReadFromString( ref index, ref nodeParams ); + } + } + } + + public void ReadOffsetFromString( ref uint index, ref string[] nodeParams ) + { + bool validDataOnMeta = m_validOffset; + if( UIUtils.CurrentShaderVersion() > TemplatesManager.MPShaderVersion ) + { + validDataOnMeta = Convert.ToBoolean( nodeParams[ index++ ] ); + } + + if( validDataOnMeta ) + { + m_offsetEnabled = Convert.ToBoolean( nodeParams[ index++ ] ); + if( UIUtils.CurrentShaderVersion() < 15304 ) + { + m_offsetFactor.FloatValue = Convert.ToSingle( nodeParams[ index++ ] ); + m_offsetUnits.FloatValue = Convert.ToSingle( nodeParams[ index++ ] ); + } + else + { + m_offsetFactor.ReadFromString( ref index, ref nodeParams, false ); + m_offsetUnits.ReadFromString( ref index, ref nodeParams, false ); + } + } + } + + public override void ReadFromString( ref uint index, ref string[] nodeParams ) + { + ReadZWriteFromString( ref index, ref nodeParams ); + ReadZTestFromString( ref index, ref nodeParams ); + ReadOffsetFromString( ref index, ref nodeParams ); + } + + public void WriteZWriteToString( ref string nodeInfo ) + { + IOUtils.AddFieldValueToString( ref nodeInfo, m_validZWrite ); + if( m_validZWrite ) + m_zWriteMode.WriteToString( ref nodeInfo ); + } + + public void WriteZTestToString( ref string nodeInfo ) + { + IOUtils.AddFieldValueToString( ref nodeInfo, m_validZTest ); + if( m_validZTest ) + m_zTestMode.WriteToString( ref nodeInfo ); + } + + public void WriteOffsetToString( ref string nodeInfo ) + { + IOUtils.AddFieldValueToString( ref nodeInfo, m_validOffset ); + if( m_validOffset ) + { + IOUtils.AddFieldValueToString( ref nodeInfo, m_offsetEnabled ); + m_offsetFactor.WriteToString( ref nodeInfo ); + m_offsetUnits.WriteToString( ref nodeInfo ); + } + } + + public override void WriteToString( ref string nodeInfo ) + { + WriteZWriteToString( ref nodeInfo ); + WriteZTestToString( ref nodeInfo ); + WriteOffsetToString( ref nodeInfo ); + } + + public bool IsActive { get { return ( m_zTestMode.IsValid || m_zTestMode.IntValue != 0 ) || ( m_zWriteMode.IsValid || m_zWriteMode.IntValue != 0 ) || m_offsetEnabled; } } + public string CurrentZWriteMode + { + get + { + if( m_zWriteMode.IsValid ) + { + return string.Format( ZWriteFormatter, m_zWriteMode.GetValueOrProperty() ); ; + } + + int finalZWrite = ( m_zWriteMode.IntValue == 0 ) ? 1 : m_zWriteMode.IntValue; + return string.Format( ZWriteFormatter, ZBufferOpHelper.ZWriteModeValues[ finalZWrite ] ); ; + } + } + public string CurrentZTestMode + { + get + { + if( m_zTestMode.IsValid ) + return string.Format( ZTestFormatter, m_zTestMode.GetValueOrProperty() ); + + int finalZTestMode = ( m_zTestMode.IntValue == 0 ) ? 3 : m_zTestMode.IntValue; + return string.Format( ZTestFormatter, ZBufferOpHelper.ZTestModeValues[ finalZTestMode ] ); + } + } + + public string CurrentOffset + { + get + { + if( m_offsetEnabled ) + return "Offset " + m_offsetFactor.GetValueOrProperty() + " , " + m_offsetUnits.GetValueOrProperty() + "\n"; + else + return "Offset 0,0\n"; + } + } + + public bool ValidZTest { get { return m_validZTest; } } + public bool ValidZWrite { get { return m_validZWrite; } } + public bool ValidOffset { get { return m_validOffset; } } + public InlineProperty ZTestMode { get { return m_zTestMode; } } + public InlineProperty ZWriteMode { get { return m_zWriteMode; } } + public InlineProperty OffsetFactor { get { return m_offsetFactor; } } + public InlineProperty OffsetUnits { get { return m_offsetUnits; } } + public bool OffsetEnabled { get { return m_offsetEnabled; } } + + + public ZTestMode ZTestModeValue + { + set + { + m_zTestMode.IntValue = ZBufferOpHelper.ZTestModeDict[ value ]; + m_zTestMode.Active = false; + } + get + { + return (ZTestMode)( m_zTestMode.IntValue - 1 ); + } + } + public ZWriteMode ZWriteModeValue + { + set + { + m_zWriteMode.IntValue = ZBufferOpHelper.ZWriteModeDict[ value ]; + m_zWriteMode.Active = false; + } + get + { + return (ZWriteMode)( m_zWriteMode.IntValue - 1 ); + } + } + public float OffsetFactorValue + { + set + { + m_offsetEnabled = true; + m_offsetFactor.FloatValue = value; + m_offsetFactor.Active = false; + } + get + { + return m_offsetFactor.FloatValue; + } + } + + public float OffsetUnitsValue + { + set + { + m_offsetEnabled = true; + m_offsetUnits.FloatValue = value; + m_offsetUnits.Active = false; + } + get + { + return m_offsetUnits.FloatValue; + } + } + } +} |