public DateTimeRange(DateTime Time, PrecisionType Precision = PrecisionType.Ticks)
{
this._Time = Time;
this._Precision = Precision;
this.WasUpdated = true;
this._TimeStart = DateTime.MinValue;
this._TimeEnd = DateTime.MaxValue;
}
public static void GetShaderPrecisionFormat(ShaderType type, PrecisionType precisiontype, int[] range, int[] precision)
{
Delegates.glGetShaderPrecisionFormat(type, precisiontype, range, precision);
}
// OBJECT TO TANGENT MATRIX
static public string GenerateObjectToTangentMatrix(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision)
{
string normal = GenerateVertexNormal(ref dataCollector, uniqueId, precision);
string tangent = GenerateVertexTangent(ref dataCollector, uniqueId, precision);
string bitangen = GenerateVertexBitangent(ref dataCollector, uniqueId, precision);
dataCollector.AddLocalVariable(uniqueId, precision, WirePortDataType.FLOAT3x3, ObjectToTangentStr, "float3x3( " + tangent + ", " + bitangen + ", " + normal + " )");
return(ObjectToTangentStr);
}
public unsafe partial void GetShaderPrecisionFormat([Flow(FlowDirection.In)] ARB shadertype, [Flow(FlowDirection.In)] PrecisionType precisiontype, [Count(Count = 2), Flow(FlowDirection.Out)] int *range, [Count(Count = 1), Flow(FlowDirection.Out)] int *precision);
public static void qglGetShaderPrecisionFormat(ShaderType shadertype, PrecisionType precisiontype, int *range, int *precision) => glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
// LIGHT DIRECTION WORLD
static public string GenerateWorldLightDirection(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision)
{
dataCollector.AddToIncludes(uniqueId, Constants.UnityCgLibFuncs);
string worldPos = GeneratorUtils.GenerateWorldPosition(ref dataCollector, uniqueId);
dataCollector.AddLocalVariable(uniqueId, "#if defined(LIGHTMAP_ON) && UNITY_VERSION < 560 //aseld");
dataCollector.AddLocalVariable(uniqueId, precision, WirePortDataType.FLOAT3, WorldLightDirStr, "0");
dataCollector.AddLocalVariable(uniqueId, "#else //aseld");
dataCollector.AddLocalVariable(uniqueId, precision, WirePortDataType.FLOAT3, WorldLightDirStr, (dataCollector.SafeNormalizeLightDir ? "Unity_SafeNormalize" : "normalize") + "( UnityWorldSpaceLightDir( " + worldPos + " ) )");
dataCollector.AddLocalVariable(uniqueId, "#endif //aseld");
return(WorldLightDirStr);
}
// VIEW POS
static public string GenerateViewPositionOnFrag(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision)
{
if (dataCollector.IsTemplate)
{
UnityEngine.Debug.LogWarning("View Pos not implemented on Templates");
}
string vertexName = GenerateVertexPositionOnFrag(ref dataCollector, uniqueId, precision);
string value = string.Format("UnityObjectToViewPos( {0} )", vertexName);
dataCollector.AddToLocalVariables(uniqueId, precision, WirePortDataType.FLOAT3, ViewPositionStr, value);
return(ViewPositionStr);
}
// VERTEX POSITION ON FRAG
static public string GenerateVertexPositionOnFrag(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision)
{
dataCollector.AddToInput(uniqueId, SurfaceInputs.WORLD_POS);
dataCollector.AddToIncludes(uniqueId, Constants.UnityShaderVariables);
string value = "mul( unity_WorldToObject, float4( " + Constants.InputVarStr + ".worldPos , 1 ) )";
dataCollector.AddToLocalVariables(uniqueId, precision, WirePortDataType.FLOAT4, VertexPosition4Str, value);
return(VertexPosition4Str);
}
static public string GenerateScreenPositionNormalized(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision, bool addInput = true)
{
string stringPosVar = GenerateScreenPosition(ref dataCollector, uniqueId, precision, addInput);
dataCollector.AddLocalVariable(uniqueId, string.Format("float4 {0} = {1} / {1}.w;", ScreenPositionNormalizedStr, stringPosVar));
dataCollector.AddLocalVariable(uniqueId, ScreenPositionNormalizedStr + ".z = ( UNITY_NEAR_CLIP_VALUE >= 0 ) ? " + ScreenPositionNormalizedStr + ".z : " + ScreenPositionNormalizedStr + ".z * 0.5 + 0.5;");
return(ScreenPositionNormalizedStr);
}
// SCREEN POSITION NORMALIZED
static public string GenerateScreenPositionNormalizedForValue(string customVertexPos, string outputId, ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision, bool addInput = true)
{
string stringPosVar = GenerateScreenPositionForValue(customVertexPos, outputId, ref dataCollector, uniqueId, precision, addInput);
string varName = ScreenPositionNormalizedStr + uniqueId;
dataCollector.AddLocalVariable(uniqueId, string.Format("float4 {0} = {1} / {1}.w;", varName, stringPosVar));
dataCollector.AddLocalVariable(uniqueId, varName + ".z = ( UNITY_NEAR_CLIP_VALUE >= 0 ) ? " + varName + ".z : " + varName + ".z * 0.5 + 0.5;");
return(varName);
}
static public string GenerateTangentToWorldMatrixPrecise(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision)
{
if (dataCollector.IsTemplate)
{
return(dataCollector.TemplateDataCollectorInstance.GetTangentToWorldMatrixPrecise(precision));
}
if (dataCollector.IsFragmentCategory)
{
dataCollector.ForceNormal = true;
dataCollector.AddToInput(-1, SurfaceInputs.WORLD_NORMAL, precision);
dataCollector.AddToInput(-1, SurfaceInputs.INTERNALDATA, addSemiColon: false);
}
string worldToTangent = GenerateWorldToTangentMatrix(ref dataCollector, uniqueId, precision);
Add3x3InverseFunction(ref dataCollector, UIUtils.PrecisionWirePortToCgType(precision, WirePortDataType.FLOAT));
dataCollector.AddLocalVariable(uniqueId, precision, WirePortDataType.FLOAT3x3, TangentToWorldPreciseStr, string.Format(Inverse3x3Header, worldToTangent));
return(TangentToWorldPreciseStr);
}
// TANGENT TO WORLD
static public string GenerateTangentToWorldMatrixFast(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision)
{
if (dataCollector.IsTemplate)
{
return(dataCollector.TemplateDataCollectorInstance.GetTangentToWorldMatrixFast(precision));
}
if (dataCollector.IsFragmentCategory)
{
dataCollector.ForceNormal = true;
dataCollector.AddToInput(-1, SurfaceInputs.WORLD_NORMAL, precision);
dataCollector.AddToInput(-1, SurfaceInputs.INTERNALDATA, addSemiColon: false);
}
string worldNormal = GenerateWorldNormal(ref dataCollector, uniqueId);
string worldTangent = GenerateWorldTangent(ref dataCollector, uniqueId);
string worldBitangent = GenerateWorldBitangent(ref dataCollector, uniqueId);
string result = string.Format("float3x3({0}.x,{1}.x,{2}.x,{0}.y,{1}.y,{2}.y,{0}.z,{1}.z,{2}.z)", worldTangent, worldBitangent, worldNormal);
dataCollector.AddLocalVariable(uniqueId, precision, WirePortDataType.FLOAT3x3, TangentToWorldFastStr, result);
return(TangentToWorldFastStr);
}
// TANGENT TO OBJECT
//static public string GenerateTangentToObjectMatrixFast( ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision )
//{
// string normal = GenerateVertexNormal( ref dataCollector, uniqueId, precision );
// string tangent = GenerateVertexTangent( ref dataCollector, uniqueId, precision );
// string bitangent = GenerateVertexBitangent( ref dataCollector, uniqueId, precision );
// string result = string.Format( "float3x3({0}.x,{1}.x,{2}.x,{0}.y,{1}.y,{2}.y,{0}.z,{1}.z,{2}.z)",tangent,bitangent,normal );
// dataCollector.AddLocalVariable( uniqueId, precision, WirePortDataType.FLOAT3x3, TangentToObjectFastStr, result );
// return TangentToObjectFastStr;
//}
//static public string GenerateTangentToObjectMatrixPrecise( ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision )
//{
// string objectToTangent = GenerateObjectToTangentMatrix( ref dataCollector, uniqueId, precision );
// Add3x3InverseFunction( ref dataCollector, UIUtils.PrecisionWirePortToCgType( precision, WirePortDataType.FLOAT ) );
// dataCollector.AddLocalVariable( uniqueId, precision, WirePortDataType.FLOAT3x3, TangentToObjectStr, string.Format( Inverse3x3Header, objectToTangent ) );
// return TangentToObjectStr;
//}
// WORLD TO TANGENT MATRIX
static public string GenerateWorldToTangentMatrix(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision)
{
if (dataCollector.IsTemplate)
{
return(dataCollector.TemplateDataCollectorInstance.GetWorldToTangentMatrix(precision));
}
if (dataCollector.IsFragmentCategory)
{
dataCollector.ForceNormal = true;
dataCollector.AddToInput(-1, SurfaceInputs.WORLD_NORMAL, precision);
dataCollector.AddToInput(-1, SurfaceInputs.INTERNALDATA, addSemiColon: false);
}
string worldNormal = GenerateWorldNormal(ref dataCollector, uniqueId);
string worldTangent = GenerateWorldTangent(ref dataCollector, uniqueId);
string worldBitangent = GenerateWorldBitangent(ref dataCollector, uniqueId);
dataCollector.AddLocalVariable(uniqueId, precision, WirePortDataType.FLOAT3x3, WorldToTangentStr, "float3x3( " + worldTangent + ", " + worldBitangent + ", " + worldNormal + " )");
return(WorldToTangentStr);
}
// WORLD NORMAL
static public string GenerateWorldNormal(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precisionType, string normal, string outputId)
{
if (dataCollector.IsTemplate)
{
return(dataCollector.TemplateDataCollectorInstance.GetWorldNormal(uniqueId, precisionType, normal, outputId));
}
string tanToWorld = GenerateTangentToWorldMatrixFast(ref dataCollector, uniqueId, precisionType);
return(string.Format("mul({0},{1})", tanToWorld, normal));
}
// WORLD TO TANGENT MATRIX
static public string GenerateWorldToTangentMatrix(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision)
{
string worldNormal = GenerateWorldNormal(ref dataCollector, uniqueId);
string worldTangent = GenerateWorldTangent(ref dataCollector, uniqueId);
string worldBitangent = GenerateWorldBitangent(ref dataCollector, uniqueId);
dataCollector.AddLocalVariable(uniqueId, precision, WirePortDataType.FLOAT3x3, WorldToTangentStr, "float3x3( " + worldTangent + ", " + worldBitangent + ", " + worldNormal + " )");
return(WorldToTangentStr);
}
// SCREEN POSITION
static public string GenerateScreenPositionForValue(string customVertexPosition, string outputId, ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision, bool addInput = true)
{
if (dataCollector.IsTemplate)
{
return(dataCollector.TemplateDataCollectorInstance.GetScreenPosForValue(customVertexPosition, outputId));
}
string value = GenerateVertexScreenPositionForValue(customVertexPosition, outputId, ref dataCollector, uniqueId, precision);
string screenPosVarName = "screenPosition" + outputId;
dataCollector.AddToInput(uniqueId, screenPosVarName, WirePortDataType.FLOAT4, precision);
dataCollector.AddToVertexLocalVariables(uniqueId, Constants.VertexShaderOutputStr + "." + screenPosVarName + " = " + value + ";");
string screenPosVarNameOnFrag = ScreenPositionStr + outputId;
string globalResult = Constants.InputVarStr + "." + screenPosVarName;
dataCollector.AddLocalVariable(uniqueId, string.Format("float4 {0} = {1};", screenPosVarNameOnFrag, globalResult));
return(screenPosVarNameOnFrag);
}
public string[] OutlineFunctionBody(ref MasterNodeDataCollector dataCollector, bool instanced, bool isShadowCaster, string shaderName, string[] billboardInfo, ref TessellationOpHelper tessOpHelper, string target, PrecisionType precision)
{
List <string> body = new List <string>();
body.Add(ModeTags[dataCollector.CustomOutlineSelectedAlpha]);
if (!string.IsNullOrEmpty(m_grabPasses))
{
body.Add(m_grabPasses.Replace("\t\t", string.Empty));
}
if (m_zWriteMode != 0)
{
body.Add("ZWrite " + ZBufferOpHelper.ZWriteModeValues[m_zWriteMode]);
}
if (m_zTestMode != 0)
{
body.Add("ZTest " + ZBufferOpHelper.ZTestModeValues[m_zTestMode]);
}
body.Add("Cull " + m_cullMode);
body.Add("CGPROGRAM");
if (tessOpHelper.EnableTesselation)
{
body.Add("#include \"" + TessellationOpHelper.TessInclude + "\"");
body.Add("#pragma target " + target);
}
else
{
body.Add("#pragma target 3.0");
}
bool customOutline = dataCollector.UsingCustomOutlineColor || dataCollector.UsingCustomOutlineWidth || dataCollector.UsingCustomOutlineAlpha;
int outlineMode = customOutline ? m_offsetMode : (m_mode == OutlineMode.VertexOffset ? 0 : 1);
string extraOptions = (customOutline ? m_customNoFog : m_noFog) ? "nofog " : string.Empty;
if (dataCollector.CustomOutlineSelectedAlpha > 0)
{
extraOptions += ModePragma[dataCollector.CustomOutlineSelectedAlpha];
}
string surfConfig = string.Format(OutlineSurfaceConfig, extraOptions);
if (tessOpHelper.EnableTesselation)
{
tessOpHelper.WriteToOptionalParams(ref surfConfig);
}
body.Add(surfConfig);
if (!isShadowCaster)
{
AddMultibodyString(m_defines, body);
AddMultibodyString(m_includes, body);
AddMultibodyString(m_pragmas, body);
}
AddMultibodyString(m_standardAdditionalDirectives, body);
//if( instanced )
//{
// body.Add( OutlineInstancedHeader );
//}
if (customOutline)
{
if (isShadowCaster)
{
for (int i = 0; i < InputList.Count; i++)
{
dataCollector.AddToInput(InputList[i].NodeId, InputList[i].PropertyName, !InputList[i].IsDirective);
}
}
else
{
if (!string.IsNullOrEmpty(m_inputs))
{
body.Add(m_inputs.Trim('\t', '\n'));
}
}
if (!DirtyInput && !isShadowCaster)
{
body.Add(OutlineBodyStructDefault);
}
if (!isShadowCaster)
{
body.Add(OutlineBodyStructEnd);
}
}
else if (!isShadowCaster)
{
body.Add(OutlineBodyStructBegin);
body.Add(OutlineBodyStructDefault);
body.Add(OutlineBodyStructEnd);
}
if (instanced)
{
//for( int i = 0; i < OutlineBodyInstancedBegin.Length; i++ )
//{
// body.Add( ( i == 0 ) ? string.Format( OutlineBodyInstancedBegin[ i ], shaderName ) : OutlineBodyInstancedBegin[ i ] );
//}
//if( (object)billboardInfo != null )
//{
// for( int j = 0; j < billboardInfo.Length; j++ )
// {
// body.Add( string.Format( BillboardInstructionFormat, billboardInfo[ j ] ) );
// }
//}
//switch( outlineMode )
//{
// case 0: body.Add( string.Format( OutlineVertexOffsetMode, WidthVariableAccessInstanced ) ); break;
// case 1: body.Add( string.Format( OutlineVertexScaleMode, WidthVariableAccessInstanced ) ); break;
// case 2: body.Add( string.Format( OutlineVertexCustomMode, WidthVariableAccessInstanced ) ); break;
//}
//for( int i = 0; i < OutlineBodyInstancedEnd.Length; i++ )
//{
// body.Add( OutlineBodyInstancedEnd[ i ] );
//}
//Instanced block name must differ from used on main shader so it won't throw a duplicate name error
shaderName = shaderName + "Outline";
bool openCBuffer = true;
if (customOutline)
{
if (isShadowCaster)
{
for (int i = 0; i < UniformList.Count; i++)
{
dataCollector.AddToUniforms(UniformList[i].NodeId, UniformList[i].PropertyName);
}
foreach (KeyValuePair <string, string> kvp in m_localFunctions)
{
dataCollector.AddFunction(kvp.Key, kvp.Value);
}
}
else
{
if (!string.IsNullOrEmpty(Uniforms))
{
body.Add(Uniforms.Trim('\t', '\n'));
}
openCBuffer = false;
body.Add(string.Format(IOUtils.InstancedPropertiesBegin, shaderName));
if (!string.IsNullOrEmpty(InstancedProperties))
{
body.Add(InstancedProperties.Trim('\t', '\n'));
}
}
}
if (openCBuffer)
{
body.Add(string.Format(IOUtils.InstancedPropertiesBegin, shaderName));
}
if (!dataCollector.UsingCustomOutlineColor)
{
body.Add(precision == PrecisionType.Float ? OutlineDefaultUniformColorInstanced.Replace("half", "float") : OutlineDefaultUniformColorInstanced);
}
if (!dataCollector.UsingCustomOutlineWidth)
{
body.Add(precision == PrecisionType.Float ? OutlineDefaultUniformWidthInstanced.Replace("half", "float") : OutlineDefaultUniformWidthInstanced);
}
body.Add(IOUtils.InstancedPropertiesEnd);
//Functions
if (customOutline && !isShadowCaster)
{
body.Add(Functions);
}
if (tessOpHelper.EnableTesselation && !isShadowCaster)
{
body.Add(tessOpHelper.Uniforms().TrimStart('\t'));
body.Add(tessOpHelper.GetCurrentTessellationFunction(ref dataCollector).Trim('\t', '\n') + "\n");
}
if (tessOpHelper.EnableTesselation)
{
body.Add(OutlineTessVertexHeader);
}
else
{
body.Add(OutlineDefaultVertexHeader);
body.Add(OutlineDefaultVertexOutputDeclaration);
}
if (customOutline)
{
if (!string.IsNullOrEmpty(VertexData))
{
body.Add("\t" + VertexData.Trim('\t', '\n'));
}
}
if ((object)billboardInfo != null)
{
for (int j = 0; j < billboardInfo.Length; j++)
{
body.Add(string.Format(BillboardInstructionFormat, billboardInfo[j]));
}
}
switch (outlineMode)
{
case 0: body.Add(string.Format(OutlineVertexOffsetMode, dataCollector.UsingCustomOutlineWidth ? "outlineVar" : WidthPropertyNameInstanced)); break;
case 1: body.Add(string.Format(OutlineVertexScaleMode, dataCollector.UsingCustomOutlineWidth ? "outlineVar" : WidthPropertyNameInstanced)); break;
case 2: body.Add(string.Format(OutlineVertexCustomMode, dataCollector.UsingCustomOutlineWidth ? "outlineVar" : WidthPropertyNameInstanced)); break;
}
for (int i = 0; i < OutlineBodyDefaultSurfBegin.Length; i++)
{
body.Add(OutlineBodyDefaultSurfBegin[i]);
}
if (dataCollector.UsingCustomOutlineColor || dataCollector.CustomOutlineSelectedAlpha > 0)
{
body.Add("\t" + Instructions.Trim('\t', '\n'));
}
else
{
for (int i = 0; i < OutlineSurfBodyInstanced.Length; i++)
{
body.Add(OutlineSurfBodyInstanced[i]);
}
}
for (int i = 0; i < OutlineBodyDefaultSurfEnd.Length; i++)
{
body.Add(OutlineBodyDefaultSurfEnd[i]);
}
}
else
{
if (customOutline)
{
if (isShadowCaster)
{
for (int i = 0; i < UniformList.Count; i++)
{
dataCollector.AddToUniforms(UniformList[i].NodeId, UniformList[i].PropertyName);
}
foreach (KeyValuePair <string, string> kvp in m_localFunctions)
{
dataCollector.AddFunction(kvp.Key, kvp.Value);
}
}
else
{
if (!string.IsNullOrEmpty(Uniforms))
{
body.Add(Uniforms.Trim('\t', '\n'));
}
}
}
if (!dataCollector.UsingCustomOutlineColor)
{
body.Add(precision == PrecisionType.Float ? OutlineDefaultUniformColor.Replace("half", "float") : OutlineDefaultUniformColor);
}
if (!dataCollector.UsingCustomOutlineWidth)
{
body.Add(precision == PrecisionType.Float ? OutlineDefaultUniformWidth.Replace("half", "float") : OutlineDefaultUniformWidth);
}
//Functions
if (customOutline && !isShadowCaster)
{
body.Add(Functions);
}
if (tessOpHelper.EnableTesselation && !isShadowCaster)
{
body.Add(tessOpHelper.Uniforms().TrimStart('\t'));
body.Add(tessOpHelper.GetCurrentTessellationFunction(ref dataCollector).Trim('\t', '\n') + "\n");
}
if (tessOpHelper.EnableTesselation)
{
body.Add(OutlineTessVertexHeader);
}
else
{
body.Add(OutlineDefaultVertexHeader);
body.Add(OutlineDefaultVertexOutputDeclaration);
}
if (customOutline)
{
if (!string.IsNullOrEmpty(VertexData))
{
body.Add("\t" + VertexData.Trim('\t', '\n'));
}
}
if ((object)billboardInfo != null)
{
for (int j = 0; j < billboardInfo.Length; j++)
{
body.Add(string.Format(BillboardInstructionFormat, billboardInfo[j]));
}
}
switch (outlineMode)
{
case 0: body.Add(string.Format(OutlineVertexOffsetMode, dataCollector.UsingCustomOutlineWidth ? "outlineVar" : WidthPropertyName)); break;
case 1: body.Add(string.Format(OutlineVertexScaleMode, dataCollector.UsingCustomOutlineWidth ? "outlineVar" : WidthPropertyName)); break;
case 2: body.Add(string.Format(OutlineVertexCustomMode, dataCollector.UsingCustomOutlineWidth ? "outlineVar" : WidthPropertyName)); break;
}
for (int i = 0; i < OutlineBodyDefaultSurfBegin.Length; i++)
{
body.Add(OutlineBodyDefaultSurfBegin[i]);
}
if (dataCollector.UsingCustomOutlineColor || dataCollector.CustomOutlineSelectedAlpha > 0)
{
body.Add("\t" + Instructions.Trim('\t', '\n'));
}
else
{
for (int i = 0; i < OutlineSurfBody.Length; i++)
{
body.Add(OutlineSurfBody[i]);
}
}
for (int i = 0; i < OutlineBodyDefaultSurfEnd.Length; i++)
{
body.Add(OutlineBodyDefaultSurfEnd[i]);
}
}
string[] bodyArr = body.ToArray();
body.Clear();
body = null;
return(bodyArr);
}
static public string GenerateScreenPosition(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision, bool addInput = true)
{
if (dataCollector.UsingCustomScreenPos && dataCollector.IsFragmentCategory)
{
string value = GenerateVertexScreenPosition(ref dataCollector, uniqueId, precision);
dataCollector.AddToInput(uniqueId, "screenPosition", WirePortDataType.FLOAT4, precision);
dataCollector.AddToVertexLocalVariables(uniqueId, Constants.VertexShaderOutputStr + ".screenPosition = " + value + ";");
string globalResult = Constants.InputVarStr + ".screenPosition";
dataCollector.AddLocalVariable(uniqueId, string.Format("float4 {0} = {1};", ScreenPositionStr, globalResult));
return(ScreenPositionStr);
}
else
{
if (!dataCollector.IsFragmentCategory)
{
return(GenerateVertexScreenPosition(ref dataCollector, uniqueId, precision));
}
if (dataCollector.IsTemplate)
{
return(dataCollector.TemplateDataCollectorInstance.GetScreenPos());
}
}
if (addInput)
{
dataCollector.AddToInput(uniqueId, SurfaceInputs.SCREEN_POS, precision);
}
string result = Constants.InputVarStr + ".screenPos";
dataCollector.AddLocalVariable(uniqueId, string.Format("float4 {0} = float4( {1}.xyz , {1}.w + 0.00000000001 );", ScreenPositionStr, result));
return(ScreenPositionStr);
}
// CLIP POSITION ON FRAG
static public string GenerateClipPositionOnFrag(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision)
{
if (dataCollector.IsTemplate)
{
return(dataCollector.TemplateDataCollectorInstance.GetClipPos());
}
string vertexName = GenerateVertexPositionOnFrag(ref dataCollector, uniqueId, precision);
string value = string.Format("ComputeScreenPos( UnityObjectToClipPos( {0} ) )", vertexName);
dataCollector.AddToLocalVariables(uniqueId, precision, WirePortDataType.FLOAT4, ClipPositionStr, value);
return(ClipPositionStr);
}
// GRAB SCREEN POSITION
static public string GenerateGrabScreenPosition(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision, bool addInput = true, string customScreenPos = null)
{
string screenPos = string.Empty;
if (string.IsNullOrEmpty(customScreenPos))
{
screenPos = GenerateScreenPosition(ref dataCollector, uniqueId, precision, addInput);
}
else
{
screenPos = customScreenPos;
}
string computeBody = string.Empty;
IOUtils.AddFunctionHeader(ref computeBody, GrabFunctionHeader);
foreach (string line in GrabFunctionBody)
{
IOUtils.AddFunctionLine(ref computeBody, line);
}
IOUtils.CloseFunctionBody(ref computeBody);
string functionResult = dataCollector.AddFunctions(GrabFunctionCall, computeBody, screenPos);
dataCollector.AddLocalVariable(uniqueId, precision, WirePortDataType.FLOAT4, GrabScreenPositionStr, functionResult);
return(GrabScreenPositionStr);
}
// SCREEN DEPTH
static public string GenerateScreenDepthOnFrag(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision)
{
if (dataCollector.IsTemplate)
{
UnityEngine.Debug.LogWarning("Screen Depth not implemented on Templates");
}
string viewPos = GenerateViewPositionOnFrag(ref dataCollector, uniqueId, precision);
string value = string.Format("-{0}.z", viewPos);
dataCollector.AddToLocalVariables(uniqueId, precision, WirePortDataType.FLOAT, ScreenDepthStr, value);
return(ScreenDepthStr);
}
// GRAB SCREEN POSITION NORMALIZED
static public string GenerateGrabScreenPositionNormalized(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision, bool addInput = true, string customScreenPos = null)
{
string stringPosVar = GenerateGrabScreenPosition(ref dataCollector, uniqueId, precision, addInput, customScreenPos);
dataCollector.AddLocalVariable(uniqueId, string.Format("float4 {0} = {1} / {1}.w;", GrabScreenPositionNormalizedStr, stringPosVar));
return(GrabScreenPositionNormalizedStr);
}
// LIGHT DIRECTION Object
static public string GenerateObjectLightDirection(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision, string vertexPos)
{
dataCollector.AddToIncludes(uniqueId, Constants.UnityCgLibFuncs);
dataCollector.AddLocalVariable(uniqueId, precision, WirePortDataType.FLOAT3, ObjectLightDirStr, "normalize( ObjSpaceLightDir( " + vertexPos + " ) )");
return(ObjectLightDirStr);
}
// SCREEN POSITION ON VERT
static public string GenerateVertexScreenPositionForValue(string customVertexPosition, string outputId, ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision)
{
if (dataCollector.IsTemplate)
{
return(dataCollector.TemplateDataCollectorInstance.GetScreenPosForValue(customVertexPosition, outputId));
}
string screenPosVarName = ScreenPositionStr + outputId;
string value = string.Format("ComputeScreenPos( UnityObjectToClipPos( {0}.vertex ) )", Constants.VertexShaderInputStr);
dataCollector.AddToVertexLocalVariables(uniqueId, precision, WirePortDataType.FLOAT4, screenPosVarName, value);
return(screenPosVarName);
}
public static unsafe void GetShaderPrecisionFormat(this ArbES2Compatibility thisApi, [Flow(FlowDirection.In)] ShaderType shadertype, [Flow(FlowDirection.In)] PrecisionType precisiontype, [Count(Count = 2), Flow(FlowDirection.Out)] Span <int> range, [Count(Count = 1), Flow(FlowDirection.Out)] Span <int> precision)
{
// SpanOverloader
thisApi.GetShaderPrecisionFormat(shadertype, precisiontype, out range.GetPinnableReference(), out precision.GetPinnableReference());
}
static public string GenerateVertexScreenPosition(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision)
{
if (dataCollector.IsTemplate)
{
return(dataCollector.TemplateDataCollectorInstance.GetScreenPos());
}
string value = string.Format("ComputeScreenPos( UnityObjectToClipPos( {0}.vertex ) )", Constants.VertexShaderInputStr);
dataCollector.AddToVertexLocalVariables(uniqueId, precision, WirePortDataType.FLOAT4, ScreenPositionStr, value);
return(ScreenPositionStr);
}
public partial void GetShaderPrecisionFormat([Flow(FlowDirection.In)] ShaderType shadertype, [Flow(FlowDirection.In)] PrecisionType precisiontype, [Count(Count = 2), Flow(FlowDirection.Out)] out int range, [Count(Count = 1), Flow(FlowDirection.Out)] out int precision);
// VERTEX NORMAL
static public string GenerateVertexNormal(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision)
{
if (dataCollector.MasterNodeCategory == AvailableShaderTypes.Template)
{
return(dataCollector.TemplateDataCollectorInstance.GetVertexNormal(UIUtils.CurrentWindow.CurrentGraph.CurrentPrecision));
}
string value = Constants.VertexShaderInputStr + ".normal.xyz";
if (dataCollector.PortCategory == MasterNodePortCategory.Fragment || dataCollector.PortCategory == MasterNodePortCategory.Debug)
{
GenerateWorldNormal(ref dataCollector, uniqueId);
dataCollector.AddToLocalVariables(uniqueId, precision, WirePortDataType.FLOAT3, VertexNormalStr, "mul( unity_WorldToObject, float4( " + WorldNormalStr + ", 0 ) )");
}
else
{
dataCollector.AddLocalVariable(uniqueId, precision, WirePortDataType.FLOAT3, VertexNormalStr, value);
}
return(VertexNormalStr);
}
// TANGENT TO OBJECT
static public string GenerateTangentToObjectMatrix(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision)
{
string normal = GenerateVertexNormal(ref dataCollector, uniqueId, precision);
string tangent = GenerateVertexTangent(ref dataCollector, uniqueId, precision);
string bitangent = GenerateVertexBitangent(ref dataCollector, uniqueId, precision);
string.Format("{0}.x,{1}.x,{2}.x,{0}.y,{1}.y,{2}.y,{0}.z,{1}.z,{2}.z");
dataCollector.AddLocalVariable(uniqueId, precision, WirePortDataType.FLOAT3x3, TangentToWorldStr, "float3x3( " + tangent + ", " + bitangent + ", " + normal + " )");
return(TangentToObjectStr);
}
// VERTEX TANGENT SIGN
static public string GenerateVertexTangentSign(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision)
{
if (dataCollector.MasterNodeCategory == AvailableShaderTypes.Template)
{
return(dataCollector.TemplateDataCollectorInstance.GetTangentSign(UIUtils.CurrentWindow.CurrentGraph.CurrentPrecision));
}
string value = Constants.VertexShaderInputStr + ".tangent.w";
if (dataCollector.IsFragmentCategory)
{
dataCollector.AddToInput(uniqueId, VertexTangentSignStr, WirePortDataType.FLOAT, PrecisionType.Half);
dataCollector.AddToVertexLocalVariables(uniqueId, Constants.VertexShaderOutputStr + "." + VertexTangentSignStr + " = " + Constants.VertexShaderInputStr + ".tangent.w;");
return(Constants.InputVarStr + "." + VertexTangentSignStr);
}
else
{
dataCollector.AddLocalVariable(uniqueId, precision, WirePortDataType.FLOAT, VertexTangentSignStr, value);
}
return(VertexTangentSignStr);
}
public static void ModifiedTimeRange(DateTime Time, PrecisionType Precision, out DateTime ModifiedTimeStart, out DateTime ModifiedTimeEnd)
{
switch (Precision)
{
case PrecisionType.Ticks:
ModifiedTimeEnd = ModifiedTimeStart = new DateTime(Time.Ticks);
break;
case PrecisionType.Seconds:
ModifiedTimeStart = new DateTime(Time.Year, Time.Month, Time.Day, Time.Hour, Time.Minute, Time.Second + 0);
ModifiedTimeEnd = new DateTime(Time.Year, Time.Month, Time.Day, Time.Hour, Time.Minute, Time.Second + 1);
break;
case PrecisionType.Minutes:
ModifiedTimeStart = new DateTime(Time.Year, Time.Month, Time.Day, Time.Hour, Time.Minute + 0, 0);
ModifiedTimeEnd = new DateTime(Time.Year, Time.Month, Time.Day, Time.Hour, Time.Minute + 1, 0);
break;
case PrecisionType.Hours:
ModifiedTimeStart = new DateTime(Time.Year, Time.Month, Time.Day, Time.Hour + 0, 0, 0);
ModifiedTimeEnd = new DateTime(Time.Year, Time.Month, Time.Day, Time.Hour + 1, 0, 0);
break;
case PrecisionType.Days:
ModifiedTimeStart = new DateTime(Time.Year, Time.Month, Time.Day + 0);
ModifiedTimeEnd = new DateTime(Time.Year, Time.Month, Time.Day + 1);
break;
case PrecisionType.Months:
ModifiedTimeStart = new DateTime(Time.Year, Time.Month + 0, 0);
ModifiedTimeEnd = new DateTime(Time.Year, Time.Month + 1, 0);
break;
case PrecisionType.Years:
ModifiedTimeStart = new DateTime(Time.Year + 0, 0, 0);
ModifiedTimeEnd = new DateTime(Time.Year + 1, 0, 0);
break;
default:
ModifiedTimeStart = DateTime.MinValue;
ModifiedTimeEnd = DateTime.MaxValue;
break;
}
}
// VERTEX BITANGENT
static public string GenerateVertexBitangent(ref MasterNodeDataCollector dataCollector, int uniqueId, PrecisionType precision)
{
if (dataCollector.MasterNodeCategory == AvailableShaderTypes.Template)
{
return(dataCollector.TemplateDataCollectorInstance.GetVertexBitangent(UIUtils.CurrentWindow.CurrentGraph.CurrentPrecision));
}
if (dataCollector.PortCategory == MasterNodePortCategory.Fragment || dataCollector.PortCategory == MasterNodePortCategory.Debug)
{
GenerateWorldBitangent(ref dataCollector, uniqueId);
dataCollector.AddToLocalVariables(uniqueId, precision, WirePortDataType.FLOAT3, VertexBitangentStr, "mul( unity_WorldToObject, float4( " + WorldBitangentStr + ", 0 ) )");
}
else
{
GenerateVertexNormal(ref dataCollector, uniqueId, precision);
GenerateVertexTangent(ref dataCollector, uniqueId, precision);
dataCollector.AddLocalVariable(uniqueId, precision, WirePortDataType.FLOAT3, VertexBitangentStr, "cross( " + VertexNormalStr + ", " + VertexTangentStr + ") * " + Constants.VertexShaderInputStr + ".tangent.w * unity_WorldTransformParams.w");
}
return(VertexBitangentStr);
}
static DateTimeRange FromUnixTimestamp(long UnixTimestamp, PrecisionType Precision = PrecisionType.Seconds)
{
return new DateTimeRange(ConvertFromUnixTimestamp(UnixTimestamp), Precision);
}
public abstract unsafe void GetShaderPrecisionFormat([Flow(FlowDirection.In)] ShaderType shadertype, [Flow(FlowDirection.In)] PrecisionType precisiontype, [Count(Count = 2), Flow(FlowDirection.Out)] int *range, [Count(Count = 1), Flow(FlowDirection.Out)] int *precision);
