public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar)
{
if (m_outputPorts[0].IsLocalValue(dataCollector.PortCategory))
{
return(m_outputPorts[0].LocalValue(dataCollector.PortCategory));
}
if (m_referenceType == TexReferenceType.Instance)
{
return(GenerateInstancedShaderForOutput(outputId, ref dataCollector, ignoreLocalvar));
}
string dataType = UIUtils.FinalPrecisionWirePortToCgType(m_currentPrecisionType, AvailableTypesValues[m_type]);
InputPort indexXPort = GetInputPortByUniqueId(0);
InputPort arrayLengthXPort = GetInputPortByUniqueId(1);
string result = string.Empty;
if (m_isJagged)
{
InputPort indexYPort = GetInputPortByUniqueId(2);
InputPort arrayLengthYPort = GetInputPortByUniqueId(3);
string arrayIndexX = indexXPort.IsConnected ? indexXPort.GeneratePortInstructions(ref dataCollector) : m_indexX.ToString();
string arrayLengthX = arrayLengthXPort.IsConnected ? arrayLengthXPort.GeneratePortInstructions(ref dataCollector) : m_arrayLengthX.ToString();
string arrayIndexY = indexYPort.IsConnected ? indexYPort.GeneratePortInstructions(ref dataCollector) : m_indexY.ToString();
string arrayLengthY = arrayLengthYPort.IsConnected ? arrayLengthYPort.GeneratePortInstructions(ref dataCollector) : m_arrayLengthY.ToString();
dataCollector.AddToUniforms(UniqueId, dataType, string.Format(JaggedArrayFormatStr, m_name, arrayLengthX, arrayLengthY));
if (m_autoRangeCheck)
{
arrayIndexX = string.Format("clamp({0},0,({1} - 1))", arrayIndexX, arrayLengthX);
arrayIndexY = string.Format("clamp({0},0,({1} - 1))", arrayIndexY, arrayLengthY);
}
result = string.Format(JaggedArrayFormatStr, m_name, arrayIndexX, arrayIndexY);
}
else
{
string arrayIndex = indexXPort.IsConnected ? indexXPort.GeneratePortInstructions(ref dataCollector) : m_indexX.ToString();
string arrayLength = arrayLengthXPort.IsConnected ? arrayLengthXPort.GeneratePortInstructions(ref dataCollector) : m_arrayLengthX.ToString();
dataCollector.AddToUniforms(UniqueId, dataType, string.Format(ArrayFormatStr, m_name, arrayLength));
if (m_autoRangeCheck)
{
arrayIndex = string.Format("clamp({0},0,({1} - 1))", arrayIndex, arrayLength);
}
result = string.Format(ArrayFormatStr, m_name, arrayIndex);
}
m_outputPorts[0].SetLocalValue(result, dataCollector.PortCategory);
return(m_outputPorts[0].LocalValue(dataCollector.PortCategory));
}
public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar)
{
if (!m_outputPorts[0].IsLocalValue(dataCollector.PortCategory))
{
string propertyOrOptions = string.Empty;
if (m_texPort.IsConnected)
{
propertyOrOptions = m_texPort.GeneratePortInstructions(ref dataCollector);
}
else if (m_referenceNode != null)
{
m_referenceNode.BaseGenerateShaderForOutput(outputId, ref dataCollector, ignoreLocalvar);
propertyOrOptions = m_referenceNode.PropertyName;
}
else
{
propertyOrOptions = GenerateSamplerAttributes();
}
string sampler = GeneratorUtils.GenerateSamplerState(ref dataCollector, UniqueId, propertyOrOptions);
m_outputPorts[0].SetLocalValue(sampler, dataCollector.PortCategory);
}
return(m_outputPorts[outputId].LocalValue(dataCollector.PortCategory));
}
public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar)
{
base.GenerateShaderForOutput(outputId, ref dataCollector, ignoreLocalvar);
switch (dataCollector.CurrentSRPType)
{
case TemplateSRPType.BuiltIn:
{
InputPort port = UIUtils.CurrentWindow.OutsideGraph.IsStandardSurface ? GetInputPortByUniqueId(0) : GetInputPortByUniqueId(3);
return(port.GeneratePortInstructions(ref dataCollector));
}
case TemplateSRPType.Lightweight:
{
InputPort port = GetInputPortByUniqueId(1);
return(port.GeneratePortInstructions(ref dataCollector));
}
case TemplateSRPType.HD:
{
InputPort port = GetInputPortByUniqueId(2);
return(port.GeneratePortInstructions(ref dataCollector));
}
}
return("0");
}
public string GenerateInstancedShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar)
{
string result = string.Empty;
if (m_referenceNode != null)
{
InputPort indexXPort = GetInputPortByUniqueId(0);
if (m_referenceNode.IsJagged)
{
InputPort indexYPort = GetInputPortByUniqueId(2);
string arrayIndexX = indexXPort.IsConnected ? indexXPort.GeneratePortInstructions(ref dataCollector) : m_indexX.ToString();
string arrayIndexY = indexYPort.IsConnected ? indexYPort.GeneratePortInstructions(ref dataCollector) : m_indexY.ToString();
result = m_referenceNode.GetArrayValue(arrayIndexX, arrayIndexY);
}
else
{
string arrayIndexX = indexXPort.IsConnected ? indexXPort.GeneratePortInstructions(ref dataCollector) : m_indexX.ToString();
result = m_referenceNode.GetArrayValue(arrayIndexX);
}
}
m_outputPorts[0].SetLocalValue(result, dataCollector.PortCategory);
return(result);
}
public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar)
{
if (m_outputPorts[0].IsLocalValue)
{
return(m_outputPorts[0].LocalValue);
}
InputPort vertexPort = GetInputPortByUniqueId(2);
InputPort lengthPort = GetInputPortByUniqueId(0);
InputPort offsetPort = GetInputPortByUniqueId(1);
string distance = lengthPort.GeneratePortInstructions(ref dataCollector);
string offset = offsetPort.GeneratePortInstructions(ref dataCollector);
string value = string.Empty;
string eyeDepth = string.Empty;
if (dataCollector.IsTemplate)
{
if (vertexPort.IsConnected)
{
string varName = "customSurfaceDepth" + OutputId;
GenerateInputInVertex(ref dataCollector, 2, varName, false);
string formatStr = string.Empty;
if (dataCollector.TemplateDataCollectorInstance.CurrentSRPType == TemplateSRPType.Lightweight)
{
formatStr = "-TransformWorldToView(TransformObjectToWorld({0})).z";
}
else
{
formatStr = "-UnityObjectToViewPos({0}).z";
}
string eyeInstruction = string.Format(formatStr, varName);
eyeDepth = "customEye" + OutputId;
dataCollector.TemplateDataCollectorInstance.RegisterCustomInterpolatedData(eyeDepth, WirePortDataType.FLOAT, m_currentPrecisionType, eyeInstruction);
}
else
{
eyeDepth = dataCollector.TemplateDataCollectorInstance.GetEyeDepth(m_currentPrecisionType);
}
value = string.Format(CameraDepthFadeFormat, eyeDepth, offset, distance);
RegisterLocalVariable(0, value, ref dataCollector, "cameraDepthFade" + OutputId);
return(m_outputPorts[0].LocalValue);
}
if (dataCollector.PortCategory == MasterNodePortCategory.Vertex || dataCollector.PortCategory == MasterNodePortCategory.Tessellation)
{
string vertexVarName = string.Empty;
if (vertexPort.IsConnected)
{
vertexVarName = vertexPort.GeneratePortInstructions(ref dataCollector);
}
else
{
vertexVarName = Constants.VertexShaderInputStr + ".vertex.xyz";
}
//dataCollector.AddVertexInstruction( "float cameraDepthFade" + UniqueId + " = (( -UnityObjectToViewPos( " + Constants.VertexShaderInputStr + ".vertex.xyz ).z -_ProjectionParams.y - " + offset + " ) / " + distance + ");", UniqueId );
value = string.Format(CameraDepthFadeFormat, "-UnityObjectToViewPos( " + vertexVarName + " ).z", offset, distance);
RegisterLocalVariable(0, value, ref dataCollector, "cameraDepthFade" + OutputId);
return(m_outputPorts[0].LocalValue);
}
dataCollector.AddToIncludes(UniqueId, Constants.UnityShaderVariables);
if (dataCollector.TesselationActive)
{
if (vertexPort.IsConnected)
{
string vertexValue = vertexPort.GeneratePortInstructions(ref dataCollector);
eyeDepth = "customSurfaceDepth" + OutputId;
RegisterLocalVariable(0, string.Format("-UnityObjectToViewPos( {0} ).z", vertexValue), ref dataCollector, eyeDepth);
}
else
{
eyeDepth = GeneratorUtils.GenerateScreenDepthOnFrag(ref dataCollector, UniqueId, m_currentPrecisionType);
}
}
else
{
if (vertexPort.IsConnected)
{
string varName = "customSurfaceDepth" + OutputId;
GenerateInputInVertex(ref dataCollector, 2, varName, false);
dataCollector.AddToInput(UniqueId, varName, WirePortDataType.FLOAT);
string vertexInstruction = "-UnityObjectToViewPos( " + varName + " ).z";
dataCollector.AddVertexInstruction(Constants.VertexShaderOutputStr + "." + varName + " = " + vertexInstruction, UniqueId);
eyeDepth = Constants.InputVarStr + "." + varName;
}
else
{
dataCollector.AddToInput(UniqueId, "eyeDepth", WirePortDataType.FLOAT);
string instruction = "-UnityObjectToViewPos( " + Constants.VertexShaderInputStr + ".vertex.xyz ).z";
dataCollector.AddVertexInstruction(Constants.VertexShaderOutputStr + ".eyeDepth = " + instruction, UniqueId);
eyeDepth = Constants.InputVarStr + ".eyeDepth";
}
}
value = string.Format(CameraDepthFadeFormat, eyeDepth, offset, distance);
RegisterLocalVariable(0, value, ref dataCollector, "cameraDepthFade" + OutputId);
//dataCollector.AddToLocalVariables( UniqueId, "float cameraDepthFade" + UniqueId + " = (( " + Constants.InputVarStr + ".eyeDepth -_ProjectionParams.y - "+ offset + " ) / " + distance + ");" );
return(m_outputPorts[0].LocalValue);
}
public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar)
{
base.GenerateShaderForOutput(outputId, ref dataCollector, ignoreLocalvar);
GeneratePOMfunction();
string textcoords = m_uvPort.GenerateShaderForOutput(ref dataCollector, WirePortDataType.FLOAT2, false, true);
string texture = m_texPort.GenerateShaderForOutput(ref dataCollector, WirePortDataType.SAMPLER2D, false, true);
string scale = m_defaultScale.ToString();
if (m_scalePort.IsConnected)
{
scale = m_scalePort.GenerateShaderForOutput(ref dataCollector, WirePortDataType.FLOAT, false, true);
}
string viewDirTan = "";
if (!m_viewdirTanPort.IsConnected)
{
if (!dataCollector.DirtyNormal)
{
dataCollector.ForceNormal = true;
}
if (dataCollector.IsTemplate)
{
viewDirTan = dataCollector.TemplateDataCollectorInstance.GetTangenViewDir();
}
else
{
string inputViewDirTan = UIUtils.GetInputDeclarationFromType(m_currentPrecisionType, AvailableSurfaceInputs.VIEW_DIR);
dataCollector.AddToInput(UniqueId, inputViewDirTan, true);
viewDirTan = Constants.InputVarStr + "." + UIUtils.GetInputValueFromType(AvailableSurfaceInputs.VIEW_DIR);
}
}
else
{
viewDirTan = m_viewdirTanPort.GenerateShaderForOutput(ref dataCollector, WirePortDataType.FLOAT3, false, true);
}
//generate world normal
string normalWorld = string.Empty;
if (dataCollector.IsTemplate)
{
normalWorld = dataCollector.TemplateDataCollectorInstance.GetWorldNormal();
}
else
{
dataCollector.AddToInput(UniqueId, UIUtils.GetInputDeclarationFromType(m_currentPrecisionType, AvailableSurfaceInputs.WORLD_NORMAL), true);
dataCollector.AddToInput(UniqueId, Constants.InternalData, 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, UIUtils.GetInputDeclarationFromType(PrecisionType.Float, AvailableSurfaceInputs.WORLD_POS), true);
worldPos = Constants.InputVarStr + ".worldPos";
}
dataCollector.AddToLocalVariables(UniqueId, m_currentPrecisionType, WirePortDataType.FLOAT3, WorldDirVarStr, string.Format("normalize( UnityWorldSpaceViewDir( {0} ) )", worldPos));
//dataCollector.AddToInput( m_uniqueId, string.Format( WorldDirVarDecStr, UIUtils.FinalPrecisionWirePortToCgType( m_currentPrecisionType, WirePortDataType.FLOAT3 ), WorldDirVarStr ), false );
//dataCollector.AddVertexInstruction( WorldDirVarDefStr, m_uniqueId );
string dx = "ddx(" + textcoords + ")";
string dy = "ddx(" + 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;
dataCollector.AddToUniforms(UniqueId, "uniform float4 " + texture + "_ST;");
string arrayIndex = m_arrayIndexPort.GeneratePortInstructions(ref dataCollector);
if (m_useTextureArray)
{
dataCollector.UsingArrayDerivatives = true;
}
string functionResult = dataCollector.AddFunctions(m_functionHeader, m_functionBody, (m_useTextureArray ? "UNITY_PASS_TEX2DARRAY(" + texture + ")": texture), textcoords, dx, dy, normalWorld, WorldDirVarStr, viewDirTan, m_minSamples, m_maxSamples, scale, refPlane, texture + "_ST.xy", curvature, arrayIndex);
dataCollector.AddToLocalVariables(UniqueId, m_currentPrecisionType, m_pomUVPort.DataType, localVarName, functionResult);
return(GetOutputVectorItem(0, outputId, localVarName));
}
public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar)
{
if (dataCollector.IsTemplate)
{
return("0");
}
if (dataCollector.IsFragmentCategory)
{
UIUtils.ShowMessage(ErrorMessage);
return("0");
}
if (m_outputPorts[0].IsLocalValue(dataCollector.PortCategory))
{
return("0");
}
m_outputPorts[0].SetLocalValue("0", dataCollector.PortCategory);
StandardSurfaceOutputNode masterNode = m_containerGraph.CurrentMasterNode as StandardSurfaceOutputNode;
MasterNodeDataCollector outlineDataCollector = new MasterNodeDataCollector();
outlineDataCollector.IsOutlineDataCollector = true;
outlineDataCollector.DirtyNormal = true;
InputPort colorPort = GetInputPortByUniqueId(0);
InputPort alphaPort = GetInputPortByUniqueId(2);
InputPort vertexPort = GetInputPortByUniqueId(1);
if (vertexPort.IsConnected)
{
outlineDataCollector.PortCategory = MasterNodePortCategory.Vertex;
string outlineWidth = vertexPort.GenerateShaderForOutput(ref outlineDataCollector, vertexPort.DataType, true, true);
outlineDataCollector.AddToVertexLocalVariables(UniqueId, PrecisionType.Float, vertexPort.DataType, "outlineVar", outlineWidth);
outlineDataCollector.AddVertexInstruction(outlineDataCollector.SpecialLocalVariables, UniqueId, false);
outlineDataCollector.ClearSpecialLocalVariables();
outlineDataCollector.AddVertexInstruction(outlineDataCollector.VertexLocalVariables, UniqueId, false);
outlineDataCollector.ClearVertexLocalVariables();
// need to check whether this breaks other outputs or not
ContainerGraph.ResetNodesLocalVariables();
}
outlineDataCollector.PortCategory = MasterNodePortCategory.Fragment;
string outlineColor = colorPort.GeneratePortInstructions(ref outlineDataCollector); // "\to.Emission = " + colorPort.GeneratePortInstructions( ref outlineDataCollector ) + ";";
string alphaValue = alphaPort.Visible ? alphaPort.GeneratePortInstructions(ref outlineDataCollector) : string.Empty;
bool addTabs = outlineDataCollector.DirtySpecialLocalVariables || alphaPort.Available;
outlineDataCollector.AddInstructions("\t" + outlineDataCollector.SpecialLocalVariables.TrimStart('\t'));
outlineDataCollector.ClearSpecialLocalVariables();
outlineDataCollector.AddInstructions((addTabs ? "\t\t\t" : "") + "o.Emission = " + outlineColor + ";");
if (alphaPort.Visible)
{
if (m_currentAlphaMode == OutlineAlphaModes.Masked)
{
float maskClipValue = 0.5f;
if (masterNode != null)
{
maskClipValue = masterNode.OpacityMaskClipValue;
}
if (masterNode.InlineOpacityMaskClipValue.IsValid)
{
RangedFloatNode fnode = UIUtils.GetNode(masterNode.InlineOpacityMaskClipValue.NodeId) as RangedFloatNode;
if (fnode != null)
{
outlineDataCollector.AddToProperties(fnode.UniqueId, fnode.GetPropertyValue(), fnode.OrderIndex);
outlineDataCollector.AddToUniforms(fnode.UniqueId, fnode.GetUniformValue());
}
else
{
IntNode inode = UIUtils.GetNode(masterNode.InlineOpacityMaskClipValue.NodeId) as IntNode;
outlineDataCollector.AddToProperties(inode.UniqueId, inode.GetPropertyValue(), inode.OrderIndex);
outlineDataCollector.AddToUniforms(inode.UniqueId, inode.GetUniformValue());
}
}
else
{
outlineDataCollector.AddToProperties(-1, string.Format(IOUtils.MaskClipValueProperty, OpacityMaskClipValueStr, maskClipValue), -1);
outlineDataCollector.AddToUniforms(-1, string.Format(IOUtils.MaskClipValueUniform, maskClipValue));
}
outlineDataCollector.AddInstructions((addTabs ? "\n\t\t\t" : "") + "clip( " + alphaValue + " - " + masterNode.InlineOpacityMaskClipValue.GetValueOrProperty(IOUtils.MaskClipValueName, false) + " );");
}
else
{
outlineDataCollector.AddInstructions((addTabs ? "\n\t\t\t" : "") + "o.Alpha = " + alphaValue + ";");
}
}
if (outlineDataCollector.UsingWorldNormal)
{
outlineDataCollector.AddInstructions((addTabs ? "\n\t\t\t" : "") + "o.Normal = float3(0,0,-1);");
}
if (masterNode != null)
{
//masterNode.AdditionalIncludes.AddToDataCollector( ref outlineDataCollector );
//masterNode.AdditionalPragmas.AddToDataCollector( ref outlineDataCollector );
//masterNode.AdditionalDefines.AddToDataCollector( ref outlineDataCollector );
masterNode.AdditionalDirectives.AddAllToDataCollector(ref outlineDataCollector);
}
ContainerGraph.CurrentStandardSurface.OutlineHelper.InputList = outlineDataCollector.InputList;
ContainerGraph.CurrentStandardSurface.OutlineHelper.Inputs = outlineDataCollector.Inputs;
ContainerGraph.CurrentStandardSurface.OutlineHelper.DirtyInput = outlineDataCollector.DirtyInputs;
ContainerGraph.CurrentStandardSurface.OutlineHelper.Includes = outlineDataCollector.Includes;
ContainerGraph.CurrentStandardSurface.OutlineHelper.Pragmas = outlineDataCollector.Pragmas;
ContainerGraph.CurrentStandardSurface.OutlineHelper.Defines = outlineDataCollector.Defines;
ContainerGraph.CurrentStandardSurface.OutlineHelper.Uniforms = outlineDataCollector.Uniforms;
ContainerGraph.CurrentStandardSurface.OutlineHelper.UniformList = outlineDataCollector.UniformsList;
ContainerGraph.CurrentStandardSurface.OutlineHelper.VertexData = outlineDataCollector.VertexData;
ContainerGraph.CurrentStandardSurface.OutlineHelper.Instructions = outlineDataCollector.Instructions;
ContainerGraph.CurrentStandardSurface.OutlineHelper.Functions = outlineDataCollector.Functions;
ContainerGraph.CurrentStandardSurface.OutlineHelper.LocalFunctions = outlineDataCollector.LocalFunctions;
ContainerGraph.CurrentStandardSurface.OutlineHelper.OutlineCullMode = m_cullMode;
ContainerGraph.CurrentStandardSurface.OutlineHelper.ZTestMode = m_zTestMode;
ContainerGraph.CurrentStandardSurface.OutlineHelper.ZWriteMode = m_zWriteMode;
ContainerGraph.CurrentStandardSurface.OutlineHelper.OffsetMode = m_currentSelectedMode;
ContainerGraph.CurrentStandardSurface.OutlineHelper.CustomNoFog = m_noFog;
dataCollector.CustomOutlineSelectedAlpha = (int)m_currentAlphaMode;
for (int i = 0; i < outlineDataCollector.PropertiesList.Count; i++)
{
dataCollector.AddToProperties(UniqueId, outlineDataCollector.PropertiesList[i].PropertyName, outlineDataCollector.PropertiesList[i].OrderIndex);
}
ContainerGraph.ResetNodesLocalVariablesIfNot(MasterNodePortCategory.Vertex);
return("0");
}
public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalVar)
{
if (dataCollector.PortCategory == MasterNodePortCategory.Tessellation)
{
UIUtils.ShowMessage(m_nodeAttribs.Name + " cannot be used on Master Node Tessellation port");
return("-1");
}
//bool isVertex = ( dataCollector.PortCategory == MasterNodePortCategory.Vertex || dataCollector.PortCategory == MasterNodePortCategory.Tessellation );
string tiling = string.Empty;
string offset = string.Empty;
string portProperty = string.Empty;
if (m_texPort.IsConnected)
{
portProperty = m_texPort.GeneratePortInstructions(ref dataCollector);
}
if (m_referenceArrayId > -1)
{
TexturePropertyNode temp = UIUtils.GetTexturePropertyNode(m_referenceArrayId);
if (temp != null)
{
portProperty = temp.BaseGenerateShaderForOutput(outputId, ref dataCollector, ignoreLocalVar);
}
}
//TEMPLATES
if (dataCollector.MasterNodeCategory == AvailableShaderTypes.Template)
{
if (m_outputPorts[0].IsLocalValue(dataCollector.PortCategory))
{
return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue(dataCollector.PortCategory)));
}
string uvName = string.Empty;
if (dataCollector.TemplateDataCollectorInstance.HasUV(m_textureCoordChannel))
{
uvName = dataCollector.TemplateDataCollectorInstance.GetUVName(m_textureCoordChannel, m_outputPorts[0].DataType);
}
else
{
uvName = dataCollector.TemplateDataCollectorInstance.RegisterUV(m_textureCoordChannel, m_outputPorts[0].DataType);
}
string currPropertyName = GetValidPropertyName();
if (!string.IsNullOrEmpty(portProperty) && portProperty != "0.0")
{
currPropertyName = portProperty;
}
if (!string.IsNullOrEmpty(currPropertyName))
{
string finalTexCoordName = "uv" + currPropertyName;
string dummyPropertyTexcoords = currPropertyName + "_ST";
dataCollector.AddToUniforms(UniqueId, "float4", dummyPropertyTexcoords);
if (m_texcoordSize > 2)
{
dataCollector.AddLocalVariable(UniqueId, m_currentPrecisionType, m_outputPorts[0].DataType, finalTexCoordName, uvName);
dataCollector.AddLocalVariable(UniqueId, finalTexCoordName + ".xy", string.Format(Constants.TilingOffsetFormat, uvName + ".xy", dummyPropertyTexcoords + ".xy", dummyPropertyTexcoords + ".zw") + ";");
m_outputPorts[0].SetLocalValue(finalTexCoordName, dataCollector.PortCategory);
}
else
{
RegisterLocalVariable(0, string.Format(Constants.TilingOffsetFormat, uvName, dummyPropertyTexcoords + ".xy", dummyPropertyTexcoords + ".zw"), ref dataCollector, finalTexCoordName);
}
//RegisterLocalVariable( 0, string.Format( Constants.TilingOffsetFormat, uvName, dummyPropertyTexcoords+".xy", dummyPropertyTexcoords+".zw" ), ref dataCollector, finalTexCoordName );
}
else
{
string finalTexCoordName = "uv" + OutputId;
tiling = m_tilingPort.GeneratePortInstructions(ref dataCollector);
offset = m_offsetPort.GeneratePortInstructions(ref dataCollector);
if (m_texcoordSize > 2)
{
dataCollector.AddLocalVariable(UniqueId, m_currentPrecisionType, m_outputPorts[0].DataType, finalTexCoordName, uvName);
dataCollector.AddLocalVariable(UniqueId, finalTexCoordName + ".xy", string.Format(Constants.TilingOffsetFormat, uvName + ".xy", tiling, offset) + ";");
m_outputPorts[0].SetLocalValue(finalTexCoordName, dataCollector.PortCategory);
}
else
{
RegisterLocalVariable(0, string.Format(Constants.TilingOffsetFormat, uvName, tiling, offset), ref dataCollector, finalTexCoordName);
}
//RegisterLocalVariable( 0, string.Format( Constants.TilingOffsetFormat, uvName, tiling, offset ), ref dataCollector, finalTexCoordName );
}
return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue(dataCollector.PortCategory)));
}
//SURFACE
string propertyName = GetValidPropertyName();
if (!string.IsNullOrEmpty(portProperty) && portProperty != "0.0")
{
propertyName = portProperty;
}
if (m_outputPorts[0].IsLocalValue(dataCollector.PortCategory))
{
return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue(dataCollector.PortCategory)));
}
if (!m_tilingPort.IsConnected && m_tilingPort.Vector2InternalData == Vector2.one)
{
tiling = null;
}
else
{
tiling = m_tilingPort.GeneratePortInstructions(ref dataCollector);
}
if (!m_offsetPort.IsConnected && m_offsetPort.Vector2InternalData == Vector2.zero)
{
offset = null;
}
else
{
offset = m_offsetPort.GeneratePortInstructions(ref dataCollector);
}
if (!string.IsNullOrEmpty(propertyName) /*m_referenceArrayId > -1*/)
{
m_surfaceTexcoordName = GeneratorUtils.GenerateAutoUVs(ref dataCollector, UniqueId, m_textureCoordChannel, propertyName, m_outputPorts[0].DataType, tiling, offset, OutputId);
}
else
{
m_surfaceTexcoordName = GeneratorUtils.GenerateAutoUVs(ref dataCollector, UniqueId, m_textureCoordChannel, null, m_outputPorts[0].DataType, tiling, offset, OutputId);
}
m_outputPorts[0].SetLocalValue(m_surfaceTexcoordName, dataCollector.PortCategory);
return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue(dataCollector.PortCategory)));
}
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" + OutputId;
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));
}
public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar)
{
if (m_outputPorts[0].IsLocalValue)
{
return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue));
}
OnPropertyNameChanged();
CheckReference();
bool isVertex = (dataCollector.PortCategory == MasterNodePortCategory.Vertex || dataCollector.PortCategory == MasterNodePortCategory.Tessellation);
bool instanced = false;
if (m_referenceType == TexReferenceType.Instance && m_referenceSampler != null)
{
instanced = true;
}
if (!instanced)
{
base.GenerateShaderForOutput(outputId, ref dataCollector, ignoreLocalvar);
}
string level = string.Empty;
if (m_lodPort.Visible)
{
level = m_lodPort.GeneratePortInstructions(ref dataCollector);
}
if (isVertex && !m_lodPort.Visible)
{
level = "0";
}
string uvs = string.Empty;
if (m_uvPort.IsConnected)
{
uvs = m_uvPort.GeneratePortInstructions(ref dataCollector);
}
else
{
if (isVertex)
{
uvs = TexCoordVertexDataNode.GenerateVertexUVs(ref dataCollector, UniqueId, m_uvSet, (instanced ? m_referenceSampler.PropertyName : PropertyName));
}
else
{
uvs = TexCoordVertexDataNode.GenerateFragUVs(ref dataCollector, UniqueId, m_uvSet, (instanced ? m_referenceSampler.PropertyName : PropertyName));
}
}
string index = m_indexPort.GeneratePortInstructions(ref dataCollector);
int connectionNumber = 0;
for (int i = 0; i < m_outputPorts.Count; i++)
{
connectionNumber += m_outputPorts[i].ConnectionCount;
}
string propertyName = string.Empty;
if (!instanced)
{
propertyName = PropertyName;
}
else
{
propertyName = m_referenceSampler.PropertyName;
}
string m_normalMapUnpackMode = "";
if (m_autoUnpackNormals)
{
bool isScaledNormal = false;
if (m_normalPort.IsConnected)
{
isScaledNormal = true;
}
else
{
if (m_normalPort.FloatInternalData != 1)
{
isScaledNormal = true;
}
}
if (isScaledNormal)
{
string scaleValue = m_normalPort.GeneratePortInstructions(ref dataCollector);
dataCollector.AddToIncludes(UniqueId, Constants.UnityStandardUtilsLibFuncs);
m_normalMapUnpackMode = "UnpackScaleNormal( {0} ," + scaleValue + " )";
}
else
{
m_normalMapUnpackMode = "UnpackNormal( {0} )";
}
}
string result = "UNITY_SAMPLE_TEX2DARRAY" + (m_lodPort.Visible || isVertex ? "_LOD" : "") + "(" + propertyName + ", float3(" + uvs + ", " + index + ") " + (m_lodPort.Visible || isVertex ? ", " + level : "") + " )";
if (m_autoUnpackNormals)
{
result = string.Format(m_normalMapUnpackMode, result);
}
//if ( connectionNumber > 1 )
//{
RegisterLocalVariable(0, result, ref dataCollector, "texArray" + OutputId);
//dataCollector.AddToLocalVariables( UniqueId, "float" + ( m_autoUnpackNormals ? "3" : "4" ) + " texArray" + m_uniqueId + " = " + result + ";" );
return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue));
//}
//else
//{
// return GetOutputVectorItem( 0, outputId, result );
//}
}
public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalVar)
{
if (m_outputPorts[0].IsLocalValue(dataCollector.PortCategory))
{
return(m_outputPorts[0].LocalValue(dataCollector.PortCategory));
}
GeneratePattern(ref dataCollector);
if (!(dataCollector.IsTemplate && dataCollector.IsSRP))
{
dataCollector.AddToIncludes(UniqueId, Constants.UnityShaderVariables);
}
string varName = string.Empty;
bool isFragment = dataCollector.IsFragmentCategory;
if (m_customScreenPos && m_inputPorts[2].IsConnected)
{
varName = "ditherCustomScreenPos" + OutputId;
string customScreenPosVal = m_inputPorts[2].GeneratePortInstructions(ref dataCollector);
dataCollector.AddLocalVariable(UniqueId, CurrentPrecisionType, WirePortDataType.FLOAT4, varName, customScreenPosVal);
}
else
{
if (dataCollector.TesselationActive && isFragment)
{
varName = GeneratorUtils.GenerateClipPositionOnFrag(ref dataCollector, UniqueId, CurrentPrecisionType);
}
else
{
if (dataCollector.IsTemplate)
{
varName = dataCollector.TemplateDataCollectorInstance.GetScreenPosNormalized(CurrentPrecisionType);
}
else
{
varName = GeneratorUtils.GenerateScreenPositionNormalized(ref dataCollector, UniqueId, CurrentPrecisionType, !dataCollector.UsingCustomScreenPos);
}
}
}
string surfInstruction = varName + ".xy * _ScreenParams.xy";
m_showErrorMessage = false;
string functionResult = "";
string noiseTex = string.Empty;
switch (m_selectedPatternInt)
{
default:
case 0:
dataCollector.AddLocalVariable(UniqueId, CurrentPrecisionType, WirePortDataType.FLOAT2, "clipScreen" + OutputId, surfInstruction);
functionResult = dataCollector.AddFunctions(m_functionHeader, m_functionBody, "fmod(" + "clipScreen" + OutputId + ".x, 4)", "fmod(" + "clipScreen" + OutputId + ".y, 4)");
break;
case 1:
dataCollector.AddLocalVariable(UniqueId, CurrentPrecisionType, WirePortDataType.FLOAT2, "clipScreen" + OutputId, surfInstruction);
functionResult = dataCollector.AddFunctions(m_functionHeader, m_functionBody, "fmod(" + "clipScreen" + OutputId + ".x, 8)", "fmod(" + "clipScreen" + OutputId + ".y, 8)");
break;
case 2:
{
if (!m_texPort.IsConnected)
{
m_showErrorMessage = true;
m_errorMessageTypeIsError = NodeMessageType.Warning;
m_errorMessageTooltip = "Please connect a texture object to the Pattern input port to generate a proper dithered pattern";
return("0");
}
else
{
ParentGraph outsideGraph = UIUtils.CurrentWindow.OutsideGraph;
noiseTex = m_texPort.GeneratePortInstructions(ref dataCollector);
//GeneratePattern( ref dataCollector );
dataCollector.AddToUniforms(UniqueId, "float4 " + noiseTex + "_TexelSize;", dataCollector.IsSRP);
#if UNITY_2018_1_OR_NEWER
if (outsideGraph.SamplingMacros)
#else
if (outsideGraph.SamplingMacros && !outsideGraph.IsStandardSurface)
#endif
{
string sampler = string.Empty;
if (m_ssPort.IsConnected)
{
sampler = m_ssPort.GeneratePortInstructions(ref dataCollector);
}
else
{
sampler = GeneratorUtils.GenerateSamplerState(ref dataCollector, UniqueId, noiseTex);
}
//if( outsideGraph.IsSRP )
// functionResult = dataCollector.AddFunctions( m_functionHeader, m_functionBody, varName, noiseTex + ", " + sampler, noiseTex + "_TexelSize" );
//else
functionResult = dataCollector.AddFunctions(m_functionHeader, m_functionBody, varName, noiseTex + ", " + sampler, noiseTex + "_TexelSize");
}
else
{
functionResult = dataCollector.AddFunctions(m_functionHeader, m_functionBody, varName, noiseTex, noiseTex + "_TexelSize");
}
}
}
break;
}
dataCollector.AddLocalVariable(UniqueId, CurrentPrecisionType, WirePortDataType.FLOAT, "dither" + OutputId, functionResult);
if (m_inputPorts[0].IsConnected)
{
string driver = m_inputPorts[0].GeneratePortInstructions(ref dataCollector);
dataCollector.AddLocalVariable(UniqueId, "dither" + OutputId + " = step( dither" + OutputId + ", " + driver + " );");
}
//RegisterLocalVariable( 0, functionResult, ref dataCollector, "dither" + OutputId );
m_outputPorts[0].SetLocalValue("dither" + OutputId, dataCollector.PortCategory);
return(m_outputPorts[0].LocalValue(dataCollector.PortCategory));
}
public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalVar)
{
if (dataCollector.PortCategory == MasterNodePortCategory.Tessellation)
{
UIUtils.ShowMessage(m_nodeAttribs.Name + " cannot be used on Master Node Tessellation port");
return("-1");
}
bool isVertex = (dataCollector.PortCategory == MasterNodePortCategory.Vertex || dataCollector.PortCategory == MasterNodePortCategory.Tessellation);
if (m_texPort.IsConnected)
{
m_texPort.GeneratePortInstructions(ref dataCollector);
}
string propertyName = GetValidPropertyName();
if (!string.IsNullOrEmpty(propertyName) /*m_referenceArrayId > -1*/)
{
//m_referenceNode = UIUtils.GetTexturePropertyNode( m_referenceArrayId );
//if ( m_referenceNode != null )
//{
//string propertyName = m_referenceNode.PropertyName;
int coordSet = ((m_textureCoordChannel < 0) ? 0 : m_textureCoordChannel);
string uvName = string.Empty;
string dummyPropUV = "_tex" + (m_texcoordSize > 2 ? "" + m_texcoordSize : "") + "coord" + (coordSet > 0 ? (coordSet + 1).ToString() : "");
string dummyUV = "uv" + (coordSet > 0 ? (coordSet + 1).ToString() : "") + dummyPropUV;
if (isVertex)
{
uvName = IOUtils.GetUVChannelName(propertyName, coordSet);
string vertexInput = Constants.VertexShaderInputStr + ".texcoord";
if (coordSet > 0)
{
vertexInput += coordSet.ToString();
}
dataCollector.AddToVertexLocalVariables(UniqueId, "float" + m_texcoordSize + " " + uvName + " = " + vertexInput + ";");
dataCollector.AddToVertexLocalVariables(UniqueId, uvName + ".xy = " + vertexInput + ".xy * " + propertyName + "_ST.xy + " + propertyName + "_ST.zw;");
}
else
{
uvName = IOUtils.GetUVChannelName(propertyName, coordSet);
if (m_texcoordSize > 2)
{
uvName += m_texcoordSize;
dataCollector.UsingHigherSizeTexcoords = true;
dataCollector.AddToLocalVariables(UniqueId, "float" + m_texcoordSize + " " + uvName + " = " + Constants.InputVarStr + "." + dummyUV + ";");
dataCollector.AddToLocalVariables(UniqueId, uvName + ".xy = " + Constants.InputVarStr + "." + dummyUV + ".xy * " + propertyName + "_ST.xy + " + propertyName + "_ST.zw;");
}
else
{
dataCollector.AddToLocalVariables(UniqueId, PrecisionType.Float, WirePortDataType.FLOAT2, uvName, Constants.InputVarStr + "." + dummyUV + " * " + propertyName + "_ST.xy + " + propertyName + "_ST.zw");
}
}
dataCollector.AddToUniforms(UniqueId, "uniform float4 " + propertyName + "_ST;");
dataCollector.AddToProperties(UniqueId, "[HideInInspector] " + dummyPropUV + "( \"\", 2D ) = \"white\" {}", 100);
dataCollector.AddToInput(UniqueId, "float" + m_texcoordSize + " " + dummyUV, true);
return(GetOutputVectorItem(0, outputId, uvName));
//}
}
if (m_texcoordId < 0)
{
if (!isVertex && dataCollector.TesselationActive)
{
return(GenerateFragShaderForOutput(outputId, ref dataCollector, ignoreLocalVar));
}
bool tessVertexMode = isVertex && dataCollector.TesselationActive;
m_texcoordId = dataCollector.AvailableUvIndex;
string texcoordName = TexCoordStr + m_texcoordId;
string uvChannel = m_textureCoordChannel == 0 ? ".xy" : m_textureCoordChannel + ".xy";
MasterNodePortCategory portCategory = dataCollector.PortCategory;
if (dataCollector.PortCategory != MasterNodePortCategory.Vertex && dataCollector.PortCategory != MasterNodePortCategory.Tessellation)
{
dataCollector.PortCategory = MasterNodePortCategory.Vertex;
}
// We need to reset local variables if there are already created to force them to be created in the vertex function
int buffer = m_texcoordId;
ContainerGraph.ResetNodesLocalVariables(this);
bool dirtySpecialVarsBefore = dataCollector.DirtySpecialLocalVariables;
bool dirtyVertexVarsBefore = dataCollector.DirtyVertexVariables;
string tiling = m_tilingPort.GenerateShaderForOutput(ref dataCollector, WirePortDataType.FLOAT2, false, true);
string offset = m_offsetPort.GenerateShaderForOutput(ref dataCollector, WirePortDataType.FLOAT2, false, true);
dataCollector.PortCategory = portCategory;
string vertexUV = Constants.VertexShaderInputStr + ".texcoord" + uvChannel;
if (!tessVertexMode)
{
dataCollector.AddToInput(UniqueId, "float" + m_texcoordSize + " " + texcoordName, true);
}
bool resetLocals = false;
// new texture coordinates are calculated on the vertex shader so we need to register its local vars
if (!dirtySpecialVarsBefore && dataCollector.DirtySpecialLocalVariables)
{
dataCollector.AddVertexInstruction(UIUtils.CurrentDataCollector.SpecialLocalVariables, UniqueId, false);
UIUtils.CurrentDataCollector.ClearSpecialLocalVariables();
resetLocals = true;
}
if (!dirtyVertexVarsBefore && dataCollector.DirtyVertexVariables)
{
dataCollector.AddVertexInstruction(UIUtils.CurrentDataCollector.VertexLocalVariables, UniqueId, false);
UIUtils.CurrentDataCollector.ClearVertexLocalVariables();
resetLocals = true;
}
//Reset local variables again so they wont be caught on the fragment shader
if (resetLocals)
{
ContainerGraph.ResetNodesLocalVariables(this);
}
if (tessVertexMode)
{
dataCollector.AddVertexInstruction(vertexUV + " = " + vertexUV + " * " + tiling + " + " + offset, UniqueId);
m_surfaceTexcoordName = Constants.VertexShaderInputStr + "." + IOUtils.GetVertexUVChannelName(m_textureCoordChannel) + ".xy";
}
else
{
if (dataCollector.TesselationActive)
{
if (isVertex)
{
dataCollector.AddVertexInstruction(vertexUV + " = " + vertexUV + " * " + tiling + " + " + offset, UniqueId);
m_surfaceTexcoordName = Constants.VertexShaderOutputStr + "." + texcoordName;
}
else
{
dataCollector.AddToProperties(UniqueId, DummyPropertyDec + " {}", -1);
dataCollector.AddToUniforms(UniqueId, DummyUniformDec);
string texCoordPrefix = (m_textureCoordChannel == 0) ? string.Empty : (m_textureCoordChannel + 1).ToString();
dataCollector.AddToInput(UniqueId, "float2 " + string.Format(DummyTexCoordDef, texCoordPrefix), true);
dataCollector.AddToSpecialLocalVariables(UniqueId, string.Format(DummyTexCoordSurfDef, OutputId, Constants.InputVarStr, texCoordPrefix, tiling, offset));
m_surfaceTexcoordName = string.Format(DummyTexCoordSurfVar, UniqueId);
}
}
else
{
dataCollector.AddVertexInstruction(Constants.VertexShaderOutputStr + "." + texcoordName + ".xy = " + vertexUV + " * " + tiling + " + " + offset, UniqueId);
m_surfaceTexcoordName = (isVertex ? Constants.VertexShaderOutputStr : Constants.InputVarStr) + "." + texcoordName;
}
}
m_texcoordId = buffer;
}
return(GetOutputVectorItem(0, outputId, m_surfaceTexcoordName));
}
public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar)
{
if (m_outputPorts[0].IsLocalValue(dataCollector.PortCategory))
{
return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue(dataCollector.PortCategory)));
}
OnPropertyNameChanged();
if (CheckReference())
{
OrderIndex = m_referenceSampler.RawOrderIndex;
OrderIndexOffset = m_referenceSampler.OrderIndexOffset;
}
bool isVertex = (dataCollector.PortCategory == MasterNodePortCategory.Vertex || dataCollector.PortCategory == MasterNodePortCategory.Tessellation);
bool instanced = false;
if (m_referenceType == TexReferenceType.Instance && m_referenceSampler != null)
{
instanced = true;
}
if (instanced)
{
if (!m_referenceSampler.TexPort.IsConnected)
{
base.GenerateShaderForOutput(outputId, ref dataCollector, ignoreLocalvar);
}
}
else if (!m_texPort.IsConnected)
{
base.GenerateShaderForOutput(outputId, ref dataCollector, ignoreLocalvar);
}
string level = string.Empty;
if (m_lodPort.Visible)
{
level = m_lodPort.GeneratePortInstructions(ref dataCollector);
}
if (isVertex && !m_lodPort.Visible)
{
level = "0";
}
string propertyName = string.Empty;
if (instanced)
{
if (m_referenceSampler.TexPort.IsConnected)
{
propertyName = m_referenceSampler.TexPort.GeneratePortInstructions(ref dataCollector);
}
else
{
propertyName = m_referenceSampler.PropertyName;
}
}
else if (m_texPort.IsConnected)
{
propertyName = m_texPort.GeneratePortInstructions(ref dataCollector);
}
else
{
propertyName = PropertyName;
}
string uvs = string.Empty;
if (m_uvPort.IsConnected)
{
uvs = m_uvPort.GeneratePortInstructions(ref dataCollector);
}
else
{
if (dataCollector.IsTemplate)
{
uvs = dataCollector.TemplateDataCollectorInstance.GetTextureCoord(m_uvSet, propertyName /*( instanced ? m_referenceSampler.PropertyName : PropertyName )*/, UniqueId, CurrentPrecisionType);
}
else
{
if (isVertex)
{
uvs = TexCoordVertexDataNode.GenerateVertexUVs(ref dataCollector, UniqueId, m_uvSet, propertyName);
}
else
{
uvs = TexCoordVertexDataNode.GenerateFragUVs(ref dataCollector, UniqueId, m_uvSet, propertyName);
}
}
}
string index = m_indexPort.GeneratePortInstructions(ref dataCollector);
string result = string.Empty;
if (dataCollector.IsTemplate && dataCollector.IsSRP)
{
//CAREFUL mipbias here means derivative (this needs index changes)
//TODO: unity now supports bias as well
if (m_mipMode == MipType.MipBias)
{
dataCollector.UsingArrayDerivatives = true;
result = propertyName + ".SampleGrad(sampler" + propertyName + ", float3(" + uvs + ", " + index + "), " + m_ddxPort.GeneratePortInstructions(ref dataCollector) + ", " + m_ddyPort.GeneratePortInstructions(ref dataCollector) + ");";
}
else if (m_lodPort.Visible || isVertex)
{
result = "SAMPLE_TEXTURE2D_ARRAY_LOD(" + propertyName + ", sampler" + propertyName + ", " + uvs + ", " + index + ", " + level + " )";
}
else
{
result = "SAMPLE_TEXTURE2D_ARRAY(" + propertyName + ", sampler" + propertyName + ", " + uvs + ", " + index + " )";
}
}
else
{
//CAREFUL mipbias here means derivative (this needs index changes)
if (m_mipMode == MipType.MipBias)
{
dataCollector.UsingArrayDerivatives = true;
result = "ASE_SAMPLE_TEX2DARRAY_GRAD(" + propertyName + ", float3(" + uvs + ", " + index + "), " + m_ddxPort.GeneratePortInstructions(ref dataCollector) + ", " + m_ddyPort.GeneratePortInstructions(ref dataCollector) + " )";
}
else if (m_lodPort.Visible || isVertex)
{
result = "UNITY_SAMPLE_TEX2DARRAY_LOD(" + propertyName + ", float3(" + uvs + ", " + index + "), " + level + " )";
}
else
{
result = "UNITY_SAMPLE_TEX2DARRAY" + (m_lodPort.Visible || isVertex ? "_LOD" : "") + "(" + propertyName + ", float3(" + uvs + ", " + index + ") " + (m_lodPort.Visible || isVertex ? ", " + level : "") + " )";
}
}
if (m_autoUnpackNormals)
{
bool isScaledNormal = false;
if (m_normalPort.IsConnected)
{
isScaledNormal = true;
}
else
{
if (m_normalPort.FloatInternalData != 1)
{
isScaledNormal = true;
}
}
string scaleValue = isScaledNormal ? m_normalPort.GeneratePortInstructions(ref dataCollector) : "1.0";
result = GeneratorUtils.GenerateUnpackNormalStr(ref dataCollector, CurrentPrecisionType, UniqueId, OutputId, result, isScaledNormal, scaleValue);
if (isScaledNormal && (!dataCollector.IsTemplate || !dataCollector.IsSRP))
{
dataCollector.AddToIncludes(UniqueId, Constants.UnityStandardUtilsLibFuncs);
}
}
RegisterLocalVariable(0, result, ref dataCollector, "texArray" + OutputId);
return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue(dataCollector.PortCategory)));
}
public override string GenerateShaderForOutput( int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalVar )
{
if( dataCollector.PortCategory == MasterNodePortCategory.Tessellation )
{
UIUtils.ShowMessage( m_nodeAttribs.Name + " cannot be used on Master Node Tessellation port" ):
return "-1":
}
//bool isVertex = ( dataCollector.PortCategory == MasterNodePortCategory.Vertex || dataCollector.PortCategory == MasterNodePortCategory.Tessellation ):
string tiling = string.Empty:
string offset = string.Empty:
string portProperty = string.Empty:
if( m_texPort.IsConnected )
portProperty = m_texPort.GeneratePortInstructions( ref dataCollector ):
if( m_referenceArrayId > -1 )
{
TexturePropertyNode temp = UIUtils.GetTexturePropertyNode( m_referenceArrayId ):
if( temp != null )
{
portProperty = temp.BaseGenerateShaderForOutput( outputId, ref dataCollector, ignoreLocalVar ):
}
}
//TEMPLATES
if( dataCollector.MasterNodeCategory == AvailableShaderTypes.Template )
{
if( m_outputPorts[ 0 ].IsLocalValue( dataCollector.PortCategory ) )
return GetOutputVectorItem( 0, outputId, m_outputPorts[ 0 ].LocalValue( dataCollector.PortCategory ) ):
string uvName = string.Empty:
if( dataCollector.TemplateDataCollectorInstance.HasUV( m_textureCoordChannel ) )
{
uvName = dataCollector.TemplateDataCollectorInstance.GetUVName( m_textureCoordChannel, m_outputPorts[ 0 ].DataType ):
}
else
{
uvName = dataCollector.TemplateDataCollectorInstance.RegisterUV( m_textureCoordChannel, m_outputPorts[ 0 ].DataType ):
}
string currPropertyName = GetValidPropertyName():
if( !string.IsNullOrEmpty( portProperty ) && portProperty != "0.0" )
{
currPropertyName = portProperty:
}
if( !string.IsNullOrEmpty( currPropertyName ) )
{
string finalTexCoordName = "uv" + m_textureCoordChannel + currPropertyName:
string dummyPropertyTexcoords = currPropertyName + "_ST":
if( m_texCoordsHelper == null )
{
m_texCoordsHelper = CreateInstance<Vector4Node>():
m_texCoordsHelper.ContainerGraph = ContainerGraph:
m_texCoordsHelper.SetBaseUniqueId( UniqueId, true ):
m_texCoordsHelper.RegisterPropertyOnInstancing = false:
}
if( UIUtils.CurrentWindow.OutsideGraph.IsInstancedShader )
{
m_texCoordsHelper.CurrentParameterType = PropertyType.InstancedProperty:
}
else
{
m_texCoordsHelper.CurrentParameterType = PropertyType.Global:
}
m_texCoordsHelper.ResetOutputLocals():
m_texCoordsHelper.SetRawPropertyName( dummyPropertyTexcoords ):
dummyPropertyTexcoords = m_texCoordsHelper.GenerateShaderForOutput( 0, ref dataCollector, false ):
if( m_texcoordSize > 2 )
{
dataCollector.AddLocalVariable( UniqueId, m_currentPrecisionType, m_outputPorts[ 0 ].DataType, finalTexCoordName, uvName ):
dataCollector.AddLocalVariable( UniqueId, finalTexCoordName + ".xy", string.Format( Constants.TilingOffsetFormat, uvName + ".xy", dummyPropertyTexcoords + ".xy", dummyPropertyTexcoords + ".zw" ) + ":" ):
m_outputPorts[ 0 ].SetLocalValue( finalTexCoordName, dataCollector.PortCategory ):
}
else
{
RegisterLocalVariable( 0, string.Format( Constants.TilingOffsetFormat, uvName, dummyPropertyTexcoords + ".xy", dummyPropertyTexcoords + ".zw" ), ref dataCollector, finalTexCoordName ):
}
//RegisterLocalVariable( 0, string.Format( Constants.TilingOffsetFormat, uvName, dummyPropertyTexcoords+".xy", dummyPropertyTexcoords+".zw" ), ref dataCollector, finalTexCoordName ):
}
else
{
string finalTexCoordName = "uv" + m_textureCoordChannel + OutputId:
tiling = m_tilingPort.GeneratePortInstructions( ref dataCollector ):
offset = m_offsetPort.GeneratePortInstructions( ref dataCollector ):
if( m_texcoordSize > 2 )
{
dataCollector.AddLocalVariable( UniqueId, m_currentPrecisionType, m_outputPorts[ 0 ].DataType, finalTexCoordName, uvName ):
dataCollector.AddLocalVariable( UniqueId, finalTexCoordName + ".xy", string.Format( Constants.TilingOffsetFormat, uvName + ".xy", tiling, offset ) + ":" ):
m_outputPorts[ 0 ].SetLocalValue( finalTexCoordName, dataCollector.PortCategory ):
}
else
{
RegisterLocalVariable( 0, string.Format( Constants.TilingOffsetFormat, uvName, tiling, offset ), ref dataCollector, finalTexCoordName ):
}
//RegisterLocalVariable( 0, string.Format( Constants.TilingOffsetFormat, uvName, tiling, offset ), ref dataCollector, finalTexCoordName ):
}
return GetOutputVectorItem( 0, outputId, m_outputPorts[ 0 ].LocalValue( dataCollector.PortCategory ) ):
}
//SURFACE
string propertyName = GetValidPropertyName():
if( !string.IsNullOrEmpty( portProperty ) && portProperty != "0.0" )
{
propertyName = portProperty:
}
if( m_outputPorts[ 0 ].IsLocalValue( dataCollector.PortCategory ) )
return GetOutputVectorItem( 0, outputId, m_outputPorts[ 0 ].LocalValue( dataCollector.PortCategory ) ):
if( !m_tilingPort.IsConnected && m_tilingPort.Vector2InternalData == Vector2.one )
tiling = null:
else
tiling = m_tilingPort.GeneratePortInstructions( ref dataCollector ):
if( !m_offsetPort.IsConnected && m_offsetPort.Vector2InternalData == Vector2.zero )
offset = null:
else
offset = m_offsetPort.GeneratePortInstructions( ref dataCollector ):
if( !string.IsNullOrEmpty( propertyName ) /*m_referenceArrayId > -1*/ )
{
m_surfaceTexcoordName = GeneratorUtils.GenerateAutoUVs( ref dataCollector, UniqueId, m_textureCoordChannel, propertyName, m_outputPorts[ 0 ].DataType, tiling, offset, OutputId ):
}
else
{
m_surfaceTexcoordName = GeneratorUtils.GenerateAutoUVs( ref dataCollector, UniqueId, m_textureCoordChannel, null, m_outputPorts[ 0 ].DataType, tiling, offset, OutputId ):
}
m_outputPorts[ 0 ].SetLocalValue( m_surfaceTexcoordName, dataCollector.PortCategory ):
return GetOutputVectorItem( 0, outputId, m_outputPorts[ 0 ].LocalValue( dataCollector.PortCategory ) ):
}
public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalVar)
{
if (dataCollector.PortCategory == MasterNodePortCategory.Tessellation)
{
UIUtils.ShowMessage(m_nodeAttribs.Name + " cannot be used on Master Node Tessellation port");
return("-1");
}
//bool isVertex = ( dataCollector.PortCategory == MasterNodePortCategory.Vertex || dataCollector.PortCategory == MasterNodePortCategory.Tessellation );
string tiling = string.Empty;
string offset = string.Empty;
string portProperty = string.Empty;
if (m_texPort.IsConnected)
{
portProperty = m_texPort.GenerateShaderForOutput(ref dataCollector, m_texPort.DataType, ignoreLocalVar);
}
if (m_referenceArrayId > -1)
{
TexturePropertyNode temp = UIUtils.GetTexturePropertyNode(m_referenceArrayId);
if (temp != null)
{
portProperty = temp.BaseGenerateShaderForOutput(outputId, ref dataCollector, ignoreLocalVar);
}
}
//TEMPLATES
if (dataCollector.MasterNodeCategory == AvailableShaderTypes.Template)
{
if (m_outputPorts[0].IsLocalValue)
{
return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue));
}
string uvName = string.Empty;
if (dataCollector.TemplateDataCollectorInstance.HasUV(m_textureCoordChannel))
{
uvName = dataCollector.TemplateDataCollectorInstance.GetUVName(m_textureCoordChannel);
}
else
{
uvName = dataCollector.TemplateDataCollectorInstance.RegisterUV(m_textureCoordChannel);
//string uvName = TemplateHelperFunctions.GenerateTextureSemantic( ref dataCollector, m_textureCoordChannel );
//uvName = ( dataCollector.IsFragmentCategory ? Constants.InputVarStr : Constants.VertexShaderInputStr ) + "." + uvName;
}
string currPropertyName = GetValidPropertyName();
if (!string.IsNullOrEmpty(portProperty) && portProperty != "0.0")
{
currPropertyName = portProperty;
}
if (!string.IsNullOrEmpty(currPropertyName))
{
string finalTexCoordName = "uv" + currPropertyName;
string dummyPropertyTexcoords = currPropertyName + "_ST";
dataCollector.AddToUniforms(UniqueId, "float4", dummyPropertyTexcoords);
if (m_texcoordSize > 2)
{
dataCollector.AddLocalVariable(UniqueId, m_currentPrecisionType, m_outputPorts[0].DataType, finalTexCoordName, uvName);
dataCollector.AddLocalVariable(UniqueId, finalTexCoordName + ".xy", string.Format(Constants.TilingOffsetFormat, uvName + ".xy", dummyPropertyTexcoords + ".xy", dummyPropertyTexcoords + ".zw") + ";");
m_outputPorts[0].SetLocalValue(finalTexCoordName);
}
else
{
RegisterLocalVariable(0, string.Format(Constants.TilingOffsetFormat, uvName, dummyPropertyTexcoords + ".xy", dummyPropertyTexcoords + ".zw"), ref dataCollector, finalTexCoordName);
}
//RegisterLocalVariable( 0, string.Format( Constants.TilingOffsetFormat, uvName, dummyPropertyTexcoords+".xy", dummyPropertyTexcoords+".zw" ), ref dataCollector, finalTexCoordName );
}
else
{
string finalTexCoordName = "uv" + OutputId;
tiling = m_tilingPort.GeneratePortInstructions(ref dataCollector);
offset = m_offsetPort.GeneratePortInstructions(ref dataCollector);
if (m_texcoordSize > 2)
{
dataCollector.AddLocalVariable(UniqueId, m_currentPrecisionType, m_outputPorts[0].DataType, finalTexCoordName, uvName);
dataCollector.AddLocalVariable(UniqueId, finalTexCoordName + ".xy", string.Format(Constants.TilingOffsetFormat, uvName + ".xy", tiling, offset) + ";");
m_outputPorts[0].SetLocalValue(finalTexCoordName);
}
else
{
RegisterLocalVariable(0, string.Format(Constants.TilingOffsetFormat, uvName, tiling, offset), ref dataCollector, finalTexCoordName);
}
//RegisterLocalVariable( 0, string.Format( Constants.TilingOffsetFormat, uvName, tiling, offset ), ref dataCollector, finalTexCoordName );
}
return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue));
}
//SURFACE
string propertyName = GetValidPropertyName();
if (!string.IsNullOrEmpty(portProperty) && portProperty != "0.0")
{
propertyName = portProperty;
}
if (m_outputPorts[0].IsLocalValue)
{
return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue));
}
tiling = m_tilingPort.GenerateShaderForOutput(ref dataCollector, WirePortDataType.FLOAT2, false, true);
offset = m_offsetPort.GenerateShaderForOutput(ref dataCollector, WirePortDataType.FLOAT2, false, true);
if (!string.IsNullOrEmpty(propertyName) /*m_referenceArrayId > -1*/)
{
////m_referenceNode = UIUtils.GetTexturePropertyNode( m_referenceArrayId );
////if ( m_referenceNode != null )
////{
////string propertyName = m_referenceNode.PropertyName;
//int coordSet = ( ( m_textureCoordChannel < 0 ) ? 0 : m_textureCoordChannel );
//string uvName = string.Empty;
//string dummyPropUV = "_tex" + ( m_texcoordSize > 2 ? "" + m_texcoordSize : "" ) + "coord" + ( coordSet > 0 ? ( coordSet + 1 ).ToString() : "" );
//string dummyUV = "uv" + ( coordSet > 0 ? ( coordSet + 1 ).ToString() : "" ) + dummyPropUV;
//if ( isVertex )
//{
// uvName = IOUtils.GetUVChannelName( propertyName, coordSet ) + m_texcoordSize.ToString() + coordSet.ToString();
// string vertexInput = Constants.VertexShaderInputStr + ".texcoord";
// if ( coordSet > 0 )
// {
// vertexInput += coordSet.ToString();
// }
// dataCollector.AddToVertexLocalVariables( UniqueId, "float" + m_texcoordSize + " " + uvName + " = " + vertexInput + ";" );
// dataCollector.AddToVertexLocalVariables( UniqueId, uvName + ".xy = " + vertexInput + ".xy * " + propertyName + "_ST.xy + " + propertyName + "_ST.zw;" );
//}
//else
//{
// uvName = IOUtils.GetUVChannelName( propertyName, coordSet );
// if ( m_texcoordSize > 2 )
// {
// uvName += m_texcoordSize;
// dataCollector.UsingHigherSizeTexcoords = true;
// dataCollector.AddToLocalVariables( UniqueId, "float" + m_texcoordSize + " " + uvName + " = " + Constants.InputVarStr + "." + dummyUV + ";" );
// dataCollector.AddToLocalVariables( UniqueId, uvName + ".xy = " + Constants.InputVarStr + "." + dummyUV + ".xy * " + propertyName + "_ST.xy + " + propertyName + "_ST.zw;" );
// }
// else
// {
// dataCollector.AddToLocalVariables( UniqueId, PrecisionType.Float, WirePortDataType.FLOAT2, uvName, Constants.InputVarStr + "." + dummyUV + " * " + propertyName + "_ST.xy + " + propertyName + "_ST.zw" );
// }
//}
//dataCollector.AddToUniforms( UniqueId, "uniform float4 " + propertyName + "_ST;" );
//dataCollector.AddToProperties( UniqueId, "[HideInInspector] " + dummyPropUV + "( \"\", 2D ) = \"white\" {}", 100 );
//dataCollector.AddToInput( UniqueId, "float" + m_texcoordSize + " " + dummyUV, true );
//return GetOutputVectorItem( 0, outputId, uvName );
////}
m_surfaceTexcoordName = GeneratorUtils.GenerateAutoUVs(ref dataCollector, UniqueId, m_textureCoordChannel, propertyName, m_outputPorts[0].DataType, tiling, offset, OutputId);
}
else
{
m_surfaceTexcoordName = GeneratorUtils.GenerateAutoUVs(ref dataCollector, UniqueId, m_textureCoordChannel, null, m_outputPorts[0].DataType, tiling, offset, OutputId);
}
//{
// if ( !isVertex && dataCollector.TesselationActive )
// {
// return GenerateFragShaderForOutput( outputId, ref dataCollector, ignoreLocalVar );
// }
// bool tessVertexMode = isVertex && dataCollector.TesselationActive;
// string texcoordName = TexCoordStr + OutputId;
// string uvChannel = m_textureCoordChannel == 0 ? ".xy" : m_textureCoordChannel + ".xy";
// MasterNodePortCategory portCategory = dataCollector.PortCategory;
// if ( dataCollector.PortCategory != MasterNodePortCategory.Vertex && dataCollector.PortCategory != MasterNodePortCategory.Tessellation )
// dataCollector.PortCategory = MasterNodePortCategory.Vertex;
// // We need to reset local variables if there are already created to force them to be created in the vertex function
// ContainerGraph.ResetNodesLocalVariablesIfNot( this, MasterNodePortCategory.Vertex );
// bool dirtySpecialVarsBefore = dataCollector.DirtySpecialLocalVariables;
// bool dirtyVertexVarsBefore = dataCollector.DirtyVertexVariables;
// string tiling = m_tilingPort.GenerateShaderForOutput( ref dataCollector, WirePortDataType.FLOAT2, false, true );
// string offset = m_offsetPort.GenerateShaderForOutput( ref dataCollector, WirePortDataType.FLOAT2, false, true );
// dataCollector.PortCategory = portCategory;
// string vertexUV = Constants.VertexShaderInputStr + ".texcoord" + uvChannel;
// if ( !tessVertexMode )
// dataCollector.AddToInput( UniqueId, "float" + m_texcoordSize + " " + texcoordName, true );
// bool resetLocals = false;
// // new texture coordinates are calculated on the vertex shader so we need to register its local vars
// if ( !dirtySpecialVarsBefore && dataCollector.DirtySpecialLocalVariables )
// {
// dataCollector.AddVertexInstruction( dataCollector.SpecialLocalVariables, UniqueId, false );
// dataCollector.ClearSpecialLocalVariables();
// resetLocals = true;
// }
// if ( !dirtyVertexVarsBefore && dataCollector.DirtyVertexVariables )
// {
// dataCollector.AddVertexInstruction( dataCollector.VertexLocalVariables, UniqueId, false );
// dataCollector.ClearVertexLocalVariables();
// resetLocals = true;
// }
// //Reset local variables again so they wont be caught on the fragment shader
// if ( resetLocals )
// ContainerGraph.ResetNodesLocalVariablesIfNot( this, MasterNodePortCategory.Vertex );
// if ( tessVertexMode )
// {
// dataCollector.AddToVertexLocalVariables(UniqueId, vertexUV + " = " + vertexUV + " * " + tiling + " + " + offset+";");
// m_surfaceTexcoordName = Constants.VertexShaderInputStr + "." + IOUtils.GetVertexUVChannelName( m_textureCoordChannel ) + ".xy";
// }
// else if( dataCollector.TesselationActive )
// {
// string texCoordPrefix = ( m_textureCoordChannel == 0 ) ? string.Empty : ( m_textureCoordChannel + 1 ).ToString();
// dataCollector.AddToProperties( UniqueId, string.Format( DummyPropertyDec, texCoordPrefix ) + " {}", -1 );
// dataCollector.AddToUniforms( UniqueId, string.Format( DummyUniformDec, texCoordPrefix ) );
// dataCollector.AddToInput( UniqueId, "float2 " + string.Format( DummyTexCoordDef, texCoordPrefix ), true );
// dataCollector.AddToSpecialLocalVariables( UniqueId, string.Format( DummyTexCoordSurfDef, OutputId, Constants.InputVarStr, texCoordPrefix, tiling, offset ) );
// m_surfaceTexcoordName = string.Format( DummyTexCoordSurfVar, OutputId );
// }
// else
// {
// //m_surfaceTexcoordName = GeneratorUtils.GenerateAutoUVs( ref dataCollector, UniqueId, m_textureCoordChannel, null, m_texcoordSize == 2 ? WirePortDataType.FLOAT2 : WirePortDataType.FLOAT3, tiling, offset, OutputId );
// dataCollector.AddToVertexLocalVariables( UniqueId, Constants.VertexShaderOutputStr + "." + texcoordName + ".xy = " + vertexUV + " * " + tiling + " + " + offset + ";" );
// m_surfaceTexcoordName = ( isVertex ? Constants.VertexShaderOutputStr : Constants.InputVarStr ) + "." + texcoordName;
// }
//}
m_outputPorts[0].SetLocalValue(m_surfaceTexcoordName, dataCollector.PortCategory);
return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue));
}
public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar)
{
if (m_outputPorts[0].IsLocalValue)
{
return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue));
}
OnPropertyNameChanged();
CheckReference();
bool isVertex = (dataCollector.PortCategory == MasterNodePortCategory.Vertex || dataCollector.PortCategory == MasterNodePortCategory.Tessellation);
bool instanced = false;
if (m_referenceType == TexReferenceType.Instance && m_referenceSampler != null)
{
instanced = true;
}
if (instanced)
{
if (!m_referenceSampler.TexPort.IsConnected)
{
base.GenerateShaderForOutput(outputId, ref dataCollector, ignoreLocalvar);
}
}
else if (!m_texPort.IsConnected)
{
base.GenerateShaderForOutput(outputId, ref dataCollector, ignoreLocalvar);
}
string level = string.Empty;
if (m_lodPort.Visible)
{
level = m_lodPort.GeneratePortInstructions(ref dataCollector);
}
if (isVertex && !m_lodPort.Visible)
{
level = "0";
}
string propertyName = string.Empty;
if (instanced)
{
if (m_referenceSampler.TexPort.IsConnected)
{
propertyName = m_referenceSampler.TexPort.GeneratePortInstructions(ref dataCollector);
}
else
{
propertyName = m_referenceSampler.PropertyName;
}
}
else if (m_texPort.IsConnected)
{
propertyName = m_texPort.GeneratePortInstructions(ref dataCollector);
}
else
{
propertyName = PropertyName;
}
string uvs = string.Empty;
if (m_uvPort.IsConnected)
{
uvs = m_uvPort.GeneratePortInstructions(ref dataCollector);
}
else
{
if (dataCollector.IsTemplate)
{
uvs = dataCollector.TemplateDataCollectorInstance.GetTextureCoord(m_uvSet, (instanced ? m_referenceSampler.PropertyName : PropertyName), UniqueId, m_currentPrecisionType);
}
else
{
if (isVertex)
{
uvs = TexCoordVertexDataNode.GenerateVertexUVs(ref dataCollector, UniqueId, m_uvSet, propertyName);
}
else
{
uvs = TexCoordVertexDataNode.GenerateFragUVs(ref dataCollector, UniqueId, m_uvSet, propertyName);
}
}
}
string index = m_indexPort.GeneratePortInstructions(ref dataCollector);
string m_normalMapUnpackMode = "";
if (m_autoUnpackNormals)
{
bool isScaledNormal = false;
if (m_normalPort.IsConnected)
{
isScaledNormal = true;
}
else
{
if (m_normalPort.FloatInternalData != 1)
{
isScaledNormal = true;
}
}
if (isScaledNormal)
{
string scaleValue = m_normalPort.GeneratePortInstructions(ref dataCollector);
dataCollector.AddToIncludes(UniqueId, Constants.UnityStandardUtilsLibFuncs);
m_normalMapUnpackMode = "UnpackScaleNormal( {0} ," + scaleValue + " )";
}
else
{
m_normalMapUnpackMode = "UnpackNormal( {0} )";
}
}
string result = string.Empty;
//CAREFUL mipbias here means derivative (this needs index changes)
if (m_mipMode == MipType.MipBias)
{
dataCollector.UsingArrayDerivatives = true;
result = "ASE_SAMPLE_TEX2DARRAY_GRAD(" + propertyName + ", float3(" + uvs + ", " + index + "), " + m_ddxPort.GeneratePortInstructions(ref dataCollector) + ", " + m_ddyPort.GeneratePortInstructions(ref dataCollector) + " )";
}
else if (m_lodPort.Visible || isVertex)
{
result = "UNITY_SAMPLE_TEX2DARRAY_LOD(" + propertyName + ", float3(" + uvs + ", " + index + "), " + level + " )";
}
else
{
result = "UNITY_SAMPLE_TEX2DARRAY" + (m_lodPort.Visible || isVertex ? "_LOD" : "") + "(" + propertyName + ", float3(" + uvs + ", " + index + ") " + (m_lodPort.Visible || isVertex ? ", " + level : "") + " )";
}
if (m_autoUnpackNormals)
{
result = string.Format(m_normalMapUnpackMode, result);
}
RegisterLocalVariable(0, result, ref dataCollector, "texArray" + OutputId);
return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue));
}
public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar)
{
if (m_outputPorts[0].IsLocalValue(dataCollector.PortCategory))
{
return(m_outputPorts[0].LocalValue(dataCollector.PortCategory));
}
if (dataCollector.IsFragmentCategory)
{
dataCollector.AddToInput(UniqueId, SurfaceInputs.WORLD_POS);
}
string viewdir = string.Empty;
if (m_viewType == ViewType.ViewDir)
{
if (m_viewVecPort.IsConnected)
{
viewdir = m_viewVecPort.GeneratePortInstructions(ref dataCollector);
}
else
{
viewdir = GeneratorUtils.GenerateViewDirection(ref dataCollector, UniqueId, ViewSpace.World);
}
}
else
{
if (m_viewVecPort.IsConnected)
{
viewdir = m_viewVecPort.GeneratePortInstructions(ref dataCollector);
}
else
{
viewdir = GeneratorUtils.GenerateWorldLightDirection(ref dataCollector, UniqueId, CurrentPrecisionType);
}
}
string normal = string.Empty;
if (m_normalType == NormalType.WorldNormal || m_normalType == NormalType.TangentNormal)
{
if (m_normalVecPort.IsConnected)
{
normal = m_normalVecPort.GeneratePortInstructions(ref dataCollector);
if (dataCollector.IsFragmentCategory)
{
dataCollector.AddToInput(UniqueId, SurfaceInputs.INTERNALDATA, addSemiColon: false);
if (m_normalType == NormalType.TangentNormal)
{
if (dataCollector.IsTemplate)
{
normal = dataCollector.TemplateDataCollectorInstance.GetWorldNormal(UniqueId, CurrentPrecisionType, normal, OutputId);
}
else
{
normal = GeneratorUtils.GenerateWorldNormal(ref dataCollector, UniqueId, CurrentPrecisionType, normal, OutputId);
dataCollector.AddToInput(UniqueId, SurfaceInputs.WORLD_NORMAL, CurrentPrecisionType);
dataCollector.ForceNormal = true;
}
}
else
{
if (m_normalizeVectors)
{
normal = string.Format("normalize( {0} )", normal);
}
}
}
else
{
if (m_normalType == NormalType.TangentNormal)
{
string wtMatrix = GeneratorUtils.GenerateWorldToTangentMatrix(ref dataCollector, UniqueId, CurrentPrecisionType);
normal = "mul( " + normal + "," + wtMatrix + " )";
}
}
}
else
{
if (dataCollector.IsFragmentCategory)
{
dataCollector.AddToInput(UniqueId, SurfaceInputs.WORLD_NORMAL, CurrentPrecisionType);
if (dataCollector.DirtyNormal)
{
dataCollector.AddToInput(UniqueId, SurfaceInputs.INTERNALDATA, addSemiColon: false);
}
}
if (dataCollector.IsTemplate)
{
normal = dataCollector.TemplateDataCollectorInstance.GetWorldNormal(CurrentPrecisionType, normalize: (dataCollector.DirtyNormal && m_normalizeVectors));
}
else
{
normal = GeneratorUtils.GenerateWorldNormal(ref dataCollector, UniqueId, (dataCollector.DirtyNormal && m_normalizeVectors));
}
if (dataCollector.DirtyNormal)
{
dataCollector.ForceNormal = true;
}
}
}
else
{
// generate HV
if (!m_normalVecPort.IsConnected)
{
string halfView = GeneratorUtils.GenerateViewDirection(ref dataCollector, UniqueId, ViewSpace.World);
string halfLight = GeneratorUtils.GenerateWorldLightDirection(ref dataCollector, UniqueId, CurrentPrecisionType);
normal = "halfVector" + OutputId;
dataCollector.AddLocalVariable(UniqueId, CurrentPrecisionType, WirePortDataType.FLOAT3, normal, "normalize( " + halfView + " + " + halfLight + " )");
}
else
{
normal = m_normalVecPort.GeneratePortInstructions(ref dataCollector);
if (m_normalizeVectors)
{
normal = string.Format("normalize( {0} )", normal);
}
}
}
string bias = m_biasPort.GeneratePortInstructions(ref dataCollector);
string scale = m_scalePort.GeneratePortInstructions(ref dataCollector);
string power = m_powerPort.GeneratePortInstructions(ref dataCollector);
string fresnelNDotVLocalValue = "dot( " + normal + ", " + viewdir + " )";
string fresnelNDotVLocalVar = "fresnelNdotV" + OutputId;
dataCollector.AddLocalVariable(UniqueId, CurrentPrecisionType, WirePortDataType.FLOAT, fresnelNDotVLocalVar, fresnelNDotVLocalValue);
string fresnelFinalVar = FresnedFinalVar + OutputId;
string result = string.Empty;
switch (m_fresnelType)
{
default:
case FresnelType.Standard:
{
result = string.Format("( {0} + {1} * pow( 1.0 - {2}, {3} ) )", bias, scale, fresnelNDotVLocalVar, power);
}
break;
case FresnelType.Schlick:
{
string f0VarName = "f0" + OutputId;
dataCollector.AddLocalVariable(UniqueId, CurrentPrecisionType, WirePortDataType.FLOAT, f0VarName, bias);
result = string.Format("( {0} + ( 1.0 - {0} ) * pow( 1.0 - {1}, 5 ) )", f0VarName, fresnelNDotVLocalVar);
}
break;
case FresnelType.SchlickIOR:
{
string iorVarName = "ior" + OutputId;
dataCollector.AddLocalVariable(UniqueId, CurrentPrecisionType, WirePortDataType.FLOAT, iorVarName, scale);
dataCollector.AddLocalVariable(UniqueId, iorVarName + " = pow( ( 1-" + iorVarName + " )/( 1+" + iorVarName + " ), 2 );");
result = string.Format("( {0} + ( 1.0 - {0} ) * pow( 1.0 - {1}, 5 ) )", iorVarName, fresnelNDotVLocalVar);
}
break;
}
RegisterLocalVariable(0, result, ref dataCollector, fresnelFinalVar);
return(m_outputPorts[0].LocalValue(dataCollector.PortCategory));
}
public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalVar)
{
if (dataCollector.PortCategory == MasterNodePortCategory.Tessellation)
{
UIUtils.ShowMessage(UniqueId, m_nodeAttribs.Name + " cannot be used on Master Node Tessellation port");
return("-1");
}
//bool isVertex = ( dataCollector.PortCategory == MasterNodePortCategory.Vertex || dataCollector.PortCategory == MasterNodePortCategory.Tessellation );
string tiling = string.Empty;
string offset = string.Empty;
string portProperty = string.Empty;
if (m_texPort.IsConnected)
{
portProperty = m_texPort.GeneratePortInstructions(ref dataCollector);
}
else if (m_referenceArrayId > -1)
{
TexturePropertyNode temp = UIUtils.GetTexturePropertyNode(m_referenceArrayId);
if (temp != null)
{
portProperty = temp.BaseGenerateShaderForOutput(outputId, ref dataCollector, ignoreLocalVar);
}
}
//TEMPLATES
if (dataCollector.MasterNodeCategory == AvailableShaderTypes.Template)
{
if (m_outputPorts[0].IsLocalValue(dataCollector.PortCategory))
{
return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue(dataCollector.PortCategory)));
}
string uvName = string.Empty;
string result = string.Empty;
string indexStr = m_textureCoordChannel > 0 ? (m_textureCoordChannel + 1).ToString() : "";
string sizeDif = string.Empty;
if (m_texcoordSize == 3)
{
sizeDif = "3";
}
else if (m_texcoordSize == 4)
{
sizeDif = "4";
}
if (dataCollector.TemplateDataCollectorInstance.GetCustomInterpolatedData(TemplateHelperFunctions.IntToUVChannelInfo[m_textureCoordChannel], m_outputPorts[0].DataType, PrecisionType.Float, ref result, false, dataCollector.PortCategory))
{
uvName = result;
}
else if (dataCollector.TemplateDataCollectorInstance.HasUV(m_textureCoordChannel))
{
uvName = dataCollector.TemplateDataCollectorInstance.GetUVName(m_textureCoordChannel, m_outputPorts[0].DataType);
}
else
{
uvName = dataCollector.TemplateDataCollectorInstance.RegisterUV(m_textureCoordChannel, m_outputPorts[0].DataType);
}
string currPropertyName = GetValidPropertyName();
if (!string.IsNullOrEmpty(portProperty) && portProperty != "0.0")
{
currPropertyName = portProperty;
}
if (!string.IsNullOrEmpty(currPropertyName))
{
string finalTexCoordName = "uv" + indexStr + (m_texcoordSize > 2 ? "s" + sizeDif : "") + currPropertyName;
string dummyPropertyTexcoords = currPropertyName + "_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(dummyPropertyTexcoords);
dummyPropertyTexcoords = m_texCoordsHelper.GenerateShaderForOutput(0, ref dataCollector, false);
if (m_texcoordSize > 2)
{
dataCollector.AddLocalVariable(UniqueId, CurrentPrecisionType, m_outputPorts[0].DataType, finalTexCoordName, uvName);
dataCollector.AddLocalVariable(UniqueId, finalTexCoordName + ".xy", string.Format(Constants.TilingOffsetFormat, uvName + ".xy", dummyPropertyTexcoords + ".xy", dummyPropertyTexcoords + ".zw") + ";");
m_outputPorts[0].SetLocalValue(finalTexCoordName, dataCollector.PortCategory);
}
else
{
RegisterLocalVariable(0, string.Format(Constants.TilingOffsetFormat, uvName, dummyPropertyTexcoords + ".xy", dummyPropertyTexcoords + ".zw"), ref dataCollector, finalTexCoordName);
}
//RegisterLocalVariable( 0, string.Format( Constants.TilingOffsetFormat, uvName, dummyPropertyTexcoords+".xy", dummyPropertyTexcoords+".zw" ), ref dataCollector, finalTexCoordName );
}
else
{
string finalTexCoordName = "texCoord" + OutputId;
tiling = m_tilingPort.GeneratePortInstructions(ref dataCollector);
offset = m_offsetPort.GeneratePortInstructions(ref dataCollector);
if (m_texcoordSize > 2)
{
dataCollector.AddLocalVariable(UniqueId, CurrentPrecisionType, m_outputPorts[0].DataType, finalTexCoordName, uvName);
dataCollector.AddLocalVariable(UniqueId, finalTexCoordName + ".xy", string.Format(Constants.TilingOffsetFormat, uvName + ".xy", tiling, offset) + ";");
m_outputPorts[0].SetLocalValue(finalTexCoordName, dataCollector.PortCategory);
}
else
{
RegisterLocalVariable(0, string.Format(Constants.TilingOffsetFormat, uvName, tiling, offset), ref dataCollector, finalTexCoordName);
}
//RegisterLocalVariable( 0, string.Format( Constants.TilingOffsetFormat, uvName, tiling, offset ), ref dataCollector, finalTexCoordName );
}
return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue(dataCollector.PortCategory)));
}
//SURFACE
string propertyName = GetValidPropertyName();
if (!string.IsNullOrEmpty(portProperty) && portProperty != "0.0")
{
propertyName = portProperty;
}
if (m_outputPorts[0].IsLocalValue(dataCollector.PortCategory))
{
return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue(dataCollector.PortCategory)));
}
if (!m_tilingPort.IsConnected && m_tilingPort.Vector2InternalData == Vector2.one)
{
tiling = null;
}
else
{
tiling = m_tilingPort.GeneratePortInstructions(ref dataCollector);
}
if (!m_offsetPort.IsConnected && m_offsetPort.Vector2InternalData == Vector2.zero)
{
offset = null;
}
else
{
offset = m_offsetPort.GeneratePortInstructions(ref dataCollector);
}
if (!string.IsNullOrEmpty(propertyName) /*m_referenceArrayId > -1*/)
{
m_surfaceTexcoordName = GeneratorUtils.GenerateAutoUVs(ref dataCollector, UniqueId, m_textureCoordChannel, propertyName, m_outputPorts[0].DataType, tiling, offset, OutputId);
}
else
{
m_surfaceTexcoordName = GeneratorUtils.GenerateAutoUVs(ref dataCollector, UniqueId, m_textureCoordChannel, null, m_outputPorts[0].DataType, tiling, offset, OutputId);
}
m_outputPorts[0].SetLocalValue(m_surfaceTexcoordName, dataCollector.PortCategory);
return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue(dataCollector.PortCategory)));
}
public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar)
{
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.AddToLocalVariables(UniqueId, m_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(m_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(m_currentPrecisionType);
}
else
{
dataCollector.AddToInput(UniqueId, SurfaceInputs.WORLD_NORMAL, m_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;
dataCollector.AddToUniforms(UniqueId, "uniform float4 " + texture + "_ST;");
if (m_pomTexType == POMTexTypes.TextureArray)
{
dataCollector.UsingArrayDerivatives = true;
}
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);
dataCollector.AddToLocalVariables(UniqueId, m_currentPrecisionType, m_pomUVPort.DataType, localVarName, functionResult);
return(GetOutputVectorItem(0, outputId, localVarName));
}