void UpdateOutputs(WirePortDataType newType)
{
//this only happens when on initial load
if (newType == WirePortDataType.OBJECT)
{
return;
}
m_currentType = newType;
switch (newType)
{
case WirePortDataType.OBJECT:
{
m_outputPorts[0].ChangeProperties(Constants.EmptyPortValue, WirePortDataType.OBJECT, false);
m_outputPorts[0].Visible = true;
for (int i = 1; i < m_outputPorts.Count; i++)
{
m_outputPorts[i].Visible = false;
}
}
break;
case WirePortDataType.FLOAT:
{
m_outputPorts[0].ChangeProperties(Constants.EmptyPortValue, WirePortDataType.FLOAT, false);
m_outputPorts[0].Visible = true;
for (int i = 1; i < m_outputPorts.Count; i++)
{
m_outputPorts[i].Visible = false;
}
}
break;
case WirePortDataType.FLOAT2:
{
for (int i = 0; i < 2; i++)
{
m_outputPorts[i].ChangeProperties(VectorPortNames[i], WirePortDataType.FLOAT, false);
m_outputPorts[i].Visible = true;
}
for (int i = 2; i < m_outputPorts.Count; i++)
{
m_outputPorts[i].Visible = false;
}
}
break;
case WirePortDataType.FLOAT3:
{
for (int i = 0; i < 3; i++)
{
m_outputPorts[i].ChangeProperties(VectorPortNames[i], WirePortDataType.FLOAT, false);
m_outputPorts[i].Visible = true;
}
for (int i = 3; i < m_outputPorts.Count; i++)
{
m_outputPorts[i].Visible = false;
}
}
break;
case WirePortDataType.FLOAT4:
{
for (int i = 0; i < 4; i++)
{
m_outputPorts[i].ChangeProperties(VectorPortNames[i], WirePortDataType.FLOAT, false);
m_outputPorts[i].Visible = true;
}
for (int i = 4; i < m_outputPorts.Count; i++)
{
m_outputPorts[i].Visible = false;
}
}
break;
case WirePortDataType.FLOAT3x3:
{
for (int i = 0; i < 9; i++)
{
m_outputPorts[i].ChangeProperties("[" + ( int )(i / 3) + "][" + i % 3 + "]", WirePortDataType.FLOAT, false);
m_outputPorts[i].Visible = true;
}
for (int i = 9; i < m_outputPorts.Count; i++)
{
m_outputPorts[i].Visible = false;
}
}
break;
case WirePortDataType.FLOAT4x4:
{
for (int i = 0; i < 16; i++)
{
m_outputPorts[i].ChangeProperties("[" + ( int )(i / 4) + "][" + i % 4 + "]", WirePortDataType.FLOAT, false);
m_outputPorts[i].Visible = true;
}
}
break;
case WirePortDataType.COLOR:
{
for (int i = 0; i < 4; i++)
{
m_outputPorts[i].ChangeProperties(ColorPortNames[i], WirePortDataType.FLOAT, false);
m_outputPorts[i].Visible = true;
}
for (int i = 4; i < m_outputPorts.Count; i++)
{
m_outputPorts[i].Visible = false;
}
}
break;
case WirePortDataType.INT:
{
m_outputPorts[0].Visible = true;
m_outputPorts[0].ChangeProperties(Constants.EmptyPortValue, WirePortDataType.INT, false);
for (int i = 1; i < m_outputPorts.Count; i++)
{
m_outputPorts[i].Visible = false;
}
}
break;
}
m_sizeIsDirty = true;
}
public static bool CheckIfCompatibles(WirePortDataType first, WirePortDataType second)
{
switch (first)
{
case WirePortDataType.OBJECT:
return(true);
case WirePortDataType.FLOAT:
case WirePortDataType.FLOAT2:
case WirePortDataType.FLOAT3:
case WirePortDataType.FLOAT4:
case WirePortDataType.COLOR:
case WirePortDataType.INT:
{
switch (second)
{
case WirePortDataType.FLOAT3x3:
case WirePortDataType.FLOAT4x4:
case WirePortDataType.SAMPLER1D:
case WirePortDataType.SAMPLER2D:
case WirePortDataType.SAMPLER3D:
case WirePortDataType.SAMPLERCUBE:
return(false);
}
}
break;
case WirePortDataType.FLOAT3x3:
case WirePortDataType.FLOAT4x4:
{
switch (second)
{
case WirePortDataType.FLOAT:
case WirePortDataType.FLOAT2:
case WirePortDataType.FLOAT3:
case WirePortDataType.FLOAT4:
case WirePortDataType.COLOR:
case WirePortDataType.INT:
case WirePortDataType.SAMPLER1D:
case WirePortDataType.SAMPLER2D:
case WirePortDataType.SAMPLER3D:
case WirePortDataType.SAMPLERCUBE:
return(false);
}
}
break;
case WirePortDataType.SAMPLER1D:
case WirePortDataType.SAMPLER2D:
case WirePortDataType.SAMPLER3D:
case WirePortDataType.SAMPLERCUBE:
{
switch (second)
{
case WirePortDataType.FLOAT:
case WirePortDataType.FLOAT2:
case WirePortDataType.FLOAT3:
case WirePortDataType.FLOAT4:
case WirePortDataType.FLOAT3x3:
case WirePortDataType.FLOAT4x4:
case WirePortDataType.COLOR:
case WirePortDataType.INT:
return(false);
}
}
break;
}
return(true);
}
public override void OnConnectedOutputNodeChanges(int outputPortId, int otherNodeId, int otherPortId, string name, WirePortDataType type)
{
base.OnConnectedOutputNodeChanges(outputPortId, otherNodeId, otherPortId, name, type);
m_inputPorts[0].MatchPortToConnection();
m_outputPorts[0].ChangeType(m_inputPorts[0].DataType, false);
}
// AUTOMATIC UVS
static public string GenerateAutoUVs(ref MasterNodeDataCollector dataCollector, int uniqueId, int index, string propertyName = null, WirePortDataType size = WirePortDataType.FLOAT2, string scale = null, string offset = null, string outputId = null)
{
string result = string.Empty;
string varName = string.Empty;
string indexStr = index > 0 ? (index + 1).ToString() : "";
if (dataCollector.PortCategory == MasterNodePortCategory.Fragment || dataCollector.PortCategory == MasterNodePortCategory.Debug)
{
string sizeDif = string.Empty;
if (size == WirePortDataType.FLOAT3)
{
sizeDif = "3";
}
else if (size == WirePortDataType.FLOAT4)
{
sizeDif = "4";
}
string dummyPropUV = "_tex" + sizeDif + "coord" + indexStr;
string dummyUV = "uv" + indexStr + dummyPropUV;
dataCollector.AddToProperties(uniqueId, "[HideInInspector] " + dummyPropUV + "( \"\", 2D ) = \"white\" {}", 100);
dataCollector.AddToInput(uniqueId, dummyUV, size);
result = Constants.InputVarStr + "." + dummyUV;
}
else
{
result = Constants.VertexShaderInputStr + ".texcoord";
if (index > 0)
{
result += index.ToString();
}
switch (size)
{
default:
case WirePortDataType.FLOAT2:
{
result += ".xy";
}
break;
case WirePortDataType.FLOAT3:
{
result += ".xyz";
}
break;
case WirePortDataType.FLOAT4: break;
}
}
varName = "uv" + indexStr + "_TexCoord" + outputId;
if (!string.IsNullOrEmpty(propertyName))
{
dataCollector.AddToUniforms(uniqueId, "uniform float4 " + propertyName + "_ST;");
if (size > WirePortDataType.FLOAT2)
{
dataCollector.UsingHigherSizeTexcoords = true;
dataCollector.AddToLocalVariables(dataCollector.PortCategory, uniqueId, PrecisionType.Float, size, "uv" + propertyName, result);
dataCollector.AddToLocalVariables(dataCollector.PortCategory, uniqueId, "uv" + propertyName + ".xy = " + result + ".xy * " + propertyName + "_ST.xy + " + propertyName + "_ST.zw;");
}
else
{
dataCollector.AddToLocalVariables(dataCollector.PortCategory, uniqueId, PrecisionType.Float, size, "uv" + propertyName, result + " * " + propertyName + "_ST.xy + " + propertyName + "_ST.zw");
}
result = "uv" + propertyName;
}
else if (!string.IsNullOrEmpty(scale) || !string.IsNullOrEmpty(offset))
{
if (size > WirePortDataType.FLOAT2)
{
dataCollector.UsingHigherSizeTexcoords = true;
dataCollector.AddToLocalVariables(dataCollector.PortCategory, uniqueId, PrecisionType.Float, size, varName, result);
dataCollector.AddToLocalVariables(dataCollector.PortCategory, uniqueId, varName + ".xy = " + result + ".xy" + (string.IsNullOrEmpty(scale) ? "" : " * " + scale) + (string.IsNullOrEmpty(offset) ? "" : " + " + offset) + ";");
}
else
{
dataCollector.AddToLocalVariables(dataCollector.PortCategory, uniqueId, PrecisionType.Float, size, varName, result + (string.IsNullOrEmpty(scale) ? "" : " * " + scale) + (string.IsNullOrEmpty(offset) ? "" : " + " + offset));
}
result = varName;
}
else if (dataCollector.PortCategory == MasterNodePortCategory.Fragment)
{
if (size > WirePortDataType.FLOAT2)
{
dataCollector.UsingHigherSizeTexcoords = true;
}
}
return(result);
}
public static TemplateInterpData CreateInterpDataList(string interpData, string fullLine)
{
TemplateInterpData interpDataObj = null;
List <TemplateVertexData> interpDataList = null;
Dictionary <TemplateSemantics, TemplateVertexData> interpDataDict = null;
Match rangeMatch = Regex.Match(fullLine, InterpRangePattern);
if (rangeMatch.Groups.Count > 0)
{
interpDataObj = new TemplateInterpData();
// Get range of available interpolators
int minVal = 0;
int maxVal = 0;
try
{
string[] minValArgs = rangeMatch.Groups[1].Value.Split(IOUtils.FLOAT_SEPARATOR);
minVal = Convert.ToInt32(minValArgs[0]);
maxVal = Convert.ToInt32(rangeMatch.Groups[2].Value);
if (minVal > maxVal)
{
int aux = minVal;
minVal = maxVal;
maxVal = aux;
}
for (int i = minVal; i <= maxVal; i++)
{
interpDataObj.AvailableInterpolators.Add(new TemplateInterpElement(IntToSemantic[i]));
}
if (minValArgs.Length > 1)
{
interpDataObj.AvailableInterpolators[0].SetAvailableChannelsFromString(minValArgs[1]);
}
}
catch (Exception e)
{
Debug.LogException(e);
}
//Get Current interpolators
int parametersBeginIdx = fullLine.IndexOf(":") + 1;
int parametersEnd = fullLine.IndexOf(TemplatesManager.TemplateEndOfLine);
string parametersBody = fullLine.Substring(parametersBeginIdx, parametersEnd - parametersBeginIdx);
foreach (Match match in Regex.Matches(interpData, VertexDataPattern))
{
if (match.Groups.Count > 1)
{
if (interpDataList == null)
{
interpDataList = new List <TemplateVertexData>();
interpDataDict = new Dictionary <TemplateSemantics, TemplateVertexData>();
}
WirePortDataType dataType = CgToWirePortType[match.Groups[1].Value];
string varName = match.Groups[2].Value;
TemplateSemantics semantics = (TemplateSemantics)Enum.Parse(typeof(TemplateSemantics), match.Groups[3].Value);
TemplateVertexData templateVertexData = new TemplateVertexData(semantics, dataType, varName);
//interpDataList.Add( templateVertexData );
interpDataDict.Add(semantics, templateVertexData);
//Check if they are also on the free channels list and update their names
interpDataObj.ReplaceNameOnInterpolator(semantics, varName);
}
}
// Get info for available interpolators
string[] paramsArray = parametersBody.Split(IOUtils.FIELD_SEPARATOR);
if (paramsArray.Length > 0)
{
for (int i = 0; i < paramsArray.Length; i++)
{
string[] paramDataArr = paramsArray[i].Split(IOUtils.VALUE_SEPARATOR);
if (paramDataArr.Length == 2)
{
string[] swizzleInfoArr = paramDataArr[1].Split(IOUtils.FLOAT_SEPARATOR);
TemplateSemantics semantic = ShortcutToSemantic[swizzleInfoArr[0]];
if (interpDataDict.ContainsKey(semantic))
{
if (interpDataDict[semantic] != null)
{
TemplateVertexData templateVertexData = new TemplateVertexData(interpDataDict[semantic]);
if (swizzleInfoArr.Length > 1)
{
templateVertexData.DataSwizzle = "." + swizzleInfoArr[1];
}
templateVertexData.DataInfo = ShortcutToInfo[paramDataArr[0]];
templateVertexData.Available = true;
interpDataList.Add(templateVertexData);
}
}
}
}
}
/*TODO:
* 1) Remove interpDataList.Add( templateVertexData ); from initial foreach
* 2) When looping though each foreach array element, create a new TemplateVertexData
* from the one containted on the interpDataDict and add it to interpDataList
*/
interpDataObj.Interpolators = interpDataList;
interpDataDict.Clear();
interpDataDict = null;
}
return(interpDataObj);
}
public string GenerateShaderForOutput(ref MasterNodeDataCollector dataCollector, WirePortDataType inputPortType, bool ignoreLocalVar, bool autoCast = false)
{
string result = string.Empty;
if (m_externalReferences.Count > 0 && !m_locked)
{
result = UIUtils.GetNode(m_externalReferences[0].NodeId).GenerateShaderForOutput(m_externalReferences[0].PortId, ref dataCollector, ignoreLocalVar);
if (autoCast && m_externalReferences[0].DataType != inputPortType)
{
result = UIUtils.CastPortType(ref dataCollector, UIUtils.GetNode(m_nodeId).CurrentPrecisionType, new NodeCastInfo(m_externalReferences[0].NodeId, m_externalReferences[0].PortId), null, m_externalReferences[0].DataType, inputPortType, result);
}
}
else
{
UpdateInternalData();
if (!String.IsNullOrEmpty(m_internalDataWrapper))
{
if (DataType == WirePortDataType.FLOAT3x3)
{
result = Matrix3x3WrappedData();
}
else
{
result = String.Format(m_internalDataWrapper, m_internalData);
}
}
else
{
result = m_internalData;
}
}
return(result);
}
public override void OnConnectedOutputNodeChanges( int inputPortId, int otherNodeId, int otherPortId, string name, WirePortDataType type )
{
base.OnConnectedOutputNodeChanges( inputPortId, otherNodeId, otherPortId, name, type );
FunctionInput functionInput = m_refreshIdsRequired ? m_allFunctionInputs[ inputPortId ] : GetFunctionInputByUniqueId( inputPortId );
if( functionInput.AutoCast )
{
InputPort inputPort = m_refreshIdsRequired ? m_inputPorts[ inputPortId ] : GetInputPortByUniqueId( inputPortId );
inputPort.MatchPortToConnection();
ParentGraph cachedGraph = ContainerGraph.ParentWindow.CustomGraph;
ContainerGraph.ParentWindow.CustomGraph = m_functionGraph;
functionInput.ChangeOutputType( inputPort.DataType, false );
ContainerGraph.ParentWindow.CustomGraph = cachedGraph;
}
for( int i = 0; i < m_allFunctionOutputs.Count; i++ )
{
m_outputPorts[ i ].ChangeType( m_allFunctionOutputs[ i ].InputPorts[ 0 ].DataType, false );
}
}
public override void ReadFromString(ref string[] nodeParams)
{
// This node is, by default, created with one input port
base.ReadFromString(ref nodeParams);
m_code = GetCurrentParam(ref nodeParams);
m_code = m_code.Replace(LineFeedSeparator, '\n');
m_code = m_code.Replace(SemiColonSeparator, ';');
m_outputTypeIdx = Convert.ToInt32(GetCurrentParam(ref nodeParams));
m_outputPorts[0].ChangeType(AvailableWireTypes[m_outputTypeIdx], false);
if (UIUtils.CurrentShaderVersion() > 12001)
{
m_callMode = Convert.ToBoolean(GetCurrentParam(ref nodeParams));
if (m_callMode)
{
m_firstAvailablePort = 1;
AddInputPortAt(0, WirePortDataType.FLOAT, false, DefaultInputName);
}
}
int count = Convert.ToInt32(GetCurrentParam(ref nodeParams));
if (count == 0)
{
DeleteInputPortByArrayIdx(0);
m_foldoutValuesLabels.Clear();
m_variableQualifiers.Clear();
}
else
{
for (int i = 0; i < count; i++)
{
bool foldoutValue = Convert.ToBoolean(GetCurrentParam(ref nodeParams));
string name = GetCurrentParam(ref nodeParams);
WirePortDataType type = ( WirePortDataType )Enum.Parse(typeof(WirePortDataType), GetCurrentParam(ref nodeParams));
string internalData = GetCurrentParam(ref nodeParams);
VariableQualifiers qualifier = VariableQualifiers.In;
if (UIUtils.CurrentShaderVersion() > 12001)
{
qualifier = ( VariableQualifiers )Enum.Parse(typeof(VariableQualifiers), GetCurrentParam(ref nodeParams));
}
int portIdx = i + m_firstAvailablePort;
if (i == 0)
{
m_inputPorts[portIdx].ChangeProperties(name, type, false);
m_variableQualifiers[0] = qualifier;
m_foldoutValuesFlags[0] = foldoutValue;
}
else
{
m_foldoutValuesLabels.Add("[" + i + "]");
m_variableQualifiers.Add(qualifier);
m_foldoutValuesFlags.Add(foldoutValue);
AddInputPort(type, false, name);
}
m_inputPorts[i].InternalData = internalData;
}
}
if (UIUtils.CurrentShaderVersion() > 7205)
{
m_customExpressionName = GetCurrentParam(ref nodeParams);
SetTitleText(m_customExpressionName);
}
m_repopulateNameDictionary = true;
m_functionMode = m_code.Contains(ReturnHelper);
}
public void AddInput(int tagStartIdx, string tagId, string portName, string defaultValue, WirePortDataType dataType, MasterNodePortCategory portCategory, int portUniqueId, int portOrderId)
{
m_inputDataList.Add(new TemplateInputData(tagStartIdx, tagId, portName, defaultValue, dataType, portCategory, portUniqueId, portOrderId));
AddId(tagId, false);
}
/// <summary>
/// Generates UV properties and uniforms and returns the varible name to use in the fragment shader
/// </summary>
/// <param name="dataCollector"></param>
/// <param name="uniqueId"></param>
/// <param name="index"></param>
/// <returns>frag variable name</returns>
static public string GenerateFragUVs(ref MasterNodeDataCollector dataCollector, int uniqueId, int index, string propertyName = null, WirePortDataType size = WirePortDataType.FLOAT2)
{
string dummyPropUV = "_texcoord" + (index > 0 ? (index + 1).ToString() : "");
string dummyUV = "uv" + (index > 0 ? (index + 1).ToString() : "") + dummyPropUV;
dataCollector.AddToProperties(uniqueId, "[HideInInspector] " + dummyPropUV + "( \"\", 2D ) = \"white\" {}", 100);
dataCollector.AddToInput(uniqueId, UIUtils.WirePortToCgType(size) + " " + dummyUV, true);
string result = Constants.InputVarStr + "." + dummyUV;
if (!string.IsNullOrEmpty(propertyName))
{
dataCollector.AddToUniforms(uniqueId, "uniform float4 " + propertyName + "_ST;");
dataCollector.AddToLocalVariables(uniqueId, PrecisionType.Float, size, "uv" + propertyName, result + " * " + propertyName + "_ST.xy + " + propertyName + "_ST.zw");
result = "uv" + propertyName;
}
return(result);
}
public override void OnConnectedOutputNodeChanges(int portId, int otherNodeId, int otherPortId, string name, WirePortDataType type)
{
base.OnConnectedOutputNodeChanges(portId, otherNodeId, otherPortId, name, type);
CheckPortConnection(portId);
}
public OutputPort(int nodeId, int portId, WirePortDataType dataType, string name) : base(nodeId, portId, dataType, name)
{
LabelSize = Vector2.zero;
}
public OutputPort(int nodeId, int portId, WirePortDataType dataType, string name) : base(nodeId, portId, dataType, name)
{
}
public override string BuildResults( int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar )
{
if( m_inputPorts[ 0 ].DataType == WirePortDataType.FLOAT3x3 ||
m_inputPorts[ 0 ].DataType == WirePortDataType.FLOAT4x4 ||
m_inputPorts[ 1 ].DataType == WirePortDataType.FLOAT3x3 ||
m_inputPorts[ 1 ].DataType == WirePortDataType.FLOAT4x4 )
{
m_inputA = m_inputPorts[ 0 ].GeneratePortInstructions( ref dataCollector ):
m_inputB = m_inputPorts[ 1 ].GeneratePortInstructions( ref dataCollector ):
WirePortDataType autoCast = WirePortDataType.OBJECT:
// Check matrix on first input
if( m_inputPorts[ 0 ].DataType == WirePortDataType.FLOAT3x3 )
{
switch( m_inputPorts[ 1 ].DataType )
{
case WirePortDataType.OBJECT:
case WirePortDataType.FLOAT:
case WirePortDataType.INT:
case WirePortDataType.FLOAT2:
case WirePortDataType.FLOAT4:
case WirePortDataType.COLOR:
{
m_inputB = UIUtils.CastPortType( ref dataCollector, m_currentPrecisionType, new NodeCastInfo( UniqueId, outputId ), m_inputB, m_inputPorts[ 1 ].DataType, WirePortDataType.FLOAT3, m_inputB ):
autoCast = WirePortDataType.FLOAT3:
}
break:
case WirePortDataType.FLOAT4x4:
{
m_inputA = UIUtils.CastPortType( ref dataCollector, m_currentPrecisionType, new NodeCastInfo( UniqueId, outputId ), m_inputA, m_inputPorts[ 0 ].DataType, WirePortDataType.FLOAT4x4, m_inputA ):
}
break:
case WirePortDataType.FLOAT3:
case WirePortDataType.FLOAT3x3: break:
}
}
if( m_inputPorts[ 0 ].DataType == WirePortDataType.FLOAT4x4 )
{
switch( m_inputPorts[ 1 ].DataType )
{
case WirePortDataType.OBJECT:
case WirePortDataType.FLOAT:
case WirePortDataType.INT:
case WirePortDataType.FLOAT2:
case WirePortDataType.FLOAT3:
{
m_inputB = UIUtils.CastPortType( ref dataCollector, m_currentPrecisionType, new NodeCastInfo( UniqueId, outputId ), m_inputB, m_inputPorts[ 1 ].DataType, WirePortDataType.FLOAT4, m_inputB ):
autoCast = WirePortDataType.FLOAT4:
}
break:
case WirePortDataType.FLOAT3x3:
{
m_inputB = UIUtils.CastPortType( ref dataCollector, m_currentPrecisionType, new NodeCastInfo( UniqueId, outputId ), m_inputB, m_inputPorts[ 1 ].DataType, WirePortDataType.FLOAT4x4, m_inputB ):
}
break:
case WirePortDataType.FLOAT4x4:
case WirePortDataType.FLOAT4:
case WirePortDataType.COLOR: break:
}
}
// Check matrix on second input
if( m_inputPorts[ 1 ].DataType == WirePortDataType.FLOAT3x3 )
{
switch( m_inputPorts[ 0 ].DataType )
{
case WirePortDataType.OBJECT:
case WirePortDataType.FLOAT:
case WirePortDataType.INT:
case WirePortDataType.FLOAT2:
case WirePortDataType.FLOAT4:
case WirePortDataType.COLOR:
{
m_inputA = UIUtils.CastPortType( ref dataCollector, m_currentPrecisionType, new NodeCastInfo( UniqueId, outputId ), m_inputA, m_inputPorts[ 0 ].DataType, WirePortDataType.FLOAT3, m_inputA ):
autoCast = WirePortDataType.FLOAT3:
}
break:
case WirePortDataType.FLOAT4x4:
case WirePortDataType.FLOAT3:
case WirePortDataType.FLOAT3x3: break:
}
}
if( m_inputPorts[ 1 ].DataType == WirePortDataType.FLOAT4x4 )
{
switch( m_inputPorts[ 0 ].DataType )
{
case WirePortDataType.OBJECT:
case WirePortDataType.FLOAT:
case WirePortDataType.INT:
case WirePortDataType.FLOAT2:
case WirePortDataType.FLOAT3:
{
m_inputA = UIUtils.CastPortType( ref dataCollector, m_currentPrecisionType, new NodeCastInfo( UniqueId, outputId ), m_inputA, m_inputPorts[ 0 ].DataType, WirePortDataType.FLOAT4, m_inputA ):
autoCast = WirePortDataType.FLOAT4:
}
break:
case WirePortDataType.FLOAT3x3:
case WirePortDataType.FLOAT4x4:
case WirePortDataType.FLOAT4:
case WirePortDataType.COLOR: break:
}
}
string result = "mul( " + m_inputA + ", " + m_inputB + " )":
if( autoCast != WirePortDataType.OBJECT && autoCast != m_outputPorts[ 0 ].DataType )
{
result = UIUtils.CastPortType( ref dataCollector, m_currentPrecisionType, new NodeCastInfo( UniqueId, outputId ), result, autoCast, m_outputPorts[ 0 ].DataType, result ):
}
return result:
}
else
{
base.BuildResults( outputId, ref dataCollector, ignoreLocalvar ):
string result = "( " + m_extensibleInputResults[ 0 ]:
for( int i = 1: i < m_extensibleInputResults.Count: i++ )
{
result += " * " + m_extensibleInputResults[ i ]:
}
result += " )":
return result:
}
}
public TemplateShaderPropertyData(string propertyInspectorName, string propertyName, WirePortDataType propertyDataType, PropertyType propertyType)
{
PropertyInspectorName = string.IsNullOrEmpty(propertyInspectorName)?propertyName: propertyInspectorName;
PropertyName = propertyName;
PropertyDataType = propertyDataType;
PropertyType = propertyType;
}
void FetchInputs(int offset, MasterNodePortCategory portCategory, string body)
{
string beginTag = (portCategory == MasterNodePortCategory.Fragment) ? TemplatesManager.TemplateInputsFragBeginTag : TemplatesManager.TemplateInputsVertBeginTag;
int[] inputBeginIndexes = body.AllIndexesOf(beginTag);
if (inputBeginIndexes != null && inputBeginIndexes.Length > 0)
{
for (int i = 0; i < inputBeginIndexes.Length; i++)
{
int inputEndIdx = body.IndexOf(TemplatesManager.TemplateEndSectionTag, inputBeginIndexes[i]);
int defaultValueBeginIdx = inputEndIdx + TemplatesManager.TemplateEndSectionTag.Length;
int endLineIdx = body.IndexOf(TemplatesManager.TemplateFullEndTag, defaultValueBeginIdx);
string defaultValue = body.Substring(defaultValueBeginIdx, endLineIdx - defaultValueBeginIdx);
string tagId = body.Substring(inputBeginIndexes[i], endLineIdx + TemplatesManager.TemplateFullEndTag.Length - inputBeginIndexes[i]);
int beginIndex = inputBeginIndexes[i] + beginTag.Length;
int length = inputEndIdx - beginIndex;
string inputData = body.Substring(beginIndex, length);
string[] inputDataArray = inputData.Split(IOUtils.FIELD_SEPARATOR);
if (inputDataArray != null && inputDataArray.Length > 0)
{
try
{
string portName = inputDataArray[(int)TemplatePortIds.Name];
WirePortDataType dataType = (WirePortDataType)Enum.Parse(typeof(WirePortDataType), inputDataArray[(int)TemplatePortIds.DataType].ToUpper());
if (inputDataArray.Length == 3)
{
int portOrderId = m_inputDataList.Count;
int portUniqueId = -1;
bool isInt = int.TryParse(inputDataArray[2], out portUniqueId);
if (isInt)
{
if (portUniqueId < 0)
{
portUniqueId = m_inputDataList.Count;
}
m_inputDataList.Add(new TemplateInputData(inputBeginIndexes[i], offset + inputBeginIndexes[i], tagId, portName, defaultValue, dataType, portCategory, portUniqueId, portOrderId, string.Empty));
m_templateProperties.AddId(body, tagId, false);
}
else
{
portUniqueId = m_inputDataList.Count;
m_inputDataList.Add(new TemplateInputData(inputBeginIndexes[i], offset + inputBeginIndexes[i], tagId, portName, defaultValue, dataType, portCategory, portUniqueId, portOrderId, inputDataArray[2]));
m_templateProperties.AddId(body, tagId, false);
}
}
else
{
int portUniqueIDArrIdx = (int)TemplatePortIds.UniqueId;
int portUniqueId = (portUniqueIDArrIdx < inputDataArray.Length) ? Convert.ToInt32(inputDataArray[portUniqueIDArrIdx]) : -1;
if (portUniqueId < 0)
{
portUniqueId = m_inputDataList.Count;
}
int portOrderArrayIdx = (int)TemplatePortIds.OrderId;
int portOrderId = (portOrderArrayIdx < inputDataArray.Length) ? Convert.ToInt32(inputDataArray[portOrderArrayIdx]) : -1;
if (portOrderId < 0)
{
portOrderId = m_inputDataList.Count;
}
int portLinkIdx = (int)TemplatePortIds.Link;
string linkId = (portLinkIdx < inputDataArray.Length) ? inputDataArray[portLinkIdx] : string.Empty;
m_inputDataList.Add(new TemplateInputData(inputBeginIndexes[i], offset + inputBeginIndexes[i], tagId, portName, defaultValue, dataType, portCategory, portUniqueId, portOrderId, linkId));
m_templateProperties.AddId(body, tagId, false);
}
}
catch (Exception e)
{
Debug.LogException(e);
}
}
}
}
}
public override void OnConnectedOutputNodeChanges( int outputPortId, int otherNodeId, int otherPortId, string name, WirePortDataType type )
{
base.OnConnectedOutputNodeChanges( outputPortId, otherNodeId, otherPortId, name, type ):
GetInputPortByUniqueId( outputPortId ).MatchPortToConnection():
UpdateOutputPort():
}
public override string GenerateShaderForOutput(int outputId, WirePortDataType inputPortType, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar)
{
string result = string.Empty;
string colorTarget = m_inputPorts[0].GenerateShaderForOutput(ref dataCollector, inputPortType, ignoreLocalvar);
WirePortDataType dataType = m_inputPorts[0].ConnectionType();
if (dataType != WirePortDataType.COLOR && dataType != WirePortDataType.FLOAT4)
{
colorTarget = UIUtils.CastPortType(new NodeCastInfo(m_uniqueId, outputId), null, dataType, WirePortDataType.FLOAT4, colorTarget);
}
string localVarName = "ChannelBlendNode" + m_uniqueId;
string localVar = "float4 " + localVarName + " = " + colorTarget + ";";
dataCollector.AddToLocalVariables(m_uniqueId, localVar);
m_inputPorts[1].InternalData = m_inputPorts[1].IsConnected ? m_inputPorts[1].GenerateShaderForOutput(ref dataCollector, inputPortType, ignoreLocalvar) : m_defaultAmounts[0].ToString();
m_inputPorts[2].InternalData = m_inputPorts[2].IsConnected ? m_inputPorts[2].GenerateShaderForOutput(ref dataCollector, inputPortType, ignoreLocalvar) : m_defaultAmounts[1].ToString();
m_inputPorts[3].InternalData = m_inputPorts[3].IsConnected ? m_inputPorts[3].GenerateShaderForOutput(ref dataCollector, inputPortType, ignoreLocalvar) : m_defaultAmounts[2].ToString();
m_inputPorts[4].InternalData = m_inputPorts[4].IsConnected ? m_inputPorts[4].GenerateShaderForOutput(ref dataCollector, inputPortType, ignoreLocalvar) : m_defaultAmounts[3].ToString();
if (m_isLayered)
{
string layerMask = m_inputPorts[4].IsConnected ? m_inputPorts[4].GenerateShaderForOutput(ref dataCollector, inputPortType, ignoreLocalvar) : m_defaultLayerFactor.ToString();
WirePortDataType dataType4 = m_inputPorts[4].ConnectionType();
if (dataType4 != WirePortDataType.FLOAT)
{
layerMask = UIUtils.CastPortType(new NodeCastInfo(m_uniqueId, outputId), null, dataType4, WirePortDataType.FLOAT, layerMask);
}
if (m_activePorts == 0)
{
result = colorTarget;
}
else if (m_activePorts == 1)
{
result += "lerp( " + layerMask + "," + m_inputPorts[1].InternalData + " , " + localVarName + ".r )";
}
else
{
result = layerMask;
for (int i = 0; i < m_activePorts; i++)
{
result = "lerp( " + result + " , " + m_inputPorts[i + 1].InternalData + " , " + localVarName + UIUtils.GetComponentForPosition(i, m_inputPorts[0].DataType, true) + " )";
}
}
}
else
{
if (m_activePorts == 0)
{
result = colorTarget;
}
else if (m_activePorts == 1)
{
result += localVarName + "*" + m_inputPorts[1].InternalData;
}
else
{
for (int i = 1; i < (m_activePorts + 1); i++)
{
result += localVarName + UIUtils.GetComponentForPosition(i - 1, m_inputPorts[0].DataType, true) + "*" + m_inputPorts[i].InternalData;
if (i != m_activePorts)
{
result += " + ";
}
}
}
}
result = UIUtils.AddBrackets(result);
return(CreateOutputLocalVariable(0, result, ref dataCollector));
}
public void GetFirstAvailableName(int nodeId, WirePortDataType type, out string outProperty, out string outInspector, bool useCustomPrefix = false, string customPrefix = null)
{
string name = string.Empty;
if (useCustomPrefix && customPrefix != null)
{
name = customPrefix;
}
else
{
switch (type)
{
case WirePortDataType.OBJECT:
case WirePortDataType.FLOAT:
{
name = FloatNameStr;
}
break;
case WirePortDataType.INT:
{
name = IntNameStr;
}
break;
case WirePortDataType.FLOAT2:
case WirePortDataType.FLOAT3:
case WirePortDataType.FLOAT4:
{
name = VectorNameStr;
}
break;
case WirePortDataType.FLOAT3x3:
case WirePortDataType.FLOAT4x4:
{
name = MatrixNameStr;
}
break;
case WirePortDataType.COLOR:
{
name = ColorNameStr;
}
break;
}
}
int count = 0;
bool foundName = false;
while (!foundName)
{
string inspectorName = name + count;
string propertyName = UIUtils.GeneratePropertyName(inspectorName, PropertyType.Property);
if (IsUniformNameAvailable(propertyName))
{
outInspector = inspectorName;
outProperty = propertyName;
RegisterUniformName(nodeId, propertyName);
return;
}
count += 1;
}
outProperty = string.Empty;
outInspector = string.Empty;
UIUtils.ShowMessage("Could not find a valid name " + MessageSeverity.Warning);
}
//public override void DrawProperties()
//{
// base.DrawProperties();
// EditorGUI.BeginChangeCheck();
// _isLayered = EditorGUILayout.ToggleLeft( IsLayerStr, _isLayered );
// if ( EditorGUI.EndChangeCheck() )
// {
// _inputPorts[ 5 ].Visible = _isLayered;
// if ( !_inputPorts[ 5 ].Visible && _inputPorts[ 5 ].IsConnected )
// {
// UIUtils.CurrentWindow.DeleteConnection( true, _uniqueId, 5, true );
// }
// _sizeIsDirty = true;
// }
// if ( _isLayered )
// {
// _defaultLayerFactor = EditorGUILayout.FloatField( LayerFactorStr, _defaultLayerFactor );
// }
// for ( int i = 0; i < _activePorts; i++ )
// {
// _defaultAmounts[ i ] = EditorGUILayout.FloatField( AmountsStr[ i ], _defaultAmounts[ i ] );
// }
//}
public override void OnConnectedOutputNodeChanges(int inputPortId, int otherNodeId, int otherPortId, string name, WirePortDataType type)
{
if (inputPortId == 0)
{
UpdateConnection(true);
}
}
private void ConfigPortsFromMaterial(bool invalidateConnections = false, Texture[] newTextures = null)
{
//PreviewSizeX = ( m_proceduralMaterial != null ) ? UIUtils.ObjectField.CalcSize( new GUIContent( m_proceduralMaterial.name ) ).x + 15 : 110;
//m_insideSize.x = TexturePreviewSizeX + 5;
SetAdditonalTitleText((m_proceduralMaterial != null) ? string.Format(Constants.PropertyValueLabel, m_proceduralMaterial.name) : "Value( <None> )");
Texture[] textures = newTextures != null ? newTextures : ((m_proceduralMaterial != null) ? m_proceduralMaterial.GetGeneratedTextures() : null);
if (textures != null)
{
string nameToRemove = m_proceduralMaterial.name + "_";
m_textureTypes = new ProceduralOutputType[textures.Length];
for (int i = 0; i < textures.Length; i++)
{
ProceduralTexture procTex = textures[i] as ProceduralTexture;
m_textureTypes[i] = procTex.GetProceduralOutputType();
WirePortDataType portType = (m_autoNormal && m_textureTypes[i] == ProceduralOutputType.Normal) ? WirePortDataType.FLOAT3 : WirePortDataType.COLOR;
string newName = textures[i].name.Replace(nameToRemove, string.Empty);
char firstLetter = Char.ToUpper(newName[0]);
newName = firstLetter.ToString() + newName.Substring(1);
if (i < m_outputPorts.Count)
{
m_outputPorts[i].ChangeProperties(newName, portType, false);
if (invalidateConnections)
{
m_outputPorts[i].FullDeleteConnections();
}
}
else
{
AddOutputPort(portType, newName);
}
}
if (textures.Length < m_outputPorts.Count)
{
int itemsToRemove = m_outputPorts.Count - textures.Length;
for (int i = 0; i < itemsToRemove; i++)
{
int idx = m_outputPorts.Count - 1;
if (m_outputPorts[idx].IsConnected)
{
m_outputPorts[idx].ForceClearConnection();
}
RemoveOutputPort(idx);
}
}
}
else
{
int itemsToRemove = m_outputPorts.Count - 1;
m_outputPorts[0].ChangeProperties(Constants.EmptyPortValue, WirePortDataType.COLOR, false);
m_outputPorts[0].ForceClearConnection();
for (int i = 0; i < itemsToRemove; i++)
{
int idx = m_outputPorts.Count - 1;
if (m_outputPorts[idx].IsConnected)
{
m_outputPorts[idx].ForceClearConnection();
}
RemoveOutputPort(idx);
}
}
m_sizeIsDirty = true;
m_isDirty = true;
//Event.current.Use();
}
public AppendData( WirePortDataType portType, int oldPortId, int newPortId )
{
PortType = portType:
OldPortId = oldPortId:
NewPortId = newPortId:
}
// VERTEX POSITION
static public string GenerateVertexPosition(ref MasterNodeDataCollector dataCollector, int uniqueId, WirePortDataType size)
{
string value = Constants.VertexShaderInputStr + ".vertex";
if (size == WirePortDataType.FLOAT3)
{
value += ".xyz";
}
if (dataCollector.PortCategory == MasterNodePortCategory.Fragment || dataCollector.PortCategory == MasterNodePortCategory.Debug)
{
dataCollector.AddToInput(uniqueId, SurfaceInputs.WORLD_POS);
dataCollector.AddToIncludes(uniqueId, Constants.UnityShaderVariables);
value = "mul( unity_WorldToObject, float4( " + Constants.InputVarStr + ".worldPos , 1 ) )";
}
string varName = VertexPosition4Str;
if (size == WirePortDataType.FLOAT3)
{
varName = VertexPosition3Str;
}
dataCollector.AddLocalVariable(uniqueId, PrecisionType.Float, size, varName, value);
return(varName);
}
public override void OnConnectedOutputNodeChanges( int portId, int otherNodeId, int otherPortId, string name, WirePortDataType type )
{
base.OnConnectedOutputNodeChanges( portId, otherNodeId, otherPortId, name, type ):
if( ( UIUtils.IsLoading || m_isNodeBeingCopied ) && UIUtils.CurrentShaderVersion() < 13206 )
return:
NewUpdateBehaviorConn( portId, ( UIUtils.IsLoading || m_isNodeBeingCopied ) ):
RenamePorts():
}
public static string AutoSwizzleData(string dataVar, WirePortDataType dataType, WirePortDataType swizzle)
{
switch (dataType)
{
case WirePortDataType.COLOR:
case WirePortDataType.FLOAT4:
{
switch (swizzle)
{
case WirePortDataType.FLOAT3: dataVar += ".xyz"; break;
case WirePortDataType.FLOAT2: dataVar += ".xy"; break;
case WirePortDataType.INT:
case WirePortDataType.FLOAT: dataVar += ".x"; break;
}
}
break;
case WirePortDataType.FLOAT3:
{
switch (swizzle)
{
case WirePortDataType.FLOAT4: dataVar = string.Format("float4({0},0)", dataVar); break;
case WirePortDataType.FLOAT2: dataVar += ".xy"; break;
case WirePortDataType.INT:
case WirePortDataType.FLOAT: dataVar += ".x"; break;
}
}
break;
case WirePortDataType.FLOAT2:
{
switch (swizzle)
{
case WirePortDataType.FLOAT4: dataVar = string.Format("float4({0},0,0)", dataVar); break;
case WirePortDataType.FLOAT3: dataVar = string.Format("float3({0},0)", dataVar); break;
case WirePortDataType.INT:
case WirePortDataType.FLOAT: dataVar += ".x"; break;
}
}
break;
case WirePortDataType.FLOAT:
{
switch (swizzle)
{
case WirePortDataType.FLOAT4: dataVar = string.Format("float4({0},0,0,0)", dataVar); break;
case WirePortDataType.FLOAT3: dataVar = string.Format("float3({0},0,0)", dataVar); break;
case WirePortDataType.FLOAT2: dataVar = string.Format("float2({0},0)", dataVar); break;
}
}
break;
}
return(dataVar);
}
public void SetReference(WirePort port)
{
m_nodeId = port.NodeId;
m_portId = port.PortId;
m_dataType = port.DataType;
}
public override void OnConnectedOutputNodeChanges(int inputPortId, int otherNodeId, int otherPortId, string name, WirePortDataType type)
{
base.OnConnectedOutputNodeChanges(inputPortId, otherNodeId, otherPortId, name, type);
UpdateConnections();
}
public TemplateInputData(int tagLocalStartIdx, int tagGlobalStartIdx, string tagId, string portName, string defaultValue, WirePortDataType dataType, MasterNodePortCategory portCategory, int portUniqueId, int orderId, string linkId)
{
DefaultValue = defaultValue;
PortName = portName;
DataType = dataType;
PortCategory = portCategory;
PortUniqueId = portUniqueId;
OrderId = orderId;
TagId = tagId;
TagGlobalStartIdx = tagGlobalStartIdx;
TagLocalStartIdx = tagLocalStartIdx;
LinkId = linkId;
}
public override string GenerateShaderForOutput(int outputId, WirePortDataType inputPortType, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar)
{
return(m_variableName);
}
public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar)
{
if (!m_texPort.IsConnected)
{
UIUtils.ShowMessage(UniqueId, "Parallax Occlusion Mapping node only works if a Texture Object is connected to its Tex (R) port");
return("0");
}
base.GenerateShaderForOutput(outputId, ref dataCollector, ignoreLocalvar);
WirePortDataType texType = (m_pomTexType == POMTexTypes.Texture3D)?WirePortDataType.SAMPLER3D: WirePortDataType.SAMPLER2D;
GeneratePOMfunction();
string arrayIndex = m_arrayIndexPort.Visible?m_arrayIndexPort.GeneratePortInstructions(ref dataCollector):"0";
string textcoords = m_uvPort.GeneratePortInstructions(ref dataCollector);
if (m_pomTexType == POMTexTypes.Texture3D)
{
string texName = "pomTexCoord" + OutputId;
dataCollector.AddLocalVariable(UniqueId, CurrentPrecisionType, WirePortDataType.FLOAT3, texName, string.Format("float3({0},{1})", textcoords, arrayIndex));
textcoords = texName;
}
string texture = m_texPort.GenerateShaderForOutput(ref dataCollector, texType, false, true);
string scale = m_defaultScale.ToString();
if (m_scalePort.IsConnected)
{
scale = m_scalePort.GeneratePortInstructions(ref dataCollector);
}
string viewDirTan = "";
if (!m_viewdirTanPort.IsConnected)
{
if (!dataCollector.DirtyNormal)
{
dataCollector.ForceNormal = true;
}
if (dataCollector.IsTemplate)
{
viewDirTan = dataCollector.TemplateDataCollectorInstance.GetTangentViewDir(CurrentPrecisionType);
}
else
{
viewDirTan = GeneratorUtils.GenerateViewDirection(ref dataCollector, UniqueId, ViewSpace.Tangent);
//dataCollector.AddToInput( UniqueId, SurfaceInputs.VIEW_DIR, m_currentPrecisionType );
//viewDirTan = Constants.InputVarStr + "." + UIUtils.GetInputValueFromType( SurfaceInputs.VIEW_DIR );
}
}
else
{
viewDirTan = m_viewdirTanPort.GeneratePortInstructions(ref dataCollector);
}
//generate world normal
string normalWorld = string.Empty;
if (dataCollector.IsTemplate)
{
normalWorld = dataCollector.TemplateDataCollectorInstance.GetWorldNormal(CurrentPrecisionType);
}
else
{
dataCollector.AddToInput(UniqueId, SurfaceInputs.WORLD_NORMAL, CurrentPrecisionType);
dataCollector.AddToInput(UniqueId, SurfaceInputs.INTERNALDATA, addSemiColon: false);
normalWorld = GeneratorUtils.GenerateWorldNormal(ref dataCollector, UniqueId);
}
//string normalWorld = "WorldNormalVector( " + Constants.InputVarStr + ", float3( 0, 0, 1 ) )";
//generate viewDir in world space
//string worldPos = string.Empty;
//if( dataCollector.IsTemplate )
//{
// worldPos = dataCollector.TemplateDataCollectorInstance.GetWorldPos();
//}
//else
//{
// dataCollector.AddToInput( UniqueId, SurfaceInputs.WORLD_POS );
// worldPos = Constants.InputVarStr + ".worldPos";
//}
//if( !dataCollector.IsTemplate )
// dataCollector.AddToInput( UniqueId, SurfaceInputs.WORLD_POS );
string worldViewDir = GeneratorUtils.GenerateViewDirection(ref dataCollector, UniqueId, ViewSpace.World);
//dataCollector.AddToLocalVariables( UniqueId, m_currentPrecisionType, WirePortDataType.FLOAT3, WorldDirVarStr, TemplateHelperFunctions.WorldSpaceViewDir( dataCollector, worldPos, true ) );
string dx = "ddx(" + textcoords + ")";
string dy = "ddy(" + textcoords + ")";
string refPlane = m_defaultRefPlane.ToString();
if (m_refPlanePort.IsConnected)
{
refPlane = m_refPlanePort.GeneratePortInstructions(ref dataCollector);
}
string curvature = "float2(" + m_CurvatureVector.x + "," + m_CurvatureVector.y + ")";
if (m_useCurvature)
{
dataCollector.AddToProperties(UniqueId, "[Header(Parallax Occlusion Mapping)]", 300);
dataCollector.AddToProperties(UniqueId, "_CurvFix(\"Curvature Bias\", Range( 0 , 1)) = 1", 301);
dataCollector.AddToUniforms(UniqueId, "uniform float _CurvFix;");
if (m_curvaturePort.IsConnected)
{
curvature = m_curvaturePort.GeneratePortInstructions(ref dataCollector);
}
}
string localVarName = "OffsetPOM" + UniqueId;
string textCoordsST = string.Empty;
//string textureSTType = dataCollector.IsSRP ? "float4 " : "uniform float4 ";
//dataCollector.AddToUniforms( UniqueId, textureSTType + texture +"_ST;");
if (m_texCoordsHelper == null)
{
m_texCoordsHelper = CreateInstance <Vector4Node>();
m_texCoordsHelper.ContainerGraph = ContainerGraph;
m_texCoordsHelper.SetBaseUniqueId(UniqueId, true);
m_texCoordsHelper.RegisterPropertyOnInstancing = false;
m_texCoordsHelper.AddGlobalToSRPBatcher = true;
}
if (UIUtils.CurrentWindow.OutsideGraph.IsInstancedShader)
{
m_texCoordsHelper.CurrentParameterType = PropertyType.InstancedProperty;
}
else
{
m_texCoordsHelper.CurrentParameterType = PropertyType.Global;
}
m_texCoordsHelper.ResetOutputLocals();
m_texCoordsHelper.SetRawPropertyName(texture + "_ST");
textCoordsST = m_texCoordsHelper.GenerateShaderForOutput(0, ref dataCollector, false);
//////
if (m_pomTexType == POMTexTypes.TextureArray)
{
dataCollector.UsingArrayDerivatives = true;
}
string textureArgs = string.Empty;
if (m_pomTexType == POMTexTypes.TextureArray)
{
if (UIUtils.CurrentWindow.OutsideGraph.IsSRP)
{
textureArgs = "TEXTURE2D_ARRAY_PARAM(" + texture + " , " + "sampler##" + texture + ")";
}
else
{
textureArgs = "UNITY_PASS_TEX2DARRAY(" + texture + ")";
}
}
else
{
bool sampleThroughMacros = UIUtils.CurrentWindow.OutsideGraph.SamplingThroughMacros;
if (sampleThroughMacros)
{
dataCollector.AddToUniforms(UniqueId, string.Format(Constants.SamplerDeclarationSRPMacros[TextureType.Texture2D], texture));
textureArgs = string.Format("{0},sampler{0}", texture);
}
else
{
textureArgs = texture;
}
}
//string functionResult = dataCollector.AddFunctions( m_functionHeader, m_functionBody, ( (m_pomTexType == POMTexTypes.TextureArray) ? "UNITY_PASS_TEX2DARRAY(" + texture + ")": texture), textcoords, dx, dy, normalWorld, worldViewDir, viewDirTan, m_minSamples, m_maxSamples, scale, refPlane, texture+"_ST.xy", curvature, arrayIndex );
string functionResult = dataCollector.AddFunctions(m_functionHeader, m_functionBody, textureArgs, textcoords, dx, dy, normalWorld, worldViewDir, viewDirTan, m_inlineMinSamples.GetValueOrProperty(false), m_inlineMinSamples.GetValueOrProperty(false), scale, refPlane, textCoordsST + ".xy", curvature, arrayIndex);
dataCollector.AddLocalVariable(UniqueId, CurrentPrecisionType, m_pomUVPort.DataType, localVarName, functionResult);
return(GetOutputVectorItem(0, outputId, localVarName));
}
