using UnityEditor.ShaderGraph;
using UnityEngine;
using System;
using UnityEditor.ShaderGraph.Internal;
using System.Linq;
using BlendMode = UnityEngine.Rendering.BlendMode;
using BlendOp = UnityEditor.ShaderGraph.BlendOp;
using UnityEngine.UIElements;
using UnityEngine.Rendering;
namespace UnityEditor.Rendering.Fullscreen.ShaderGraph
{
[GenerateBlocks("Fullscreen")]
internal struct FullscreenBlocks
{
public static BlockFieldDescriptor color = new BlockFieldDescriptor(BlockFields.SurfaceDescription.name, "FullscreenColor", "Color",
"SURFACEDESCRIPTION_COLOR", new ColorControl(UnityEngine.Color.grey, true), ShaderStage.Fragment);
public static BlockFieldDescriptor eyeDepth = new BlockFieldDescriptor(BlockFields.SurfaceDescription.name, "FullscreenEyeDepth", "Eye Depth",
"SURFACEDESCRIPTION_EYE_DEPTH", new FloatControl(0), ShaderStage.Fragment);
public static BlockFieldDescriptor linear01Depth = new BlockFieldDescriptor(BlockFields.SurfaceDescription.name, "FullscreenLinear01Depth", "Linear01 Depth",
"SURFACEDESCRIPTION_LINEAR01_DEPTH", new FloatControl(0), ShaderStage.Fragment);
public static BlockFieldDescriptor rawDepth = new BlockFieldDescriptor(BlockFields.SurfaceDescription.name, "FullscreenRawDepth", "Raw Depth",
"SURFACEDESCRIPTION_RAW_DEPTH", new FloatControl(0), ShaderStage.Fragment);
}
[GenerationAPI]
internal struct FullscreenFields
{
public static FieldDescriptor depth = new FieldDescriptor("OUTPUT", "depth", "OUTPUT_DEPTH");
}
internal enum FullscreenMode
{
FullScreen,
CustomRenderTexture,
}
internal enum FullscreenCompatibility
{
Blit,
DrawProcedural,
}
internal enum FullscreenBlendMode
{
Disabled,
Alpha,
Premultiply,
Additive,
Multiply,
Custom,
}
internal enum FullscreenDepthWriteMode
{
LinearEye,
Linear01,
Raw,
}
internal static class FullscreenUniforms
{
public static readonly string blendModeProperty = "_Fullscreen_BlendMode";
public static readonly string srcColorBlendProperty = "_Fullscreen_SrcColorBlend";
public static readonly string dstColorBlendProperty = "_Fullscreen_DstColorBlend";
public static readonly string srcAlphaBlendProperty = "_Fullscreen_SrcAlphaBlend";
public static readonly string dstAlphaBlendProperty = "_Fullscreen_DstAlphaBlend";
public static readonly string colorBlendOperationProperty = "_Fullscreen_ColorBlendOperation";
public static readonly string alphaBlendOperationProperty = "_Fullscreen_AlphaBlendOperation";
public static readonly string depthWriteProperty = "_Fullscreen_DepthWrite";
public static readonly string depthTestProperty = "_Fullscreen_DepthTest";
public static readonly string stencilEnableProperty = "_Fullscreen_Stencil";
public static readonly string stencilReferenceProperty = "_Fullscreen_StencilReference";
public static readonly string stencilReadMaskProperty = "_Fullscreen_StencilReadMask";
public static readonly string stencilWriteMaskProperty = "_Fullscreen_StencilWriteMask";
public static readonly string stencilComparisonProperty = "_Fullscreen_StencilComparison";
public static readonly string stencilPassProperty = "_Fullscreen_StencilPass";
public static readonly string stencilFailProperty = "_Fullscreen_StencilFail";
public static readonly string stencilDepthFailProperty = "_Fullscreen_StencilDepthFail";
public static readonly string srcColorBlend = "[" + srcColorBlendProperty + "]";
public static readonly string dstColorBlend = "[" + dstColorBlendProperty + "]";
public static readonly string srcAlphaBlend = "[" + srcAlphaBlendProperty + "]";
public static readonly string dstAlphaBlend = "[" + dstAlphaBlendProperty + "]";
public static readonly string colorBlendOperation = "[" + colorBlendOperationProperty + "]";
public static readonly string alphaBlendOperation = "[" + alphaBlendOperationProperty + "]";
public static readonly string depthWrite = "[" + depthWriteProperty + "]";
public static readonly string depthTest = "[" + depthTestProperty + "]";
public static readonly string stencilReference = "[" + stencilReferenceProperty + "]";
public static readonly string stencilReadMask = "[" + stencilReadMaskProperty + "]";
public static readonly string stencilWriteMask = "[" + stencilWriteMaskProperty + "]";
public static readonly string stencilComparison = "[" + stencilComparisonProperty + "]";
public static readonly string stencilPass = "[" + stencilPassProperty + "]";
public static readonly string stencilFail = "[" + stencilFailProperty + "]";
public static readonly string stencilDepthFail = "[" + stencilDepthFailProperty + "]";
}
internal abstract class FullscreenSubTarget<T> : SubTarget<T>, IRequiresData<FullscreenData>, IHasMetadata where T : Target
{
static readonly GUID kSourceCodeGuid = new GUID("1cfc804c75474e144be5d4158b9522ed"); // FullscreenSubTarget.cs // TODO
static readonly string[] kSharedTemplateDirectories = GenerationUtils.GetDefaultSharedTemplateDirectories().Union(new string[] { "Packages/com.unity.shadergraph/Editor/Generation/Targets/Fullscreen/Templates" }).ToArray();
// HLSL includes
protected static readonly string kFullscreenCommon = "Packages/com.unity.shadergraph/Editor/Generation/Targets/Fullscreen/Includes/FullscreenCommon.hlsl";
protected static readonly string kTemplatePath = "Packages/com.unity.shadergraph/Editor/Generation/Targets/Fullscreen/Templates/ShaderPass.template";
protected static readonly string kCommon = "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl";
protected static readonly string kColor = "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl";
protected static readonly string kTexture = "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl";
protected static readonly string kInstancing = "Packages/com.unity.render-pipelines.core/ShaderLibrary/UnityInstancing.hlsl";
protected static readonly string kFullscreenShaderPass = "Packages/com.unity.shadergraph/Editor/Generation/Targets/Fullscreen/Includes/FullscreenShaderPass.cs.hlsl";
protected static readonly string kSpaceTransforms = "Packages/com.unity.render-pipelines.core/ShaderLibrary/SpaceTransforms.hlsl";
protected static readonly string kFunctions = "Packages/com.unity.shadergraph/ShaderGraphLibrary/Functions.hlsl";
protected static readonly string kTextureStack = "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl";
protected virtual string fullscreenDrawProceduralInclude => "Packages/com.unity.shadergraph/Editor/Generation/Targets/Fullscreen/Includes/FullscreenDrawProcedural.hlsl";
protected virtual string fullscreenBlitInclude => "Packages/com.unity.shadergraph/Editor/Generation/Targets/Fullscreen/Includes/FullscreenBlit.hlsl";
FullscreenData m_FullscreenData;
FullscreenData IRequiresData<FullscreenData>.data
{
get => m_FullscreenData;
set => m_FullscreenData = value;
}
public FullscreenData fullscreenData
{
get => m_FullscreenData;
set => m_FullscreenData = value;
}
public override void Setup(ref TargetSetupContext context)
{
context.AddAssetDependency(kSourceCodeGuid, AssetCollection.Flags.SourceDependency);
context.SetDefaultShaderGUI(GetDefaultShaderGUI().FullName);
context.AddSubShader(GenerateSubShader());
}
protected virtual IncludeCollection pregraphIncludes => new IncludeCollection();
protected abstract string pipelineTag { get; }
protected virtual Type GetDefaultShaderGUI() => typeof(FullscreenShaderGUI);
public virtual string identifier => GetType().Name;
public virtual ScriptableObject GetMetadataObject(GraphDataReadOnly graph)
{
var bultInMetadata = ScriptableObject.CreateInstance<FullscreenMetaData>();
bultInMetadata.fullscreenMode = fullscreenData.fullscreenMode;
return bultInMetadata;
}
public RenderStateCollection GetRenderState()
{
var result = new RenderStateCollection();
if (fullscreenData.allowMaterialOverride)
{
if (fullscreenData.depthTestMode != CompareFunction.Disabled)
result.Add(RenderState.ZTest(FullscreenUniforms.depthTest));
else
result.Add(RenderState.ZTest("Off"));
result.Add(RenderState.ZWrite(FullscreenUniforms.depthWrite));
if (fullscreenData.blendMode != FullscreenBlendMode.Disabled)
{
result.Add(RenderState.Blend(FullscreenUniforms.srcColorBlend, FullscreenUniforms.dstColorBlend, FullscreenUniforms.srcAlphaBlend, FullscreenUniforms.dstAlphaBlend));
result.Add(RenderState.BlendOp(FullscreenUniforms.colorBlendOperation, FullscreenUniforms.alphaBlendOperation));
}
else
{
result.Add(RenderState.Blend("Blend Off"));
}
if (fullscreenData.enableStencil)
{
result.Add(RenderState.Stencil(new StencilDescriptor { Ref = FullscreenUniforms.stencilReference, ReadMask = FullscreenUniforms.stencilReadMask, WriteMask = FullscreenUniforms.stencilWriteMask, Comp = FullscreenUniforms.stencilComparison, ZFail = FullscreenUniforms.stencilDepthFail, Fail = FullscreenUniforms.stencilFail, Pass = FullscreenUniforms.stencilPass }));
}
}
else
{
if (fullscreenData.depthTestMode == CompareFunction.Disabled)
result.Add(RenderState.ZTest("Off"));
else
result.Add(RenderState.ZTest(CompareFunctionToZTest(fullscreenData.depthTestMode).ToString()));
result.Add(RenderState.ZWrite(fullscreenData.depthWrite ? ZWrite.On.ToString() : ZWrite.Off.ToString()));
// Blend mode
if (fullscreenData.blendMode == FullscreenBlendMode.Alpha)
result.Add(RenderState.Blend(Blend.SrcAlpha, Blend.OneMinusSrcAlpha, Blend.One, Blend.OneMinusSrcAlpha));
else if (fullscreenData.blendMode == FullscreenBlendMode.Premultiply)
result.Add(RenderState.Blend(Blend.One, Blend.OneMinusSrcAlpha, Blend.One, Blend.OneMinusSrcAlpha));
else if (fullscreenData.blendMode == FullscreenBlendMode.Additive)
result.Add(RenderState.Blend(Blend.SrcAlpha, Blend.One, Blend.One, Blend.One));
else if (fullscreenData.blendMode == FullscreenBlendMode.Multiply)
result.Add(RenderState.Blend(Blend.DstColor, Blend.Zero));
else if (fullscreenData.blendMode == FullscreenBlendMode.Disabled)
result.Add(RenderState.Blend("Blend Off"));
else
{
result.Add(RenderState.Blend(BlendModeToBlend(fullscreenData.srcColorBlendMode), BlendModeToBlend(fullscreenData.dstColorBlendMode), BlendModeToBlend(fullscreenData.srcAlphaBlendMode), BlendModeToBlend(fullscreenData.dstAlphaBlendMode)));
result.Add(RenderState.BlendOp(fullscreenData.colorBlendOperation, fullscreenData.alphaBlendOperation));
}
if (fullscreenData.enableStencil)
{
result.Add(RenderState.Stencil(new StencilDescriptor
{
Ref = fullscreenData.stencilReference.ToString(),
ReadMask = fullscreenData.stencilReadMask.ToString(),
WriteMask = fullscreenData.stencilWriteMask.ToString(),
Comp = CompareFunctionToStencilString(fullscreenData.stencilCompareFunction),
ZFail = StencilOpToStencilString(fullscreenData.stencilDepthTestFailOperation),
Fail = StencilOpToStencilString(fullscreenData.stencilFailOperation),
Pass = StencilOpToStencilString(fullscreenData.stencilPassOperation),
}));
}
}
result.Add(RenderState.Cull(UnityEditor.ShaderGraph.Cull.Off));
return result;
}
public static Blend BlendModeToBlend(BlendMode mode)
{
switch (mode)
{
case BlendMode.Zero: return Blend.Zero;
case BlendMode.One: return Blend.One;
case BlendMode.DstColor: return Blend.DstColor;
case BlendMode.SrcColor: return Blend.SrcColor;
case BlendMode.OneMinusDstColor: return Blend.OneMinusDstColor;
case BlendMode.SrcAlpha: return Blend.SrcAlpha;
case BlendMode.OneMinusSrcColor: return Blend.OneMinusSrcColor;
case BlendMode.DstAlpha: return Blend.DstAlpha;
case BlendMode.OneMinusDstAlpha: return Blend.OneMinusDstAlpha;
case BlendMode.SrcAlphaSaturate: return Blend.SrcAlpha;
case BlendMode.OneMinusSrcAlpha: return Blend.OneMinusSrcAlpha;
default: return Blend.Zero;
}
;
}
public static ZTest CompareFunctionToZTest(CompareFunction mode)
{
switch (mode)
{
case CompareFunction.Equal: return ZTest.Equal;
case CompareFunction.NotEqual: return ZTest.NotEqual;
case CompareFunction.Greater: return ZTest.Greater;
case CompareFunction.Less: return ZTest.Less;
case CompareFunction.GreaterEqual: return ZTest.GEqual;
case CompareFunction.LessEqual: return ZTest.LEqual;
case CompareFunction.Always: return ZTest.Always;
case CompareFunction.Disabled: return ZTest.Always;
default: return ZTest.Always;
}
;
}
public static string CompareFunctionToStencilString(CompareFunction compare)
{
switch (compare)
{
case CompareFunction.Never: return "Never";
case CompareFunction.Equal: return "Equal";
case CompareFunction.NotEqual: return "NotEqual";
case CompareFunction.Greater: return "Greater";
case CompareFunction.Less: return "Less";
case CompareFunction.GreaterEqual: return "GEqual";
case CompareFunction.LessEqual: return "LEqual";
case CompareFunction.Always: return "Always";
default: return "Always";
}
;
}
public static string StencilOpToStencilString(StencilOp op)
{
switch (op)
{
case StencilOp.Keep: return "Keep";
case StencilOp.Zero: return "Zero";
case StencilOp.Replace: return "Replace";
case StencilOp.IncrementSaturate: return "IncrSat";
case StencilOp.DecrementSaturate: return "DecrSat";
case StencilOp.Invert: return "Invert";
case StencilOp.IncrementWrap: return "IncrWrap";
case StencilOp.DecrementWrap: return "DecrWrap";
default: return "Keep";
}
;
}
public virtual SubShaderDescriptor GenerateSubShader()
{
var result = new SubShaderDescriptor()
{
generatesPreview = true,
passes = new PassCollection(),
pipelineTag = pipelineTag,
};
result.passes.Add(GenerateFullscreenPass(FullscreenCompatibility.DrawProcedural));
result.passes.Add(GenerateFullscreenPass(FullscreenCompatibility.Blit));
return result;
}
public virtual IncludeCollection GetPreGraphIncludes()
{
return new IncludeCollection
{
{ kCommon, IncludeLocation.Pregraph },
{ kColor, IncludeLocation.Pregraph },
{ kTexture, IncludeLocation.Pregraph },
{ kTextureStack, IncludeLocation.Pregraph },
{ kFullscreenShaderPass, IncludeLocation.Pregraph }, // For VR
{ pregraphIncludes },
{ kSpaceTransforms, IncludeLocation.Pregraph },
{ kFunctions, IncludeLocation.Pregraph },
};
}
public virtual IncludeCollection GetPostGraphIncludes()
{
return new IncludeCollection { { kFullscreenCommon, IncludeLocation.Postgraph } };
}
static readonly KeywordDescriptor depthWriteKeyword = new KeywordDescriptor
{
displayName = "Depth Write",
referenceName = "DEPTH_WRITE",
type = KeywordType.Boolean,
definition = KeywordDefinition.ShaderFeature,
stages = KeywordShaderStage.Fragment,
};
static readonly KeywordDescriptor depthWriteModeKeyword = new KeywordDescriptor
{
displayName = "Depth Write Mode",
referenceName = "DEPTH_WRITE_MODE",
type = KeywordType.Enum,
definition = KeywordDefinition.Predefined,
entries = new KeywordEntry[]
{
new KeywordEntry("Eye Depth", "EYE"),
new KeywordEntry("Eye Linear 01", "LINEAR01"),
new KeywordEntry("Eye Raw", "RAW"),
},
stages = KeywordShaderStage.Fragment,
};
public static StructDescriptor Varyings = new StructDescriptor()
{
name = "Varyings",
packFields = true,
populateWithCustomInterpolators = false,
fields = new FieldDescriptor[]
{
StructFields.Varyings.positionCS,
StructFields.Varyings.texCoord0,
StructFields.Varyings.texCoord1,
StructFields.Varyings.instanceID,
StructFields.Varyings.stereoTargetEyeIndexAsBlendIdx0,
StructFields.Varyings.stereoTargetEyeIndexAsRTArrayIdx,
}
};
protected virtual DefineCollection GetPassDefines(FullscreenCompatibility compatibility)
=> new DefineCollection();
protected virtual KeywordCollection GetPassKeywords(FullscreenCompatibility compatibility)
=> new KeywordCollection();
static StructDescriptor GetFullscreenAttributes(FullscreenCompatibility compatibility)
{
var desc = new StructDescriptor()
{
name = "Attributes",
packFields = false,
};
if (compatibility == FullscreenCompatibility.Blit)
{
desc.fields = new FieldDescriptor[]
{
StructFields.Attributes.instanceID,
StructFields.Attributes.vertexID,
StructFields.Attributes.positionOS,
};
}
else
{
desc.fields = new FieldDescriptor[]
{
StructFields.Attributes.instanceID,
StructFields.Attributes.vertexID,
};
}
return desc;
}
public virtual PassDescriptor GenerateFullscreenPass(FullscreenCompatibility compatibility)
{
var fullscreenPass = new PassDescriptor
{
// Definition
displayName = compatibility.ToString(),
referenceName = "SHADERPASS_" + compatibility.ToString().ToUpper(),
useInPreview = true,
// Template
passTemplatePath = kTemplatePath,
sharedTemplateDirectories = kSharedTemplateDirectories,
// Port Mask
validVertexBlocks = null,
validPixelBlocks = new BlockFieldDescriptor[]
{
BlockFields.SurfaceDescription.BaseColor,
BlockFields.SurfaceDescription.Alpha,
FullscreenBlocks.eyeDepth,
FullscreenBlocks.linear01Depth,
FullscreenBlocks.rawDepth,
},
// Fields
structs = new StructCollection
{
{ GetFullscreenAttributes(compatibility) },
{ Structs.SurfaceDescriptionInputs },
{ Varyings },
{ Structs.VertexDescriptionInputs },
},
fieldDependencies = FieldDependencies.Default,
requiredFields = new FieldCollection
{
StructFields.Varyings.texCoord0, // Always need texCoord0 to calculate the other properties in fullscreen node code
StructFields.Varyings.texCoord1, // We store the view direction computed in the vertex in the texCoord1
StructFields.Attributes.vertexID, // Need the vertex Id for the DrawProcedural case
},
// Conditional State
renderStates = GetRenderState(),
pragmas = new PragmaCollection
{
{ Pragma.Target(ShaderModel.Target30) },
{ Pragma.Vertex("vert") },
{ Pragma.Fragment("frag") },
},
defines = new DefineCollection
{
{depthWriteKeyword, 1, new FieldCondition(FullscreenFields.depth, true)},
{depthWriteModeKeyword, (int)fullscreenData.depthWriteMode, new FieldCondition(FullscreenFields.depth, true)},
GetPassDefines(compatibility),
},
keywords = GetPassKeywords(compatibility),
includes = new IncludeCollection
{
// Pre-graph
GetPreGraphIncludes(),
// Post-graph
GetPostGraphIncludes(),
},
};
switch (compatibility)
{
default:
case FullscreenCompatibility.Blit:
fullscreenPass.includes.Add(fullscreenBlitInclude, IncludeLocation.Postgraph);
break;
case FullscreenCompatibility.DrawProcedural:
fullscreenPass.includes.Add(fullscreenDrawProceduralInclude, IncludeLocation.Postgraph);
break;
}
return fullscreenPass;
}
// We don't need the save context / update materials for now
public override object saveContext => null;
public FullscreenSubTarget()
{
displayName = "Fullscreen";
}
public override bool IsNodeAllowedBySubTarget(Type nodeType)
{
var interfaces = nodeType.GetInterfaces();
bool allowed = true;
// Subgraph nodes inherits all the interfaces including vertex ones.
if (nodeType == typeof(SubGraphNode))
return true;
// There is no input in the vertex block for now
if (interfaces.Contains(typeof(IMayRequireVertexID))
|| interfaces.Contains(typeof(IMayRequireVertexSkinning))
|| interfaces.Contains(typeof(IMayRequireInstanceID)))
allowed = false;
return allowed;
}
public override bool IsActive() => true;
public override void GetFields(ref TargetFieldContext context)
{
context.AddField(UnityEditor.ShaderGraph.Fields.GraphPixel);
context.AddField(FullscreenFields.depth, fullscreenData.depthWrite || fullscreenData.depthTestMode != CompareFunction.Disabled);
}
public override void GetActiveBlocks(ref TargetActiveBlockContext context)
{
context.AddBlock(BlockFields.SurfaceDescription.BaseColor);
context.AddBlock(BlockFields.SurfaceDescription.Alpha);
var depthBlock = FullscreenBlocks.eyeDepth;
if (fullscreenData.depthWriteMode == FullscreenDepthWriteMode.Linear01)
depthBlock = FullscreenBlocks.linear01Depth;
if (fullscreenData.depthWriteMode == FullscreenDepthWriteMode.Raw)
depthBlock = FullscreenBlocks.rawDepth;
context.AddBlock(depthBlock, fullscreenData.depthWrite || fullscreenData.depthTestMode != CompareFunction.Disabled);
}
public override void CollectShaderProperties(PropertyCollector collector, GenerationMode generationMode)
{
if (fullscreenData.allowMaterialOverride)
{
base.CollectShaderProperties(collector, generationMode);
CollectRenderStateShaderProperties(collector, generationMode);
}
collector.AddFloatProperty("_FlipY", 0, HLSLDeclaration.Global, false);
}
public void CollectRenderStateShaderProperties(PropertyCollector collector, GenerationMode generationMode)
{
if (generationMode != GenerationMode.Preview && fullscreenData.allowMaterialOverride)
{
// When blend mode is disabled, we can't override
if (fullscreenData.blendMode != FullscreenBlendMode.Disabled)
{
BlendMode srcColorBlend = fullscreenData.srcColorBlendMode;
BlendMode srcAlphaBlend = fullscreenData.srcAlphaBlendMode;
BlendMode dstColorBlend = fullscreenData.dstColorBlendMode;
BlendMode dstAlphaBlend = fullscreenData.dstAlphaBlendMode;
BlendOp colorBlendOp = fullscreenData.colorBlendOperation;
BlendOp alphaBlendOp = fullscreenData.alphaBlendOperation;
// Patch the default blend values depending on the Blend Mode:
if (fullscreenData.blendMode != FullscreenBlendMode.Custom)
{
colorBlendOp = BlendOp.Add;
alphaBlendOp = BlendOp.Add;
}
if (fullscreenData.blendMode == FullscreenBlendMode.Alpha)
{
srcColorBlend = BlendMode.SrcAlpha;
dstColorBlend = BlendMode.OneMinusSrcAlpha;
srcAlphaBlend = BlendMode.One;
dstAlphaBlend = BlendMode.OneMinusSrcAlpha;
}
else if (fullscreenData.blendMode == FullscreenBlendMode.Premultiply)
{
srcColorBlend = BlendMode.One;
dstColorBlend = BlendMode.OneMinusSrcAlpha;
srcAlphaBlend = BlendMode.One;
dstAlphaBlend = BlendMode.OneMinusSrcAlpha;
}
else if (fullscreenData.blendMode == FullscreenBlendMode.Additive)
{
srcColorBlend = BlendMode.SrcAlpha;
dstColorBlend = BlendMode.One;
srcAlphaBlend = BlendMode.One;
dstAlphaBlend = BlendMode.One;
}
else if (fullscreenData.blendMode == FullscreenBlendMode.Multiply)
{
srcColorBlend = BlendMode.DstColor;
dstColorBlend = BlendMode.Zero;
srcAlphaBlend = BlendMode.One;
dstAlphaBlend = BlendMode.OneMinusSrcAlpha;
}
collector.AddEnumProperty(FullscreenUniforms.blendModeProperty, fullscreenData.blendMode);
collector.AddEnumProperty(FullscreenUniforms.srcColorBlendProperty, srcColorBlend);
collector.AddEnumProperty(FullscreenUniforms.dstColorBlendProperty, dstColorBlend);
collector.AddEnumProperty(FullscreenUniforms.srcAlphaBlendProperty, srcAlphaBlend);
collector.AddEnumProperty(FullscreenUniforms.dstAlphaBlendProperty, dstAlphaBlend);
collector.AddEnumProperty(FullscreenUniforms.colorBlendOperationProperty, colorBlendOp);
collector.AddEnumProperty(FullscreenUniforms.alphaBlendOperationProperty, alphaBlendOp);
}
collector.AddBoolProperty(FullscreenUniforms.depthWriteProperty, fullscreenData.depthWrite);
if (fullscreenData.depthTestMode != CompareFunction.Disabled)
collector.AddEnumProperty(FullscreenUniforms.depthTestProperty, fullscreenData.depthTestMode);
// When stencil is disabled, we can't override
if (fullscreenData.enableStencil)
{
collector.AddBoolProperty(FullscreenUniforms.stencilEnableProperty, fullscreenData.enableStencil);
collector.AddIntProperty(FullscreenUniforms.stencilReferenceProperty, fullscreenData.stencilReference);
collector.AddIntProperty(FullscreenUniforms.stencilReadMaskProperty, fullscreenData.stencilReadMask);
collector.AddIntProperty(FullscreenUniforms.stencilWriteMaskProperty, fullscreenData.stencilWriteMask);
collector.AddEnumProperty(FullscreenUniforms.stencilComparisonProperty, fullscreenData.stencilCompareFunction);
collector.AddEnumProperty(FullscreenUniforms.stencilPassProperty, fullscreenData.stencilPassOperation);
collector.AddEnumProperty(FullscreenUniforms.stencilFailProperty, fullscreenData.stencilFailOperation);
collector.AddEnumProperty(FullscreenUniforms.stencilDepthFailProperty, fullscreenData.stencilDepthTestFailOperation);
}
}
}
public override void GetPropertiesGUI(ref TargetPropertyGUIContext context, Action onChange, Action<String> registerUndo)
{
context.AddProperty("Allow Material Override", new Toggle() { value = fullscreenData.allowMaterialOverride }, (evt) =>
{
if (Equals(fullscreenData.allowMaterialOverride, evt.newValue))
return;
registerUndo("Change Allow Material Override");
fullscreenData.allowMaterialOverride = evt.newValue;
onChange();
});
GetRenderStatePropertiesGUI(ref context, onChange, registerUndo);
}
protected virtual void GetRenderStatePropertiesGUI(ref TargetPropertyGUIContext context, Action onChange, Action<String> registerUndo)
{
GetBlendingPropertiesGUI(ref context, onChange, registerUndo);
context.AddProperty("Depth Test", new EnumField(fullscreenData.depthTestMode) { value = fullscreenData.depthTestMode }, (evt) =>
{
if (Equals(fullscreenData.depthTestMode, evt.newValue))
return;
registerUndo("Change Depth Test");
fullscreenData.depthTestMode = (CompareFunction)evt.newValue;
onChange();
});
context.AddProperty("Depth Write", new Toggle { value = fullscreenData.depthWrite }, (evt) =>
{
if (Equals(fullscreenData.depthWrite, evt.newValue))
return;
registerUndo("Change Depth Write");
fullscreenData.depthWrite = evt.newValue;
onChange();
});
if (fullscreenData.depthWrite || fullscreenData.depthTestMode != CompareFunction.Disabled)
{
context.AddProperty("Depth Write Mode", new EnumField(fullscreenData.depthWriteMode) { value = fullscreenData.depthWriteMode }, (evt) =>
{
if (Equals(fullscreenData.depthWriteMode, evt.newValue))
return;
registerUndo("Change Depth Write Mode");
fullscreenData.depthWriteMode = (FullscreenDepthWriteMode)evt.newValue;
onChange();
});
}
GetStencilPropertiesGUI(ref context, onChange, registerUndo);
}
protected virtual void GetBlendingPropertiesGUI(ref TargetPropertyGUIContext context, Action onChange, Action<String> registerUndo)
{
context.AddProperty("Blend Mode", new EnumField(fullscreenData.blendMode) { value = fullscreenData.blendMode }, (evt) =>
{
if (Equals(fullscreenData.blendMode, evt.newValue))
return;
registerUndo("Change Blend Mode");
fullscreenData.blendMode = (FullscreenBlendMode)evt.newValue;
onChange();
});
if (fullscreenData.blendMode == FullscreenBlendMode.Custom)
{
context.globalIndentLevel++;
context.AddLabel("Color Blend Mode", 0);
context.AddProperty("Src Color", new EnumField(fullscreenData.srcColorBlendMode) { value = fullscreenData.srcColorBlendMode }, (evt) =>
{
if (Equals(fullscreenData.srcColorBlendMode, evt.newValue))
return;
registerUndo("Change Blend Mode");
fullscreenData.srcColorBlendMode = (BlendMode)evt.newValue;
onChange();
});
context.AddProperty("Dst Color", new EnumField(fullscreenData.dstColorBlendMode) { value = fullscreenData.dstColorBlendMode }, (evt) =>
{
if (Equals(fullscreenData.dstColorBlendMode, evt.newValue))
return;
registerUndo("Change Blend Mode");
fullscreenData.dstColorBlendMode = (BlendMode)evt.newValue;
onChange();
});
context.AddProperty("Color Operation", new EnumField(fullscreenData.colorBlendOperation) { value = fullscreenData.colorBlendOperation }, (evt) =>
{
if (Equals(fullscreenData.colorBlendOperation, evt.newValue))
return;
registerUndo("Change Blend Mode");
fullscreenData.colorBlendOperation = (BlendOp)evt.newValue;
onChange();
});
context.AddLabel("Alpha Blend Mode", 0);
context.AddProperty("Src", new EnumField(fullscreenData.srcAlphaBlendMode) { value = fullscreenData.srcAlphaBlendMode }, (evt) =>
{
if (Equals(fullscreenData.srcAlphaBlendMode, evt.newValue))
return;
registerUndo("Change Blend Mode");
fullscreenData.srcAlphaBlendMode = (BlendMode)evt.newValue;
onChange();
});
context.AddProperty("Dst", new EnumField(fullscreenData.dstAlphaBlendMode) { value = fullscreenData.dstAlphaBlendMode }, (evt) =>
{
if (Equals(fullscreenData.dstAlphaBlendMode, evt.newValue))
return;
registerUndo("Change Blend Mode");
fullscreenData.dstAlphaBlendMode = (BlendMode)evt.newValue;
onChange();
});
context.AddProperty("Blend Operation Alpha", new EnumField(fullscreenData.alphaBlendOperation) { value = fullscreenData.alphaBlendOperation }, (evt) =>
{
if (Equals(fullscreenData.alphaBlendOperation, evt.newValue))
return;
registerUndo("Change Blend Mode");
fullscreenData.alphaBlendOperation = (BlendOp)evt.newValue;
onChange();
});
context.globalIndentLevel--;
}
}
protected virtual void GetStencilPropertiesGUI(ref TargetPropertyGUIContext context, Action onChange, Action<String> registerUndo)
{
context.AddProperty("Enable Stencil", new Toggle { value = fullscreenData.enableStencil }, (evt) =>
{
if (Equals(fullscreenData.enableStencil, evt.newValue))
return;
registerUndo("Change Enable Stencil");
fullscreenData.enableStencil = evt.newValue;
onChange();
});
if (fullscreenData.enableStencil)
{
context.globalIndentLevel++;
context.AddProperty("Reference", new IntegerField { value = fullscreenData.stencilReference, isDelayed = true }, (evt) =>
{
if (Equals(fullscreenData.stencilReference, evt.newValue))
return;
registerUndo("Change Stencil Reference");
fullscreenData.stencilReference = evt.newValue;
onChange();
});
context.AddProperty("Read Mask", new IntegerField { value = fullscreenData.stencilReadMask, isDelayed = true }, (evt) =>
{
if (Equals(fullscreenData.stencilReadMask, evt.newValue))
return;
registerUndo("Change Stencil Read Mask");
fullscreenData.stencilReadMask = evt.newValue;
onChange();
});
context.AddProperty("Write Mask", new IntegerField { value = fullscreenData.stencilWriteMask, isDelayed = true }, (evt) =>
{
if (Equals(fullscreenData.stencilWriteMask, evt.newValue))
return;
registerUndo("Change Stencil Write Mask");
fullscreenData.stencilWriteMask = evt.newValue;
onChange();
});
context.AddProperty("Comparison", new EnumField(fullscreenData.stencilCompareFunction) { value = fullscreenData.stencilCompareFunction }, (evt) =>
{
if (Equals(fullscreenData.stencilCompareFunction, evt.newValue))
return;
registerUndo("Change Stencil Comparison");
fullscreenData.stencilCompareFunction = (CompareFunction)evt.newValue;
onChange();
});
context.AddProperty("Pass", new EnumField(fullscreenData.stencilPassOperation) { value = fullscreenData.stencilPassOperation }, (evt) =>
{
if (Equals(fullscreenData.stencilPassOperation, evt.newValue))
return;
registerUndo("Change Stencil Pass Operation");
fullscreenData.stencilPassOperation = (StencilOp)evt.newValue;
onChange();
});
context.AddProperty("Fail", new EnumField(fullscreenData.stencilFailOperation) { value = fullscreenData.stencilFailOperation }, (evt) =>
{
if (Equals(fullscreenData.stencilFailOperation, evt.newValue))
return;
registerUndo("Change Stencil Fail Operation");
fullscreenData.stencilFailOperation = (StencilOp)evt.newValue;
onChange();
});
context.AddProperty("Depth Fail", new EnumField(fullscreenData.stencilDepthTestFailOperation) { value = fullscreenData.stencilDepthTestFailOperation }, (evt) =>
{
if (Equals(fullscreenData.stencilDepthTestFailOperation, evt.newValue))
return;
registerUndo("Change Stencil Depth Fail Operation");
fullscreenData.stencilDepthTestFailOperation = (StencilOp)evt.newValue;
onChange();
});
context.globalIndentLevel--;
}
}
}
internal static class FullscreenPropertyCollectorExtension
{
public static void AddEnumProperty<T>(this PropertyCollector collector, string prop, T value, HLSLDeclaration hlslDeclaration = HLSLDeclaration.DoNotDeclare) where T : Enum
{
collector.AddShaderProperty(new Vector1ShaderProperty
{
floatType = FloatType.Enum,
enumType = EnumType.CSharpEnum,
cSharpEnumType = typeof(T),
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = hlslDeclaration,
value = Convert.ToInt32(value),
overrideReferenceName = prop,
});
}
public static void AddIntProperty(this PropertyCollector collector, string prop, int value, HLSLDeclaration hlslDeclaration = HLSLDeclaration.DoNotDeclare)
{
collector.AddShaderProperty(new Vector1ShaderProperty
{
floatType = FloatType.Integer,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = hlslDeclaration,
value = value,
overrideReferenceName = prop,
});
}
public static void AddBoolProperty(this PropertyCollector collector, string prop, bool value, HLSLDeclaration hlslDeclaration = HLSLDeclaration.DoNotDeclare)
{
collector.AddShaderProperty(new BooleanShaderProperty
{
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = hlslDeclaration,
value = value,
overrideReferenceName = prop,
});
}
public static void AddFloatProperty(this PropertyCollector collector, string referenceName, float defaultValue, HLSLDeclaration declarationType = HLSLDeclaration.DoNotDeclare, bool generatePropertyBlock = true)
{
collector.AddShaderProperty(new Vector1ShaderProperty
{
floatType = FloatType.Default,
hidden = true,
overrideHLSLDeclaration = true,
hlslDeclarationOverride = declarationType,
value = defaultValue,
generatePropertyBlock = generatePropertyBlock,
overrideReferenceName = referenceName,
});
}
}
}