918 lines
33 KiB
C#
918 lines
33 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEngine;
|
|
using UnityEditor.Graphing;
|
|
using UnityEditor.ShaderGraph.Internal;
|
|
|
|
namespace UnityEditor.ShaderGraph
|
|
{
|
|
[HasDependencies(typeof(MinimalSubGraphNode))]
|
|
[Title("Utility", "Sub-graph")]
|
|
class SubGraphNode : AbstractMaterialNode
|
|
, IGeneratesBodyCode
|
|
, IOnAssetEnabled
|
|
, IGeneratesFunction
|
|
, IMayRequireNormal
|
|
, IMayRequireTangent
|
|
, IMayRequireBitangent
|
|
, IMayRequireMeshUV
|
|
, IMayRequireScreenPosition
|
|
, IMayRequireNDCPosition
|
|
, IMayRequirePixelPosition
|
|
, IMayRequireViewDirection
|
|
, IMayRequirePosition
|
|
, IMayRequirePositionPredisplacement
|
|
, IMayRequireVertexColor
|
|
, IMayRequireTime
|
|
, IMayRequireFaceSign
|
|
, IMayRequireCameraOpaqueTexture
|
|
, IMayRequireDepthTexture
|
|
, IMayRequireVertexSkinning
|
|
, IMayRequireVertexID
|
|
, IMayRequireInstanceID
|
|
, IDisposable
|
|
{
|
|
[Serializable]
|
|
public class MinimalSubGraphNode : IHasDependencies
|
|
{
|
|
[SerializeField]
|
|
string m_SerializedSubGraph = string.Empty;
|
|
|
|
public void GetSourceAssetDependencies(AssetCollection assetCollection)
|
|
{
|
|
var assetReference = JsonUtility.FromJson<SubGraphAssetReference>(m_SerializedSubGraph);
|
|
string guidString = assetReference?.subGraph?.guid;
|
|
if (!string.IsNullOrEmpty(guidString) && GUID.TryParse(guidString, out GUID guid))
|
|
{
|
|
// subgraphs are read as artifacts
|
|
// they also should be pulled into .unitypackages
|
|
assetCollection.AddAssetDependency(
|
|
guid,
|
|
AssetCollection.Flags.ArtifactDependency |
|
|
AssetCollection.Flags.IsSubGraph |
|
|
AssetCollection.Flags.IncludeInExportPackage);
|
|
}
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
class SubGraphHelper
|
|
{
|
|
public SubGraphAsset subGraph;
|
|
}
|
|
|
|
[Serializable]
|
|
class SubGraphAssetReference
|
|
{
|
|
public AssetReference subGraph = default;
|
|
|
|
public override string ToString()
|
|
{
|
|
return $"subGraph={subGraph}";
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
class AssetReference
|
|
{
|
|
public long fileID = default;
|
|
public string guid = default;
|
|
public int type = default;
|
|
|
|
public override string ToString()
|
|
{
|
|
return $"fileID={fileID}, guid={guid}, type={type}";
|
|
}
|
|
}
|
|
|
|
[SerializeField]
|
|
string m_SerializedSubGraph = string.Empty;
|
|
|
|
[NonSerialized]
|
|
SubGraphAsset m_SubGraph; // This should not be accessed directly by most code -- use the asset property instead, and check for NULL! :)
|
|
|
|
[SerializeField]
|
|
List<string> m_PropertyGuids = new List<string>();
|
|
|
|
[SerializeField]
|
|
List<int> m_PropertyIds = new List<int>();
|
|
|
|
[SerializeField]
|
|
List<string> m_Dropdowns = new List<string>();
|
|
|
|
[SerializeField]
|
|
List<string> m_DropdownSelectedEntries = new List<string>();
|
|
|
|
public string subGraphGuid
|
|
{
|
|
get
|
|
{
|
|
var assetReference = JsonUtility.FromJson<SubGraphAssetReference>(m_SerializedSubGraph);
|
|
return assetReference?.subGraph?.guid;
|
|
}
|
|
}
|
|
|
|
void LoadSubGraph()
|
|
{
|
|
if (m_SubGraph == null)
|
|
{
|
|
if (string.IsNullOrEmpty(m_SerializedSubGraph))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var graphGuid = subGraphGuid;
|
|
var assetPath = AssetDatabase.GUIDToAssetPath(graphGuid);
|
|
if (string.IsNullOrEmpty(assetPath))
|
|
{
|
|
// this happens if the editor has never seen the GUID
|
|
// error will be printed by validation code in this case
|
|
return;
|
|
}
|
|
m_SubGraph = AssetDatabase.LoadAssetAtPath<SubGraphAsset>(assetPath);
|
|
if (m_SubGraph == null)
|
|
{
|
|
// this happens if the editor has seen the GUID, but the file has been deleted since then
|
|
// error will be printed by validation code in this case
|
|
return;
|
|
}
|
|
m_SubGraph.LoadGraphData();
|
|
m_SubGraph.LoadDependencyData();
|
|
|
|
name = m_SubGraph.name;
|
|
}
|
|
}
|
|
|
|
public SubGraphAsset asset
|
|
{
|
|
get
|
|
{
|
|
LoadSubGraph();
|
|
return m_SubGraph;
|
|
}
|
|
set
|
|
{
|
|
if (asset == value)
|
|
return;
|
|
|
|
var helper = new SubGraphHelper();
|
|
helper.subGraph = value;
|
|
m_SerializedSubGraph = EditorJsonUtility.ToJson(helper, true);
|
|
m_SubGraph = null;
|
|
UpdateSlots();
|
|
|
|
Dirty(ModificationScope.Topological);
|
|
}
|
|
}
|
|
|
|
public override bool hasPreview
|
|
{
|
|
get { return true; }
|
|
}
|
|
|
|
public override PreviewMode previewMode
|
|
{
|
|
get
|
|
{
|
|
PreviewMode mode = m_PreviewMode;
|
|
if ((mode == PreviewMode.Inherit) && (asset != null))
|
|
mode = asset.previewMode;
|
|
return mode;
|
|
}
|
|
}
|
|
|
|
public SubGraphNode()
|
|
{
|
|
name = "Sub Graph";
|
|
}
|
|
|
|
public override bool allowedInSubGraph
|
|
{
|
|
get { return true; }
|
|
}
|
|
|
|
public override bool canSetPrecision
|
|
{
|
|
get { return asset?.subGraphGraphPrecision == GraphPrecision.Graph; }
|
|
}
|
|
|
|
public override void GetInputSlots<T>(MaterialSlot startingSlot, List<T> foundSlots)
|
|
{
|
|
var allSlots = new List<T>();
|
|
GetInputSlots<T>(allSlots);
|
|
var info = asset?.GetOutputDependencies(startingSlot.RawDisplayName());
|
|
if (info != null)
|
|
{
|
|
foreach (var slot in allSlots)
|
|
{
|
|
if (info.ContainsSlot(slot))
|
|
foundSlots.Add(slot);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void GetOutputSlots<T>(MaterialSlot startingSlot, List<T> foundSlots)
|
|
{
|
|
var allSlots = new List<T>();
|
|
GetOutputSlots<T>(allSlots);
|
|
var info = asset?.GetInputDependencies(startingSlot.RawDisplayName());
|
|
if (info != null)
|
|
{
|
|
foreach (var slot in allSlots)
|
|
{
|
|
if (info.ContainsSlot(slot))
|
|
foundSlots.Add(slot);
|
|
}
|
|
}
|
|
}
|
|
|
|
ShaderStageCapability GetSlotCapability(MaterialSlot slot)
|
|
{
|
|
SlotDependencyInfo dependencyInfo;
|
|
if (slot.isInputSlot)
|
|
dependencyInfo = asset?.GetInputDependencies(slot.RawDisplayName());
|
|
else
|
|
dependencyInfo = asset?.GetOutputDependencies(slot.RawDisplayName());
|
|
|
|
if (dependencyInfo != null)
|
|
return dependencyInfo.capabilities;
|
|
return ShaderStageCapability.All;
|
|
}
|
|
|
|
public void GenerateNodeCode(ShaderStringBuilder sb, GenerationMode generationMode)
|
|
{
|
|
var outputGraphPrecision = asset?.outputGraphPrecision ?? GraphPrecision.Single;
|
|
var outputPrecision = outputGraphPrecision.ToConcrete(concretePrecision);
|
|
|
|
if (asset == null || hasError)
|
|
{
|
|
var outputSlots = new List<MaterialSlot>();
|
|
GetOutputSlots(outputSlots);
|
|
|
|
foreach (var slot in outputSlots)
|
|
{
|
|
sb.AppendLine($"{slot.concreteValueType.ToShaderString(outputPrecision)} {GetVariableNameForSlot(slot.id)} = {slot.GetDefaultValue(GenerationMode.ForReals)};");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
var inputVariableName = $"_{GetVariableNameForNode()}";
|
|
|
|
GenerationUtils.GenerateSurfaceInputTransferCode(sb, asset.requirements, asset.inputStructName, inputVariableName);
|
|
|
|
// declare output variables
|
|
foreach (var outSlot in asset.outputs)
|
|
sb.AppendLine("{0} {1};", outSlot.concreteValueType.ToShaderString(outputPrecision), GetVariableNameForSlot(outSlot.id));
|
|
|
|
var arguments = new List<string>();
|
|
foreach (AbstractShaderProperty prop in asset.inputs)
|
|
{
|
|
// setup the property concrete precision (fallback to node concrete precision when it's switchable)
|
|
prop.SetupConcretePrecision(this.concretePrecision);
|
|
var inSlotId = m_PropertyIds[m_PropertyGuids.IndexOf(prop.guid.ToString())];
|
|
arguments.Add(GetSlotValue(inSlotId, generationMode, prop.concretePrecision));
|
|
|
|
if (prop.isConnectionTestable)
|
|
arguments.Add(IsSlotConnected(inSlotId) ? "true" : "false");
|
|
}
|
|
|
|
var dropdowns = asset.dropdowns;
|
|
foreach (var dropdown in dropdowns)
|
|
{
|
|
var name = GetDropdownEntryName(dropdown.referenceName);
|
|
if (dropdown.ContainsEntry(name))
|
|
arguments.Add(dropdown.IndexOfName(name).ToString());
|
|
else
|
|
arguments.Add(dropdown.value.ToString());
|
|
}
|
|
|
|
// pass surface inputs through
|
|
arguments.Add(inputVariableName);
|
|
|
|
foreach (var outSlot in asset.outputs)
|
|
arguments.Add(GetVariableNameForSlot(outSlot.id));
|
|
|
|
foreach (var feedbackSlot in asset.vtFeedbackVariables)
|
|
{
|
|
string feedbackVar = GetVariableNameForNode() + "_" + feedbackSlot;
|
|
sb.AppendLine("{0} {1};", ConcreteSlotValueType.Vector4.ToShaderString(ConcretePrecision.Single), feedbackVar);
|
|
arguments.Add(feedbackVar);
|
|
}
|
|
|
|
sb.TryAppendIndentation();
|
|
sb.Append(asset.functionName);
|
|
sb.Append("(");
|
|
bool firstArg = true;
|
|
foreach (var arg in arguments)
|
|
{
|
|
if (!firstArg)
|
|
sb.Append(", ");
|
|
firstArg = false;
|
|
sb.Append(arg);
|
|
}
|
|
sb.Append(");");
|
|
sb.AppendNewLine();
|
|
}
|
|
|
|
public void OnEnable()
|
|
{
|
|
UpdateSlots();
|
|
}
|
|
|
|
public bool Reload(HashSet<string> changedFileDependencyGUIDs)
|
|
{
|
|
if (!changedFileDependencyGUIDs.Contains(subGraphGuid))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (asset == null)
|
|
{
|
|
// asset missing or deleted
|
|
return true;
|
|
}
|
|
|
|
if (changedFileDependencyGUIDs.Contains(asset.assetGuid) || asset.descendents.Any(changedFileDependencyGUIDs.Contains))
|
|
{
|
|
m_SubGraph = null;
|
|
UpdateSlots();
|
|
|
|
if (hasError)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
owner.ClearErrorsForNode(this);
|
|
ValidateNode();
|
|
Dirty(ModificationScope.Graph);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public override void UpdatePrecision(List<MaterialSlot> inputSlots)
|
|
{
|
|
if (asset != null)
|
|
{
|
|
if (asset.subGraphGraphPrecision == GraphPrecision.Graph)
|
|
{
|
|
// subgraph is defined to be switchable, so use the default behavior to determine precision
|
|
base.UpdatePrecision(inputSlots);
|
|
}
|
|
else
|
|
{
|
|
// subgraph sets a specific precision, force that
|
|
graphPrecision = asset.subGraphGraphPrecision;
|
|
concretePrecision = graphPrecision.ToConcrete(owner.graphDefaultConcretePrecision);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// no subgraph asset; use default behavior
|
|
base.UpdatePrecision(inputSlots);
|
|
}
|
|
}
|
|
|
|
public virtual void UpdateSlots()
|
|
{
|
|
var validNames = new List<int>();
|
|
if (asset == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var props = asset.inputs;
|
|
var toFix = new HashSet<(SlotReference from, SlotReference to)>();
|
|
foreach (var prop in props)
|
|
{
|
|
SlotValueType valueType = prop.concreteShaderValueType.ToSlotValueType();
|
|
var propertyString = prop.guid.ToString();
|
|
var propertyIndex = m_PropertyGuids.IndexOf(propertyString);
|
|
if (propertyIndex < 0)
|
|
{
|
|
propertyIndex = m_PropertyGuids.Count;
|
|
m_PropertyGuids.Add(propertyString);
|
|
m_PropertyIds.Add(prop.guid.GetHashCode());
|
|
}
|
|
var id = m_PropertyIds[propertyIndex];
|
|
|
|
//for whatever reason, it seems like shader property ids changed between 21.2a17 and 21.2b1
|
|
//tried tracking it down, couldnt find any reason for it, so we gotta fix it in post (after we deserialize)
|
|
List<MaterialSlot> inputs = new List<MaterialSlot>();
|
|
MaterialSlot found = null;
|
|
GetInputSlots(inputs);
|
|
foreach (var input in inputs)
|
|
{
|
|
if (input.shaderOutputName == prop.referenceName && input.id != id)
|
|
{
|
|
found = input;
|
|
break;
|
|
}
|
|
}
|
|
|
|
MaterialSlot slot = MaterialSlot.CreateMaterialSlot(valueType, id, prop.displayName, prop.referenceName, SlotType.Input, Vector4.zero, ShaderStageCapability.All);
|
|
|
|
// Copy defaults
|
|
switch (prop.concreteShaderValueType)
|
|
{
|
|
case ConcreteSlotValueType.SamplerState:
|
|
{
|
|
var tSlot = slot as SamplerStateMaterialSlot;
|
|
var tProp = prop as SamplerStateShaderProperty;
|
|
if (tSlot != null && tProp != null)
|
|
tSlot.defaultSamplerState = tProp.value;
|
|
}
|
|
break;
|
|
case ConcreteSlotValueType.Matrix4:
|
|
{
|
|
var tSlot = slot as Matrix4MaterialSlot;
|
|
var tProp = prop as Matrix4ShaderProperty;
|
|
if (tSlot != null && tProp != null)
|
|
tSlot.value = tProp.value;
|
|
}
|
|
break;
|
|
case ConcreteSlotValueType.Matrix3:
|
|
{
|
|
var tSlot = slot as Matrix3MaterialSlot;
|
|
var tProp = prop as Matrix3ShaderProperty;
|
|
if (tSlot != null && tProp != null)
|
|
tSlot.value = tProp.value;
|
|
}
|
|
break;
|
|
case ConcreteSlotValueType.Matrix2:
|
|
{
|
|
var tSlot = slot as Matrix2MaterialSlot;
|
|
var tProp = prop as Matrix2ShaderProperty;
|
|
if (tSlot != null && tProp != null)
|
|
tSlot.value = tProp.value;
|
|
}
|
|
break;
|
|
case ConcreteSlotValueType.Texture2D:
|
|
{
|
|
var tSlot = slot as Texture2DInputMaterialSlot;
|
|
var tProp = prop as Texture2DShaderProperty;
|
|
if (tSlot != null && tProp != null)
|
|
|
|
tSlot.texture = tProp.value.texture;
|
|
}
|
|
break;
|
|
case ConcreteSlotValueType.Texture2DArray:
|
|
{
|
|
var tSlot = slot as Texture2DArrayInputMaterialSlot;
|
|
var tProp = prop as Texture2DArrayShaderProperty;
|
|
if (tSlot != null && tProp != null)
|
|
tSlot.textureArray = tProp.value.textureArray;
|
|
}
|
|
break;
|
|
case ConcreteSlotValueType.Texture3D:
|
|
{
|
|
var tSlot = slot as Texture3DInputMaterialSlot;
|
|
var tProp = prop as Texture3DShaderProperty;
|
|
if (tSlot != null && tProp != null)
|
|
tSlot.texture = tProp.value.texture;
|
|
}
|
|
break;
|
|
case ConcreteSlotValueType.Cubemap:
|
|
{
|
|
var tSlot = slot as CubemapInputMaterialSlot;
|
|
var tProp = prop as CubemapShaderProperty;
|
|
if (tSlot != null && tProp != null)
|
|
tSlot.cubemap = tProp.value.cubemap;
|
|
}
|
|
break;
|
|
case ConcreteSlotValueType.Gradient:
|
|
{
|
|
var tSlot = slot as GradientInputMaterialSlot;
|
|
var tProp = prop as GradientShaderProperty;
|
|
if (tSlot != null && tProp != null)
|
|
tSlot.value = tProp.value;
|
|
}
|
|
break;
|
|
case ConcreteSlotValueType.Vector4:
|
|
{
|
|
var tSlot = slot as Vector4MaterialSlot;
|
|
var vector4Prop = prop as Vector4ShaderProperty;
|
|
var colorProp = prop as ColorShaderProperty;
|
|
if (tSlot != null && vector4Prop != null)
|
|
tSlot.value = vector4Prop.value;
|
|
else if (tSlot != null && colorProp != null)
|
|
tSlot.value = colorProp.value;
|
|
}
|
|
break;
|
|
case ConcreteSlotValueType.Vector3:
|
|
{
|
|
var tSlot = slot as Vector3MaterialSlot;
|
|
var tProp = prop as Vector3ShaderProperty;
|
|
if (tSlot != null && tProp != null)
|
|
tSlot.value = tProp.value;
|
|
}
|
|
break;
|
|
case ConcreteSlotValueType.Vector2:
|
|
{
|
|
var tSlot = slot as Vector2MaterialSlot;
|
|
var tProp = prop as Vector2ShaderProperty;
|
|
if (tSlot != null && tProp != null)
|
|
tSlot.value = tProp.value;
|
|
}
|
|
break;
|
|
case ConcreteSlotValueType.Vector1:
|
|
{
|
|
var tSlot = slot as Vector1MaterialSlot;
|
|
var tProp = prop as Vector1ShaderProperty;
|
|
if (tSlot != null && tProp != null)
|
|
tSlot.value = tProp.value;
|
|
}
|
|
break;
|
|
case ConcreteSlotValueType.Boolean:
|
|
{
|
|
var tSlot = slot as BooleanMaterialSlot;
|
|
var tProp = prop as BooleanShaderProperty;
|
|
if (tSlot != null && tProp != null)
|
|
tSlot.value = tProp.value;
|
|
}
|
|
break;
|
|
}
|
|
|
|
AddSlot(slot);
|
|
validNames.Add(id);
|
|
|
|
if (found != null)
|
|
{
|
|
List<IEdge> edges = new List<IEdge>();
|
|
owner.GetEdges(found.slotReference, edges);
|
|
foreach (var edge in edges)
|
|
{
|
|
toFix.Add((edge.outputSlot, slot.slotReference));
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (var slot in asset.outputs)
|
|
{
|
|
var outputStage = GetSlotCapability(slot);
|
|
var newSlot = MaterialSlot.CreateMaterialSlot(slot.valueType, slot.id, slot.RawDisplayName(),
|
|
slot.shaderOutputName, SlotType.Output, Vector4.zero, outputStage, slot.hidden);
|
|
AddSlot(newSlot);
|
|
validNames.Add(slot.id);
|
|
}
|
|
|
|
RemoveSlotsNameNotMatching(validNames, true);
|
|
|
|
// sort slot order to match subgraph property order
|
|
SetSlotOrder(validNames);
|
|
|
|
foreach (var (from, to) in toFix)
|
|
{
|
|
//for whatever reason, in this particular error fix, GraphView will incorrectly either add two edgeViews or none
|
|
//but it does work correctly if we dont notify GraphView of this added edge. Gross.
|
|
owner.UnnotifyAddedEdge(owner.Connect(from, to));
|
|
}
|
|
}
|
|
|
|
void ValidateShaderStage()
|
|
{
|
|
if (asset != null)
|
|
{
|
|
List<MaterialSlot> slots = new List<MaterialSlot>();
|
|
GetInputSlots(slots);
|
|
GetOutputSlots(slots);
|
|
|
|
foreach (MaterialSlot slot in slots)
|
|
slot.stageCapability = GetSlotCapability(slot);
|
|
}
|
|
}
|
|
|
|
public override void ValidateNode()
|
|
{
|
|
base.ValidateNode();
|
|
|
|
if (asset == null)
|
|
{
|
|
hasError = true;
|
|
var assetGuid = subGraphGuid;
|
|
var assetPath = string.IsNullOrEmpty(subGraphGuid) ? null : AssetDatabase.GUIDToAssetPath(assetGuid);
|
|
if (string.IsNullOrEmpty(assetPath))
|
|
{
|
|
owner.AddValidationError(objectId, $"Could not find Sub Graph asset with GUID {assetGuid}.");
|
|
}
|
|
else
|
|
{
|
|
owner.AddValidationError(objectId, $"Could not load Sub Graph asset at \"{assetPath}\" with GUID {assetGuid}.");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (owner.isSubGraph && (asset.descendents.Contains(owner.assetGuid) || asset.assetGuid == owner.assetGuid))
|
|
{
|
|
hasError = true;
|
|
owner.AddValidationError(objectId, $"Detected a recursion in Sub Graph asset at \"{AssetDatabase.GUIDToAssetPath(subGraphGuid)}\" with GUID {subGraphGuid}.");
|
|
}
|
|
else if (!asset.isValid)
|
|
{
|
|
hasError = true;
|
|
owner.AddValidationError(objectId, $"Sub Graph has errors, asset at \"{AssetDatabase.GUIDToAssetPath(subGraphGuid)}\" with GUID {subGraphGuid}.");
|
|
}
|
|
else if (!owner.isSubGraph && owner.activeTargets.Any(x => asset.unsupportedTargets.Contains(x)))
|
|
{
|
|
SetOverrideActiveState(ActiveState.ExplicitInactive);
|
|
owner.AddValidationError(objectId, $"Sub Graph contains nodes that are unsupported by the current active targets, asset at \"{AssetDatabase.GUIDToAssetPath(subGraphGuid)}\" with GUID {subGraphGuid}.");
|
|
}
|
|
|
|
// detect disconnected VT properties, and VT layer count mismatches
|
|
foreach (var paramProp in asset.inputs)
|
|
{
|
|
if (paramProp is VirtualTextureShaderProperty vtProp)
|
|
{
|
|
int paramLayerCount = vtProp.value.layers.Count;
|
|
|
|
var argSlotId = m_PropertyIds[m_PropertyGuids.IndexOf(paramProp.guid.ToString())]; // yikes
|
|
if (!IsSlotConnected(argSlotId))
|
|
{
|
|
owner.AddValidationError(objectId, $"A VirtualTexture property must be connected to the input slot \"{paramProp.displayName}\"");
|
|
}
|
|
else
|
|
{
|
|
var argProp = GetSlotProperty(argSlotId) as VirtualTextureShaderProperty;
|
|
if (argProp != null)
|
|
{
|
|
int argLayerCount = argProp.value.layers.Count;
|
|
|
|
if (argLayerCount != paramLayerCount)
|
|
owner.AddValidationError(objectId, $"Input \"{paramProp.displayName}\" has different number of layers from the connected property \"{argProp.displayName}\"");
|
|
}
|
|
else
|
|
{
|
|
owner.AddValidationError(objectId, $"Input \"{paramProp.displayName}\" is not connected to a valid VirtualTexture property");
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
ValidateShaderStage();
|
|
}
|
|
|
|
public override void CollectShaderProperties(PropertyCollector visitor, GenerationMode generationMode)
|
|
{
|
|
base.CollectShaderProperties(visitor, generationMode);
|
|
|
|
if (asset == null)
|
|
return;
|
|
|
|
foreach (var property in asset.nodeProperties)
|
|
{
|
|
visitor.AddShaderProperty(property);
|
|
}
|
|
}
|
|
|
|
public AbstractShaderProperty GetShaderProperty(int id)
|
|
{
|
|
var index = m_PropertyIds.IndexOf(id);
|
|
if (index >= 0)
|
|
{
|
|
var guid = m_PropertyGuids[index];
|
|
return asset?.inputs.Where(x => x.guid.ToString().Equals(guid)).FirstOrDefault();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void CollectShaderKeywords(KeywordCollector keywords, GenerationMode generationMode)
|
|
{
|
|
if (asset == null)
|
|
return;
|
|
|
|
foreach (var keyword in asset.keywords)
|
|
{
|
|
keywords.AddShaderKeyword(keyword as ShaderKeyword);
|
|
}
|
|
}
|
|
|
|
public override void CollectPreviewMaterialProperties(List<PreviewProperty> properties)
|
|
{
|
|
base.CollectPreviewMaterialProperties(properties);
|
|
|
|
if (asset == null)
|
|
return;
|
|
|
|
foreach (var property in asset.nodeProperties)
|
|
{
|
|
properties.Add(property.GetPreviewMaterialProperty());
|
|
}
|
|
}
|
|
|
|
public virtual void GenerateNodeFunction(FunctionRegistry registry, GenerationMode generationMode)
|
|
{
|
|
if (asset == null || hasError)
|
|
return;
|
|
|
|
registry.RequiresIncludes(asset.includes);
|
|
|
|
var graphData = registry.builder.currentNode.owner;
|
|
var graphDefaultConcretePrecision = graphData.graphDefaultConcretePrecision;
|
|
|
|
foreach (var function in asset.functions)
|
|
{
|
|
var name = function.key;
|
|
var source = function.value;
|
|
var graphPrecisionFlags = function.graphPrecisionFlags;
|
|
|
|
// the subgraph may use multiple precision variants of this function internally
|
|
// here we iterate through all the requested precisions and forward those requests out to the graph
|
|
for (int requestedGraphPrecision = 0; requestedGraphPrecision <= (int)GraphPrecision.Half; requestedGraphPrecision++)
|
|
{
|
|
// only provide requested precisions
|
|
if ((graphPrecisionFlags & (1 << requestedGraphPrecision)) != 0)
|
|
{
|
|
// when a function coming from a subgraph asset has a graph precision of "Graph",
|
|
// that means it is up to the subgraph NODE to decide (i.e. us!)
|
|
GraphPrecision actualGraphPrecision = (GraphPrecision)requestedGraphPrecision;
|
|
|
|
// subgraph asset setting falls back to this node setting (when switchable)
|
|
actualGraphPrecision = actualGraphPrecision.GraphFallback(this.graphPrecision);
|
|
|
|
// which falls back to the graph default concrete precision
|
|
ConcretePrecision actualConcretePrecision = actualGraphPrecision.ToConcrete(graphDefaultConcretePrecision);
|
|
|
|
// forward the function into the current graph
|
|
registry.ProvideFunction(name, actualGraphPrecision, actualConcretePrecision, sb => sb.AppendLines(source));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public NeededCoordinateSpace RequiresNormal(ShaderStageCapability stageCapability)
|
|
{
|
|
if (asset == null)
|
|
return NeededCoordinateSpace.None;
|
|
|
|
return asset.requirements.requiresNormal;
|
|
}
|
|
|
|
public bool RequiresMeshUV(UVChannel channel, ShaderStageCapability stageCapability)
|
|
{
|
|
if (asset == null)
|
|
return false;
|
|
|
|
return asset.requirements.requiresMeshUVs.Contains(channel);
|
|
}
|
|
|
|
public bool RequiresScreenPosition(ShaderStageCapability stageCapability)
|
|
{
|
|
if (asset == null)
|
|
return false;
|
|
|
|
return asset.requirements.requiresScreenPosition;
|
|
}
|
|
|
|
public bool RequiresNDCPosition(ShaderStageCapability stageCapability)
|
|
{
|
|
if (asset == null)
|
|
return false;
|
|
|
|
return asset.requirements.requiresNDCPosition;
|
|
}
|
|
|
|
public bool RequiresPixelPosition(ShaderStageCapability stageCapability)
|
|
{
|
|
if (asset == null)
|
|
return false;
|
|
|
|
return asset.requirements.requiresPixelPosition;
|
|
}
|
|
|
|
public NeededCoordinateSpace RequiresViewDirection(ShaderStageCapability stageCapability)
|
|
{
|
|
if (asset == null)
|
|
return NeededCoordinateSpace.None;
|
|
|
|
return asset.requirements.requiresViewDir;
|
|
}
|
|
|
|
public NeededCoordinateSpace RequiresPosition(ShaderStageCapability stageCapability)
|
|
{
|
|
if (asset == null)
|
|
return NeededCoordinateSpace.None;
|
|
|
|
return asset.requirements.requiresPosition;
|
|
}
|
|
|
|
public NeededCoordinateSpace RequiresPositionPredisplacement(ShaderStageCapability stageCapability = ShaderStageCapability.All)
|
|
{
|
|
if (asset == null)
|
|
return NeededCoordinateSpace.None;
|
|
|
|
return asset.requirements.requiresPositionPredisplacement;
|
|
}
|
|
|
|
public NeededCoordinateSpace RequiresTangent(ShaderStageCapability stageCapability)
|
|
{
|
|
if (asset == null)
|
|
return NeededCoordinateSpace.None;
|
|
|
|
return asset.requirements.requiresTangent;
|
|
}
|
|
|
|
public bool RequiresTime()
|
|
{
|
|
if (asset == null)
|
|
return false;
|
|
|
|
return asset.requirements.requiresTime;
|
|
}
|
|
|
|
public bool RequiresFaceSign(ShaderStageCapability stageCapability)
|
|
{
|
|
if (asset == null)
|
|
return false;
|
|
|
|
return asset.requirements.requiresFaceSign;
|
|
}
|
|
|
|
public NeededCoordinateSpace RequiresBitangent(ShaderStageCapability stageCapability)
|
|
{
|
|
if (asset == null)
|
|
return NeededCoordinateSpace.None;
|
|
|
|
return asset.requirements.requiresBitangent;
|
|
}
|
|
|
|
public bool RequiresVertexColor(ShaderStageCapability stageCapability)
|
|
{
|
|
if (asset == null)
|
|
return false;
|
|
|
|
return asset.requirements.requiresVertexColor;
|
|
}
|
|
|
|
public bool RequiresCameraOpaqueTexture(ShaderStageCapability stageCapability)
|
|
{
|
|
if (asset == null)
|
|
return false;
|
|
|
|
return asset.requirements.requiresCameraOpaqueTexture;
|
|
}
|
|
|
|
public bool RequiresDepthTexture(ShaderStageCapability stageCapability)
|
|
{
|
|
if (asset == null)
|
|
return false;
|
|
|
|
return asset.requirements.requiresDepthTexture;
|
|
}
|
|
|
|
public bool RequiresVertexSkinning(ShaderStageCapability stageCapability)
|
|
{
|
|
if (asset == null)
|
|
return false;
|
|
|
|
return asset.requirements.requiresVertexSkinning;
|
|
}
|
|
|
|
public bool RequiresVertexID(ShaderStageCapability stageCapability)
|
|
{
|
|
if (asset == null)
|
|
return false;
|
|
|
|
return asset.requirements.requiresVertexID;
|
|
}
|
|
|
|
public bool RequiresInstanceID(ShaderStageCapability stageCapability)
|
|
{
|
|
if (asset == null)
|
|
return false;
|
|
|
|
return asset.requirements.requiresInstanceID;
|
|
}
|
|
|
|
public string GetDropdownEntryName(string referenceName)
|
|
{
|
|
var index = m_Dropdowns.IndexOf(referenceName);
|
|
return index >= 0 ? m_DropdownSelectedEntries[index] : string.Empty;
|
|
}
|
|
|
|
public void SetDropdownEntryName(string referenceName, string value)
|
|
{
|
|
var index = m_Dropdowns.IndexOf(referenceName);
|
|
if (index >= 0)
|
|
{
|
|
m_DropdownSelectedEntries[index] = value;
|
|
}
|
|
else
|
|
{
|
|
m_Dropdowns.Add(referenceName);
|
|
m_DropdownSelectedEntries.Add(value);
|
|
}
|
|
}
|
|
|
|
public override void Dispose()
|
|
{
|
|
base.Dispose();
|
|
m_SubGraph = null;
|
|
}
|
|
}
|
|
}
|