You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1149 lines
34 KiB
1149 lines
34 KiB
// Amplify Shader Editor - Visual Shader Editing Tool
|
|
// Copyright (c) Amplify Creations, Lda <info@amplify.pt>
|
|
|
|
using System;
|
|
using System.Text.RegularExpressions;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
namespace AmplifyShaderEditor
|
|
{
|
|
/*ase_pass_options OLDEST
|
|
DefineOnConnected:portId:definevalue
|
|
DefineOnUnconnected:portId:definevalue
|
|
Options:name:defaultOption:opt0:opt1:opt2
|
|
SetVisible:PortId:OptionName:OptionValue
|
|
*/
|
|
|
|
/*ase_pass_options OLD
|
|
Option:Option Name:UI Type:Default:Item0,Item1,Item3...ItemN
|
|
Action:Action Type:Action Data:ConditionA && ConditionB || ConditionC:
|
|
*/
|
|
|
|
/*ase_pass_options:UniqueId:PropagateDataToHiddenPasses
|
|
Option:Color Offset:A,B,C:A
|
|
A:ShowPort:My Port Name
|
|
B,C:HidePort:My Port Name
|
|
B:SetDefine:MY_DEFINE
|
|
C:SetDefine:MY_COLOR_DEFINE
|
|
Option:My Other Option:True,False
|
|
True:ShowOption:Color Offset
|
|
False:HideOption:Color Offset
|
|
Port:My Port Name
|
|
On:SetDefine:MY_COLOR_DEFINE
|
|
Off:UnsetDefine:MY_COLOR_DEFINE
|
|
*/
|
|
public enum AseOptionsUIWidget
|
|
{
|
|
Dropdown,
|
|
Toggle,
|
|
Float,
|
|
FloatRange,
|
|
Int,
|
|
IntRange
|
|
}
|
|
|
|
public enum AseOptionsType
|
|
{
|
|
Option,
|
|
Port,
|
|
Field
|
|
}
|
|
|
|
|
|
public enum AseOptionItemSetup
|
|
{
|
|
None,
|
|
InvertActionOnDeselection
|
|
}
|
|
|
|
public enum AseOptionsActionType
|
|
{
|
|
ShowOption,
|
|
HideOption,
|
|
SetOption,
|
|
HidePort,
|
|
ShowPort,
|
|
SetPortName,
|
|
SetDefine,
|
|
RemoveDefine,
|
|
SetUndefine,
|
|
RemoveUndefine,
|
|
ExcludePass,
|
|
IncludePass,
|
|
SetPropertyOnPass,
|
|
SetPropertyOnSubShader,
|
|
SetShaderProperty,
|
|
SetMaterialProperty
|
|
}
|
|
|
|
public enum PropertyActionsEnum
|
|
{
|
|
CullMode,
|
|
ColorMask,
|
|
ColorMask1,
|
|
ColorMask2,
|
|
ColorMask3,
|
|
ZWrite,
|
|
ZTest,
|
|
ZOffsetFactor,
|
|
ZOffsetUnits,
|
|
BlendRGB,
|
|
BlendAlpha,
|
|
BlendOpRGB,
|
|
BlendOpAlpha,
|
|
BlendRGB1,
|
|
BlendAlpha1,
|
|
BlendOpRGB1,
|
|
BlendOpAlpha1,
|
|
BlendRGB2,
|
|
BlendAlpha2,
|
|
BlendOpRGB2,
|
|
BlendOpAlpha2,
|
|
BlendRGB3,
|
|
BlendAlpha3,
|
|
BlendOpRGB3,
|
|
BlendOpAlpha3,
|
|
StencilReference,
|
|
StencilReadMask,
|
|
StencilWriteMask,
|
|
StencilComparison,
|
|
StencilPass,
|
|
StencilFail,
|
|
StencilZFail,
|
|
RenderType,
|
|
RenderQueue,
|
|
DisableBatching
|
|
}
|
|
|
|
public enum AseOptionsSetup
|
|
{
|
|
CopyOptionsFromMainPass,
|
|
Id,
|
|
Name
|
|
}
|
|
|
|
[Serializable]
|
|
public class ItemColorMask
|
|
{
|
|
public bool ValueR = true;
|
|
public bool ValueG = true;
|
|
public bool ValueB = true;
|
|
public bool ValueA = true;
|
|
|
|
public bool MaskR = false;
|
|
public bool MaskG = false;
|
|
public bool MaskB = false;
|
|
public bool MaskA = false;
|
|
|
|
public bool[] GetColorMask( bool[] input )
|
|
{
|
|
bool[] result = { ValueR, ValueG, ValueB, ValueA };
|
|
result[ 0 ] = MaskR ? ValueR : input[ 0 ];
|
|
result[ 1 ] = MaskG ? ValueG : input[ 1 ];
|
|
result[ 2 ] = MaskB ? ValueB : input[ 2 ];
|
|
result[ 3 ] = MaskA ? ValueA : input[ 3 ];
|
|
return result;
|
|
}
|
|
|
|
public void SetColorMask( int index, string value )
|
|
{
|
|
switch( index )
|
|
{
|
|
default:
|
|
case 0:
|
|
{
|
|
MaskR = !string.IsNullOrEmpty( value );
|
|
if(MaskR)
|
|
ValueR = Convert.ToBoolean( value );
|
|
}
|
|
break;
|
|
case 1:
|
|
{
|
|
MaskG = !string.IsNullOrEmpty( value );
|
|
if( MaskG )
|
|
ValueG = Convert.ToBoolean( value );
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
MaskB = !string.IsNullOrEmpty( value );
|
|
if( MaskB )
|
|
ValueB = Convert.ToBoolean( value );
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
MaskA = !string.IsNullOrEmpty( value );
|
|
if( MaskA )
|
|
ValueA = Convert.ToBoolean( value );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class TemplateActionItem
|
|
{
|
|
public AseOptionsActionType ActionType;
|
|
public string ActionData = string.Empty;
|
|
public int ActionDataIdx = -1;
|
|
|
|
public string PassName;
|
|
public bool AllPasses = false;
|
|
|
|
public PropertyActionsEnum PropertyAction;
|
|
//CULL
|
|
public CullMode ActionCullMode;
|
|
//COLOR MASK
|
|
public ItemColorMask ColorMask = new ItemColorMask();
|
|
public ItemColorMask ColorMask1 = new ItemColorMask();
|
|
public ItemColorMask ColorMask2 = new ItemColorMask();
|
|
public ItemColorMask ColorMask3 = new ItemColorMask();
|
|
|
|
//DEPTH
|
|
public ZWriteMode ActionZWrite;
|
|
public ZTestMode ActionZTest;
|
|
public float ActionZOffsetFactor;
|
|
public float ActionZOffsetUnits;
|
|
|
|
//BLEND OPS
|
|
public AvailableBlendFactor ActionBlendRGBSource;
|
|
public AvailableBlendFactor ActionBlendRGBDest;
|
|
public AvailableBlendFactor ActionBlendAlphaSource;
|
|
public AvailableBlendFactor ActionBlendAlphaDest;
|
|
public AvailableBlendOps ActionBlendOpRGB;
|
|
public AvailableBlendOps ActionBlendOpAlpha;
|
|
|
|
public AvailableBlendFactor ActionBlendRGBSource1;
|
|
public AvailableBlendFactor ActionBlendRGBDest1;
|
|
public AvailableBlendFactor ActionBlendAlphaSource1;
|
|
public AvailableBlendFactor ActionBlendAlphaDest1;
|
|
public AvailableBlendOps ActionBlendOpRGB1;
|
|
public AvailableBlendOps ActionBlendOpAlpha1;
|
|
|
|
public AvailableBlendFactor ActionBlendRGBSource2;
|
|
public AvailableBlendFactor ActionBlendRGBDest2;
|
|
public AvailableBlendFactor ActionBlendAlphaSource2;
|
|
public AvailableBlendFactor ActionBlendAlphaDest2;
|
|
public AvailableBlendOps ActionBlendOpRGB2;
|
|
public AvailableBlendOps ActionBlendOpAlpha2;
|
|
|
|
public AvailableBlendFactor ActionBlendRGBSource3;
|
|
public AvailableBlendFactor ActionBlendRGBDest3;
|
|
public AvailableBlendFactor ActionBlendAlphaSource3;
|
|
public AvailableBlendFactor ActionBlendAlphaDest3;
|
|
public AvailableBlendOps ActionBlendOpRGB3;
|
|
public AvailableBlendOps ActionBlendOpAlpha3;
|
|
|
|
//STENCIL
|
|
public int ActionStencilReference;
|
|
public int ActionStencilReadMask;
|
|
public int ActionStencilWriteMask;
|
|
public int ActionStencilComparison;
|
|
public int ActionStencilPass;
|
|
public int ActionStencilFail;
|
|
public int ActionStencilZFail;
|
|
|
|
public bool CopyFromSubShader = false;
|
|
|
|
public string ActionBuffer;
|
|
public override string ToString()
|
|
{
|
|
return ActionType + " " + ActionData + " " + ActionDataIdx;
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class TemplateActionItemGrid
|
|
{
|
|
[Serializable]
|
|
public class TemplateActionItemRow
|
|
{
|
|
public TemplateActionItem[] Columns;
|
|
}
|
|
|
|
public TemplateActionItemRow[] Rows;
|
|
|
|
public TemplateActionItemGrid( int rowsCount )
|
|
{
|
|
Rows = new TemplateActionItemRow[ rowsCount ];
|
|
}
|
|
|
|
public TemplateActionItem this[ int row, int column ]
|
|
{
|
|
get { return Rows[ row ].Columns[ column ]; }
|
|
set { Rows[ row ].Columns[ column ] = value; }
|
|
}
|
|
|
|
public TemplateActionItem[] this[ int row ]
|
|
{
|
|
get { return Rows[ row ].Columns; }
|
|
|
|
set
|
|
{
|
|
if( Rows[ row ] == null )
|
|
Rows[ row ] = new TemplateActionItemRow();
|
|
|
|
Rows[ row ].Columns = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class TemplateOptionsItem
|
|
{
|
|
public AseOptionsType Type;
|
|
public AseOptionsUIWidget UIWidget;
|
|
public AseOptionItemSetup Setup = AseOptionItemSetup.None;
|
|
|
|
public string Id = string.Empty;
|
|
public string Name = string.Empty;
|
|
public string DefaultOption = string.Empty;
|
|
public string[] Options = null;
|
|
public string[] DisplayOptions = null;
|
|
public int DisableIdx = -1;
|
|
|
|
[SerializeField]
|
|
private float m_defaultFieldValue;
|
|
|
|
public float FieldMin;
|
|
public float FieldMax;
|
|
|
|
public bool FieldInline;
|
|
public string FieldInlineName;
|
|
public string FieldInlineOutput = string.Empty;
|
|
|
|
[SerializeField]
|
|
public InlineProperty FieldValue = new InlineProperty();
|
|
|
|
public TemplateActionItemGrid ActionsPerOption = null;
|
|
|
|
public int Count = 0;
|
|
|
|
[SerializeField]
|
|
private int m_defaultOptionIndex = -1;
|
|
|
|
~TemplateOptionsItem()
|
|
{
|
|
Options = null;
|
|
}
|
|
|
|
public int OptionIndexFor( string option )
|
|
{
|
|
for( int i = 0; i < Options.Length; i++ )
|
|
{
|
|
if( Options[ i ].Equals( option ) )
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
Debug.LogWarning( "Couldn't find index for option: " + option );
|
|
return 0;
|
|
}
|
|
|
|
public int DefaultOptionIndex
|
|
{
|
|
get
|
|
{
|
|
if( m_defaultOptionIndex > -1 )
|
|
return m_defaultOptionIndex;
|
|
|
|
for( int i = 0; i < Options.Length; i++ )
|
|
{
|
|
if( Options[ i ].Equals( DefaultOption ) )
|
|
{
|
|
m_defaultOptionIndex = i;
|
|
return i;
|
|
}
|
|
}
|
|
Debug.LogWarning( "Couldn't find index for default option: " + DefaultOption );
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public float DefaultFieldValue
|
|
{
|
|
get
|
|
{
|
|
return m_defaultFieldValue;
|
|
}
|
|
set
|
|
{
|
|
m_defaultFieldValue = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public class TemplateOptionsContainer
|
|
{
|
|
public bool Enabled = false;
|
|
public string Body = string.Empty;
|
|
public int Index = -1;
|
|
public int Id = -1;
|
|
public string Name = string.Empty;
|
|
public bool CopyOptionsFromMainPass = false;
|
|
public TemplateOptionsItem[] Options = null;
|
|
~TemplateOptionsContainer()
|
|
{
|
|
Options = null;
|
|
}
|
|
|
|
public void CopyPortOptionsFrom( TemplateOptionsContainer container, string passName )
|
|
{
|
|
if( container == null || container.Options == null )
|
|
return;
|
|
|
|
List<TemplateOptionsItem> newItems = new List<TemplateOptionsItem>();
|
|
for( int i = 0; i < container.Options.Length; i++ )
|
|
{
|
|
if( container.Options[ i ].Type == AseOptionsType.Port &&
|
|
container.Options[ i ].Id.Equals( passName ) )
|
|
{
|
|
newItems.Add( container.Options[ i ] );
|
|
}
|
|
}
|
|
|
|
if( newItems.Count > 0 )
|
|
{
|
|
Enabled = true;
|
|
if( Options == null )
|
|
{
|
|
Options = newItems.ToArray();
|
|
}
|
|
else
|
|
{
|
|
Array.Resize<TemplateOptionsItem>( ref Options, Options.Length + newItems.Count );
|
|
Array.Copy( newItems.ToArray(), Options, newItems.Count );
|
|
}
|
|
}
|
|
newItems.Clear();
|
|
newItems = null;
|
|
}
|
|
|
|
public int EndIndex { get { return Index + Body.Length; } }
|
|
}
|
|
|
|
public class TemplateOptionsToolsHelper
|
|
{
|
|
//public const string PassOptionsMainPattern = @"\/\*ase_pass_options:([\w:= ]*)[\n]([\w: \t;\n&|,_\+-]*)\*\/";
|
|
//public const string SubShaderOptionsMainPattern = @"\/\*ase_subshader_options:([\w:= ]*)[\n]([\w: \t;\n&|,_\+-]*)\*\/";
|
|
public const string PassOptionsMainPattern = "\\/\\*ase_pass_options:([\\w:= ]*)[\n]([\\w: \t;\n&|,_\\+\\-\\(\\)\\[\\]\\\"\\=\\/\\.]*)\\*\\/";
|
|
public const string SubShaderOptionsMainPattern = "\\/\\*ase_subshader_options:([\\w:= ]*)[\n]([\\w: \t;\n&|,_\\+\\-\\(\\)\\[\\]\\\"\\=\\/\\.]*)\\*\\/";
|
|
public static readonly char OptionsDataSeparator = ',';
|
|
public static Dictionary<string, AseOptionsSetup> AseOptionsSetupDict = new Dictionary<string, AseOptionsSetup>()
|
|
{
|
|
{ "CopyOptionsFromMainPass",AseOptionsSetup.CopyOptionsFromMainPass},
|
|
{ "Id",AseOptionsSetup.Id},
|
|
{ "Name",AseOptionsSetup.Name},
|
|
};
|
|
|
|
public static Dictionary<string, AseOptionsUIWidget> AseOptionsUITypeDict = new Dictionary<string, AseOptionsUIWidget>()
|
|
{
|
|
{ "Dropdown",AseOptionsUIWidget.Dropdown },
|
|
{ "Toggle", AseOptionsUIWidget.Toggle }
|
|
};
|
|
|
|
public static Dictionary<string, AseOptionsActionType> AseOptionsActionTypeDict = new Dictionary<string, AseOptionsActionType>()
|
|
{
|
|
{"ShowOption", AseOptionsActionType.ShowOption },
|
|
{"HideOption", AseOptionsActionType.HideOption },
|
|
{"SetOption", AseOptionsActionType.SetOption },
|
|
{"HidePort", AseOptionsActionType.HidePort },
|
|
{"ShowPort", AseOptionsActionType.ShowPort },
|
|
{"SetPortName", AseOptionsActionType.SetPortName },
|
|
{"SetDefine", AseOptionsActionType.SetDefine },
|
|
{"RemoveDefine", AseOptionsActionType.RemoveDefine },
|
|
{"SetUndefine", AseOptionsActionType.SetUndefine },
|
|
{"RemoveUndefine", AseOptionsActionType.RemoveUndefine },
|
|
{"ExcludePass", AseOptionsActionType.ExcludePass },
|
|
{"IncludePass", AseOptionsActionType.IncludePass },
|
|
{"SetPropertyOnPass", AseOptionsActionType.SetPropertyOnPass },
|
|
{"SetPropertyOnSubShader", AseOptionsActionType.SetPropertyOnSubShader },
|
|
{"SetShaderProperty", AseOptionsActionType.SetShaderProperty },
|
|
{"SetMaterialProperty", AseOptionsActionType.SetMaterialProperty }
|
|
};
|
|
|
|
public static Dictionary<string, AseOptionItemSetup> AseOptionItemSetupDict = new Dictionary<string, AseOptionItemSetup>
|
|
{
|
|
{"None", AseOptionItemSetup.None },
|
|
{ "InvertActionOnDeselection", AseOptionItemSetup.InvertActionOnDeselection}
|
|
};
|
|
|
|
public static bool InvertAction( AseOptionsActionType original, ref AseOptionsActionType inverted )
|
|
{
|
|
bool success = true;
|
|
switch( original )
|
|
{
|
|
case AseOptionsActionType.ShowOption:
|
|
inverted = AseOptionsActionType.HideOption;
|
|
break;
|
|
case AseOptionsActionType.HideOption:
|
|
inverted = AseOptionsActionType.ShowOption;
|
|
break;
|
|
case AseOptionsActionType.HidePort:
|
|
inverted = AseOptionsActionType.ShowPort;
|
|
break;
|
|
case AseOptionsActionType.ShowPort:
|
|
inverted = AseOptionsActionType.HidePort;
|
|
break;
|
|
case AseOptionsActionType.SetDefine:
|
|
inverted = AseOptionsActionType.RemoveDefine;
|
|
break;
|
|
case AseOptionsActionType.RemoveDefine:
|
|
inverted = AseOptionsActionType.SetDefine;
|
|
break;
|
|
case AseOptionsActionType.SetUndefine:
|
|
inverted = AseOptionsActionType.RemoveUndefine;
|
|
break;
|
|
case AseOptionsActionType.RemoveUndefine:
|
|
inverted = AseOptionsActionType.SetUndefine;
|
|
break;
|
|
case AseOptionsActionType.ExcludePass:
|
|
inverted = AseOptionsActionType.IncludePass;
|
|
break;
|
|
case AseOptionsActionType.IncludePass:
|
|
inverted = AseOptionsActionType.ExcludePass;
|
|
break;
|
|
case AseOptionsActionType.SetPortName:
|
|
case AseOptionsActionType.SetOption:
|
|
case AseOptionsActionType.SetPropertyOnPass:
|
|
case AseOptionsActionType.SetPropertyOnSubShader:
|
|
success = false;
|
|
break;
|
|
}
|
|
return success;
|
|
}
|
|
|
|
|
|
public static TemplateOptionsContainer GenerateOptionsContainer( bool isSubShader, string data )
|
|
{
|
|
TemplateOptionsContainer optionsContainer = new TemplateOptionsContainer();
|
|
|
|
Match match = Regex.Match( data, isSubShader ? SubShaderOptionsMainPattern : PassOptionsMainPattern );
|
|
optionsContainer.Enabled = match.Success;
|
|
if( match.Success )
|
|
{
|
|
try
|
|
{
|
|
optionsContainer.Body = match.Value;
|
|
optionsContainer.Index = match.Index;
|
|
|
|
List<TemplateOptionsItem> optionItemsList = new List<TemplateOptionsItem>();
|
|
List<List<TemplateActionItem>> actionItemsList = new List<List<TemplateActionItem>>();
|
|
Dictionary<string, int> optionItemToIndex = new Dictionary<string, int>();
|
|
TemplateOptionsItem currentOption = null;
|
|
|
|
//OPTIONS OVERALL SETUP
|
|
string[] setupLines = match.Groups[ 1 ].Value.Split( ':' );
|
|
for( int i = 0; i < setupLines.Length; i++ )
|
|
{
|
|
if( AseOptionsSetupDict.ContainsKey( setupLines[ i ] ) )
|
|
{
|
|
AseOptionsSetup setup = AseOptionsSetupDict[ setupLines[ i ] ];
|
|
switch( setup )
|
|
{
|
|
case AseOptionsSetup.CopyOptionsFromMainPass: optionsContainer.CopyOptionsFromMainPass = true; break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string[] args = setupLines[ i ].Split( '=' );
|
|
if( args.Length > 1 && AseOptionsSetupDict.ContainsKey( args[ 0 ] ) )
|
|
{
|
|
AseOptionsSetup setup = AseOptionsSetupDict[ args[ 0 ] ];
|
|
switch( setup )
|
|
{
|
|
case AseOptionsSetup.Id: if( !int.TryParse( args[ 1 ], out optionsContainer.Id ) ) optionsContainer.Id = -1; break;
|
|
case AseOptionsSetup.Name: optionsContainer.Name = args[ 1 ]; break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//AVAILABLE OPTIONS
|
|
string body = match.Groups[ 2 ].Value.Replace( "\t", string.Empty );
|
|
string[] optionLines = body.Split( '\n' );
|
|
for( int oL = 0; oL < optionLines.Length; oL++ )
|
|
{
|
|
string[] optionItems = optionLines[ oL ].Split( ':' );
|
|
if( optionItems.Length > 0 )
|
|
{
|
|
string[] itemIds = optionItems[ 0 ].Split( OptionsDataSeparator );
|
|
switch( itemIds[ 0 ] )
|
|
{
|
|
case "Option":
|
|
{
|
|
//Fills previous option with its actions
|
|
//actionItemsList is cleared over here
|
|
FillOptionAction( currentOption, ref actionItemsList );
|
|
|
|
optionItemToIndex.Clear();
|
|
currentOption = new TemplateOptionsItem();
|
|
currentOption.Type = AseOptionsType.Option;
|
|
string[] optionItemSetup = optionItems[ 1 ].Split( OptionsDataSeparator );
|
|
currentOption.Name = optionItemSetup[ 0 ];
|
|
if( optionItemSetup.Length > 1 )
|
|
{
|
|
if( AseOptionItemSetupDict.ContainsKey( optionItemSetup[ 1 ] ) )
|
|
currentOption.Setup = AseOptionItemSetupDict[ optionItemSetup[ 1 ] ];
|
|
}
|
|
|
|
currentOption.Id = itemIds.Length > 1 ? itemIds[ 1 ] : optionItems[ 1 ];
|
|
currentOption.DisplayOptions = optionItems[ 2 ].Split( OptionsDataSeparator );
|
|
currentOption.DisableIdx = currentOption.DisplayOptions.Length;
|
|
optionItems[ 2 ] += ",disable";
|
|
currentOption.Options = optionItems[ 2 ].Split( OptionsDataSeparator );
|
|
currentOption.Count = currentOption.Options.Length;
|
|
|
|
for( int opIdx = 0; opIdx < currentOption.Options.Length; opIdx++ )
|
|
{
|
|
optionItemToIndex.Add( currentOption.Options[ opIdx ], opIdx );
|
|
actionItemsList.Add( new List<TemplateActionItem>() );
|
|
}
|
|
|
|
if( optionItems.Length > 3 )
|
|
{
|
|
currentOption.DefaultOption = optionItems[ 3 ];
|
|
}
|
|
else
|
|
{
|
|
currentOption.DefaultOption = currentOption.Options[ 0 ];
|
|
}
|
|
|
|
if( currentOption.Options.Length == 2 || ( currentOption.Options.Length == 3 && currentOption.Options[ 2 ].Equals( "disable" ) ) )
|
|
{
|
|
if( ( currentOption.Options[ 0 ].Equals( "true" ) && currentOption.Options[ 1 ].Equals( "false" ) ) ||
|
|
( currentOption.Options[ 0 ].Equals( "false" ) && currentOption.Options[ 1 ].Equals( "true" ) ) )
|
|
{
|
|
// Toggle 0 is false and 1 is true
|
|
currentOption.Options[ 0 ] = "false";
|
|
currentOption.Options[ 1 ] = "true";
|
|
currentOption.UIWidget = AseOptionsUIWidget.Toggle;
|
|
}
|
|
}
|
|
else if( currentOption.Options.Length > 2 )
|
|
{
|
|
currentOption.UIWidget = AseOptionsUIWidget.Dropdown;
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning( "Detected an option with less than two items:" + optionItems[ 1 ] );
|
|
}
|
|
optionItemsList.Add( currentOption );
|
|
}
|
|
break;
|
|
case "Port":
|
|
{
|
|
//Fills previous option with its actions
|
|
//actionItemsList is cleared over here
|
|
FillOptionAction( currentOption, ref actionItemsList );
|
|
|
|
optionItemToIndex.Clear();
|
|
|
|
currentOption = new TemplateOptionsItem();
|
|
currentOption.Type = AseOptionsType.Port;
|
|
if( isSubShader && optionItems.Length > 2 )
|
|
{
|
|
currentOption.Id = optionItems[ 1 ];
|
|
currentOption.Name = optionItems[ 2 ];
|
|
}
|
|
else
|
|
{
|
|
currentOption.Name = optionItems[ 1 ];
|
|
}
|
|
|
|
currentOption.Options = new string[] { "On", "Off" };
|
|
optionItemToIndex.Add( currentOption.Options[ 0 ], 0 );
|
|
optionItemToIndex.Add( currentOption.Options[ 1 ], 1 );
|
|
|
|
actionItemsList.Add( new List<TemplateActionItem>() );
|
|
actionItemsList.Add( new List<TemplateActionItem>() );
|
|
|
|
optionItemsList.Add( currentOption );
|
|
}
|
|
break;
|
|
case "Field":
|
|
{
|
|
//Fills previous option with its actions
|
|
//actionItemsList is cleared over here
|
|
FillOptionAction( currentOption, ref actionItemsList );
|
|
|
|
optionItemToIndex.Clear();
|
|
currentOption = new TemplateOptionsItem();
|
|
currentOption.Type = AseOptionsType.Field;
|
|
|
|
currentOption.Id = optionItems[ 1 ];
|
|
currentOption.Name = optionItems[ 1 ];
|
|
|
|
currentOption.UIWidget = AseOptionsUIWidget.Float;
|
|
if( optionItems[ 2 ].Equals( "Int" ) )
|
|
currentOption.UIWidget = AseOptionsUIWidget.Int;
|
|
|
|
if( optionItems.Length >= 3 )
|
|
{
|
|
currentOption.DefaultFieldValue = Convert.ToSingle( optionItems[ 3 ], System.Globalization.CultureInfo.InvariantCulture );
|
|
}
|
|
|
|
if( optionItems.Length >= 6 )
|
|
{
|
|
if( currentOption.UIWidget == AseOptionsUIWidget.Int )
|
|
currentOption.UIWidget = AseOptionsUIWidget.Int;
|
|
else
|
|
currentOption.UIWidget = AseOptionsUIWidget.FloatRange;
|
|
|
|
currentOption.FieldMin = Convert.ToSingle( optionItems[ 4 ], System.Globalization.CultureInfo.InvariantCulture );
|
|
currentOption.FieldMax = Convert.ToSingle( optionItems[ 5 ], System.Globalization.CultureInfo.InvariantCulture );
|
|
}
|
|
|
|
if( optionItems.Length == 5 || optionItems.Length == 7 )
|
|
{
|
|
currentOption.FieldInline = true;
|
|
currentOption.FieldInlineName = optionItems[ optionItems.Length - 1 ];
|
|
}
|
|
|
|
currentOption.Options = new string[] { "Change", "Inline", "disable" };
|
|
|
|
optionItemToIndex.Add( currentOption.Options[ 0 ], 0 );
|
|
optionItemToIndex.Add( currentOption.Options[ 1 ], 1 );
|
|
optionItemToIndex.Add( currentOption.Options[ 2 ], 2 );
|
|
currentOption.DisableIdx = 2;
|
|
|
|
actionItemsList.Add( new List<TemplateActionItem>() );
|
|
actionItemsList.Add( new List<TemplateActionItem>() );
|
|
actionItemsList.Add( new List<TemplateActionItem>() );
|
|
|
|
optionItemsList.Add( currentOption );
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
if( optionItemToIndex.ContainsKey( optionItems[ 0 ] ) )
|
|
{
|
|
int idx = 0;
|
|
if( currentOption != null && currentOption.UIWidget == AseOptionsUIWidget.Toggle )
|
|
{
|
|
idx = ( optionItems[ 0 ].Equals( "true" ) ) ? 1 : 0;
|
|
if( optionItems[ 0 ].Equals( "disable" ) )
|
|
idx = 2;
|
|
}
|
|
else
|
|
{
|
|
idx = optionItemToIndex[ optionItems[ 0 ] ];
|
|
}
|
|
actionItemsList[ idx ].Add( CreateActionItem( isSubShader, optionItems ) );
|
|
}
|
|
else
|
|
{
|
|
//string[] ids = optionItems[ 0 ].Split( ',' );
|
|
if( itemIds.Length > 1 )
|
|
{
|
|
for( int i = 0; i < itemIds.Length; i++ )
|
|
{
|
|
if( optionItemToIndex.ContainsKey( itemIds[ i ] ) )
|
|
{
|
|
int idx = optionItemToIndex[ itemIds[ i ] ];
|
|
actionItemsList[ idx ].Add( CreateActionItem( isSubShader, optionItems ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Fills last option with its actions
|
|
FillOptionAction( currentOption, ref actionItemsList );
|
|
|
|
actionItemsList.Clear();
|
|
actionItemsList = null;
|
|
|
|
optionsContainer.Options = optionItemsList.ToArray();
|
|
optionItemsList.Clear();
|
|
optionItemsList = null;
|
|
|
|
optionItemToIndex.Clear();
|
|
optionItemToIndex = null;
|
|
}
|
|
catch( Exception e )
|
|
{
|
|
Debug.LogException( e );
|
|
}
|
|
}
|
|
return optionsContainer;
|
|
}
|
|
|
|
static void FillOptionAction( TemplateOptionsItem currentOption, ref List<List<TemplateActionItem>> actionItemsList )
|
|
{
|
|
if( currentOption != null )
|
|
{
|
|
int count = actionItemsList.Count;
|
|
currentOption.ActionsPerOption = new TemplateActionItemGrid( count );
|
|
for( int i = 0; i < count; i++ )
|
|
{
|
|
currentOption.ActionsPerOption[ i ] = actionItemsList[ i ].ToArray();
|
|
actionItemsList[ i ].Clear();
|
|
}
|
|
actionItemsList.Clear();
|
|
}
|
|
}
|
|
|
|
static TemplateActionItem CreateActionItem( bool isSubshader, string[] optionItems )
|
|
{
|
|
TemplateActionItem actionItem = new TemplateActionItem();
|
|
try
|
|
{
|
|
actionItem.ActionType = AseOptionsActionTypeDict[ optionItems[ 1 ] ];
|
|
int optionsIdx = 2;
|
|
if( optionItems.Length > 3 )
|
|
{
|
|
optionsIdx = 3;
|
|
actionItem.PassName = optionItems[ 2 ];
|
|
}
|
|
else
|
|
{
|
|
actionItem.AllPasses = isSubshader;
|
|
}
|
|
|
|
actionItem.ActionData = optionItems[ optionsIdx ];
|
|
|
|
switch( actionItem.ActionType )
|
|
{
|
|
case AseOptionsActionType.ShowOption:
|
|
case AseOptionsActionType.HideOption:
|
|
{
|
|
string[] arr = optionItems[ optionsIdx ].Split( OptionsDataSeparator );
|
|
if( arr.Length > 1 )
|
|
{
|
|
actionItem.ActionData = arr[ 0 ];
|
|
if( !int.TryParse( arr[ 1 ], out actionItem.ActionDataIdx ) )
|
|
{
|
|
actionItem.ActionDataIdx = -1;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case AseOptionsActionType.SetOption:
|
|
{
|
|
string[] arr = optionItems[ optionsIdx ].Split( OptionsDataSeparator );
|
|
if( arr.Length > 1 )
|
|
{
|
|
actionItem.ActionData = arr[ 0 ];
|
|
if( !int.TryParse( arr[ 1 ], out actionItem.ActionDataIdx ) )
|
|
{
|
|
Debug.LogWarning( "SetOption value must be a the selection index" );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case AseOptionsActionType.HidePort:
|
|
case AseOptionsActionType.ShowPort:
|
|
{
|
|
if( !int.TryParse( actionItem.ActionData, out actionItem.ActionDataIdx ) )
|
|
actionItem.ActionDataIdx = -1;
|
|
}
|
|
break;
|
|
case AseOptionsActionType.SetPortName:
|
|
{
|
|
string[] arr = optionItems[ optionsIdx ].Split( OptionsDataSeparator );
|
|
if( arr.Length > 1 )
|
|
{
|
|
int.TryParse( arr[ 0 ], out actionItem.ActionDataIdx );
|
|
actionItem.ActionData = arr[ 1 ];
|
|
}
|
|
}
|
|
break;
|
|
case AseOptionsActionType.SetDefine:
|
|
case AseOptionsActionType.RemoveDefine:
|
|
case AseOptionsActionType.SetUndefine:
|
|
case AseOptionsActionType.RemoveUndefine:
|
|
case AseOptionsActionType.ExcludePass:
|
|
case AseOptionsActionType.IncludePass:
|
|
break;
|
|
case AseOptionsActionType.SetShaderProperty:
|
|
{
|
|
int optIndex = optionItems[ optionsIdx ].IndexOf( OptionsDataSeparator );
|
|
if( optIndex > -1 )
|
|
{
|
|
actionItem.ActionData = optionItems[ optionsIdx ].Substring( 0, optIndex );
|
|
actionItem.ActionBuffer = optionItems[ optionsIdx ].Substring( optIndex + 1, optionItems[ optionsIdx ].Length - optIndex - 1);
|
|
}
|
|
}break;
|
|
case AseOptionsActionType.SetMaterialProperty:
|
|
{
|
|
int optIndex = optionItems[ optionsIdx ].IndexOf( OptionsDataSeparator );
|
|
if( optIndex > -1 )
|
|
{
|
|
actionItem.ActionData = optionItems[ optionsIdx ].Substring( 0, optIndex );
|
|
}
|
|
}
|
|
break;
|
|
case AseOptionsActionType.SetPropertyOnPass:
|
|
case AseOptionsActionType.SetPropertyOnSubShader:
|
|
{
|
|
string[] arr = optionItems[ optionsIdx ].Split( OptionsDataSeparator );
|
|
actionItem.PropertyAction = (PropertyActionsEnum)Enum.Parse( typeof( PropertyActionsEnum ), arr[ 0 ] );
|
|
if( arr.Length == 1 && actionItem.ActionType == AseOptionsActionType.SetPropertyOnPass )
|
|
{
|
|
actionItem.CopyFromSubShader = true;
|
|
}
|
|
else
|
|
{
|
|
switch( actionItem.PropertyAction )
|
|
{
|
|
case PropertyActionsEnum.CullMode:
|
|
{
|
|
if( arr.Length > 1 )
|
|
actionItem.ActionCullMode = (CullMode)Enum.Parse( typeof( CullMode ), arr[ 1 ] );
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.ColorMask:
|
|
{
|
|
if( arr.Length > 4 )
|
|
{
|
|
actionItem.ColorMask.SetColorMask( 0, arr[ 1 ] );
|
|
actionItem.ColorMask.SetColorMask( 1, arr[ 2 ] );
|
|
actionItem.ColorMask.SetColorMask( 2, arr[ 3 ] );
|
|
actionItem.ColorMask.SetColorMask( 3, arr[ 4 ] );
|
|
}
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.ColorMask1:
|
|
{
|
|
if( arr.Length > 4 )
|
|
{
|
|
actionItem.ColorMask1.SetColorMask( 0, arr[ 1 ] );
|
|
actionItem.ColorMask1.SetColorMask( 1, arr[ 2 ] );
|
|
actionItem.ColorMask1.SetColorMask( 2, arr[ 3 ] );
|
|
actionItem.ColorMask1.SetColorMask( 3, arr[ 4 ] );
|
|
}
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.ColorMask2:
|
|
{
|
|
if( arr.Length > 4 )
|
|
{
|
|
actionItem.ColorMask2.SetColorMask( 0, arr[ 1 ] );
|
|
actionItem.ColorMask2.SetColorMask( 1, arr[ 2 ] );
|
|
actionItem.ColorMask2.SetColorMask( 2, arr[ 3 ] );
|
|
actionItem.ColorMask2.SetColorMask( 3, arr[ 4 ] );
|
|
}
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.ColorMask3:
|
|
{
|
|
if( arr.Length > 4 )
|
|
{
|
|
actionItem.ColorMask3.SetColorMask( 0, arr[ 1 ] );
|
|
actionItem.ColorMask3.SetColorMask( 1, arr[ 2 ] );
|
|
actionItem.ColorMask3.SetColorMask( 2, arr[ 3 ] );
|
|
actionItem.ColorMask3.SetColorMask( 3, arr[ 4 ] );
|
|
}
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.ZWrite:
|
|
{
|
|
if( arr.Length > 1 )
|
|
actionItem.ActionZWrite = (ZWriteMode)Enum.Parse( typeof( ZWriteMode ), arr[ 1 ] );
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.ZTest:
|
|
{
|
|
if( arr.Length > 1 )
|
|
actionItem.ActionZTest = (ZTestMode)Enum.Parse( typeof( ZTestMode ), arr[ 1 ] );
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.ZOffsetFactor:
|
|
{
|
|
if( arr.Length > 1 )
|
|
actionItem.ActionZOffsetFactor = Convert.ToSingle( arr[ 1 ] );
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.ZOffsetUnits:
|
|
{
|
|
if( arr.Length > 1 )
|
|
actionItem.ActionZOffsetUnits = Convert.ToSingle( arr[ 1 ] );
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.BlendRGB:
|
|
{
|
|
if( arr.Length > 2 )
|
|
{
|
|
actionItem.ActionBlendRGBSource = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), arr[ 1 ] );
|
|
actionItem.ActionBlendRGBDest = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), arr[ 2 ] );
|
|
}
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.BlendRGB1:
|
|
{
|
|
if( arr.Length > 2 )
|
|
{
|
|
actionItem.ActionBlendRGBSource1 = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), arr[ 1 ] );
|
|
actionItem.ActionBlendRGBDest1 = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), arr[ 2 ] );
|
|
}
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.BlendRGB2:
|
|
{
|
|
if( arr.Length > 2 )
|
|
{
|
|
actionItem.ActionBlendRGBSource2 = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), arr[ 1 ] );
|
|
actionItem.ActionBlendRGBDest2 = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), arr[ 2 ] );
|
|
}
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.BlendRGB3:
|
|
{
|
|
if( arr.Length > 2 )
|
|
{
|
|
actionItem.ActionBlendRGBSource3 = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), arr[ 1 ] );
|
|
actionItem.ActionBlendRGBDest3 = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), arr[ 2 ] );
|
|
}
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.BlendAlpha:
|
|
{
|
|
if( arr.Length > 2 )
|
|
{
|
|
actionItem.ActionBlendAlphaSource = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), arr[ 1 ] );
|
|
actionItem.ActionBlendAlphaDest = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), arr[ 2 ] );
|
|
}
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.BlendAlpha1:
|
|
{
|
|
if( arr.Length > 2 )
|
|
{
|
|
actionItem.ActionBlendAlphaSource1 = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), arr[ 1 ] );
|
|
actionItem.ActionBlendAlphaDest1 = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), arr[ 2 ] );
|
|
}
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.BlendAlpha2:
|
|
{
|
|
if( arr.Length > 2 )
|
|
{
|
|
actionItem.ActionBlendAlphaSource2 = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), arr[ 1 ] );
|
|
actionItem.ActionBlendAlphaDest2 = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), arr[ 2 ] );
|
|
}
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.BlendAlpha3:
|
|
{
|
|
if( arr.Length > 2 )
|
|
{
|
|
actionItem.ActionBlendAlphaSource3 = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), arr[ 1 ] );
|
|
actionItem.ActionBlendAlphaDest3 = (AvailableBlendFactor)Enum.Parse( typeof( AvailableBlendFactor ), arr[ 2 ] );
|
|
}
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.BlendOpRGB:
|
|
{
|
|
if( arr.Length > 1 )
|
|
{
|
|
actionItem.ActionBlendOpRGB = (AvailableBlendOps)Enum.Parse( typeof( AvailableBlendOps ), arr[ 1 ] );
|
|
|
|
}
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.BlendOpAlpha:
|
|
{
|
|
if( arr.Length > 1 )
|
|
{
|
|
actionItem.ActionBlendOpAlpha = (AvailableBlendOps)Enum.Parse( typeof( AvailableBlendOps ), arr[ 1 ] );
|
|
}
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.StencilReference:
|
|
{
|
|
if( arr.Length > 1 )
|
|
{
|
|
int.TryParse( arr[ 1 ], out actionItem.ActionStencilReference );
|
|
}
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.StencilReadMask:
|
|
{
|
|
if( arr.Length > 1 )
|
|
{
|
|
int.TryParse( arr[ 1 ], out actionItem.ActionStencilReadMask );
|
|
}
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.StencilWriteMask:
|
|
{
|
|
if( arr.Length > 1 )
|
|
{
|
|
int.TryParse( arr[ 1 ], out actionItem.ActionStencilWriteMask );
|
|
}
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.StencilComparison:
|
|
{
|
|
if( arr.Length > 1 )
|
|
actionItem.ActionStencilComparison = StencilBufferOpHelper.StencilComparisonValuesDict[ arr[ 1 ] ];
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.StencilPass:
|
|
{
|
|
if( arr.Length > 1 )
|
|
actionItem.ActionStencilPass = StencilBufferOpHelper.StencilOpsValuesDict[ arr[ 1 ] ];
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.StencilFail:
|
|
{
|
|
if( arr.Length > 1 )
|
|
actionItem.ActionStencilFail = StencilBufferOpHelper.StencilOpsValuesDict[ arr[ 1 ] ];
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.StencilZFail:
|
|
{
|
|
if( arr.Length > 1 )
|
|
actionItem.ActionStencilZFail = StencilBufferOpHelper.StencilOpsValuesDict[ arr[ 1 ] ];
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.RenderType:
|
|
{
|
|
if( arr.Length > 1 )
|
|
actionItem.ActionData = arr[ 1 ];
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.RenderQueue:
|
|
{
|
|
if( arr.Length > 1 )
|
|
actionItem.ActionData = arr[ 1 ];
|
|
if( arr.Length > 2 )
|
|
{
|
|
int.TryParse( arr[ 2 ], out actionItem.ActionDataIdx );
|
|
}
|
|
else
|
|
{
|
|
actionItem.ActionDataIdx = 0;
|
|
}
|
|
}
|
|
break;
|
|
case PropertyActionsEnum.DisableBatching:
|
|
{
|
|
if( arr.Length > 1 )
|
|
actionItem.ActionData = arr[ 1 ];
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
catch( Exception e )
|
|
{
|
|
Debug.LogException( e );
|
|
}
|
|
return actionItem;
|
|
}
|
|
}
|
|
}
|