Example #1
0
        public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalVar)
        {
            if (dataCollector.IsTemplate)
            {
                string varName = (m_viewDirSpace == ViewSpace.World) ? dataCollector.TemplateDataCollectorInstance.GetViewDir(true, MasterNodePortCategory.Fragment, m_safeNormalize?NormalizeType.Safe:NormalizeType.Regular) :
                                 dataCollector.TemplateDataCollectorInstance.GetTangentViewDir(m_currentPrecisionType, true, MasterNodePortCategory.Fragment, m_safeNormalize ? NormalizeType.Safe : NormalizeType.Regular);
                return(GetOutputVectorItem(0, outputId, varName));
            }


            if (dataCollector.PortCategory == MasterNodePortCategory.Vertex || dataCollector.PortCategory == MasterNodePortCategory.Tessellation)
            {
                string result = GeneratorUtils.GenerateViewDirection(ref dataCollector, UniqueId, m_viewDirSpace);
                return(GetOutputVectorItem(0, outputId, result));
            }
            else
            {
                if (m_viewDirSpace == ViewSpace.World)
                {
                    if (dataCollector.DirtyNormal || m_safeNormalize)
                    {
                        dataCollector.AddToInput(UniqueId, SurfaceInputs.WORLD_POS);
                        string result = GeneratorUtils.GenerateViewDirection(ref dataCollector, UniqueId);
                        return(GetOutputVectorItem(0, outputId, result));
                    }
                    else
                    {
                        dataCollector.AddToInput(UniqueId, SurfaceInputs.VIEW_DIR, PrecisionType.Float);
                        return(GetOutputVectorItem(0, outputId, m_currentInputValueStr));
                        //return base.GenerateShaderForOutput( outputId, ref dataCollector, ignoreLocalVar );
                    }
                }
                else
                {
                    if (m_safeNormalize)
                    {
                        dataCollector.AddToInput(UniqueId, SurfaceInputs.WORLD_NORMAL, m_currentPrecisionType);
                        dataCollector.AddToInput(UniqueId, SurfaceInputs.INTERNALDATA, addSemiColon: false);
                        dataCollector.ForceNormal = true;
                        dataCollector.AddToInput(UniqueId, SurfaceInputs.WORLD_POS);
                        string result = GeneratorUtils.GenerateViewDirection(ref dataCollector, UniqueId, ViewSpace.Tangent);
                        return(GetOutputVectorItem(0, outputId, result));
                    }
                    else
                    {
                        dataCollector.ForceNormal = true;
                        return(base.GenerateShaderForOutput(outputId, ref dataCollector, ignoreLocalVar));
                    }
                }
            }
        }
Example #2
0
        public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalVar)
        {
            if (dataCollector.IsTemplate)
            {
                string varName = (m_viewDirSpace == ViewSpace.World)? dataCollector.TemplateDataCollectorInstance.GetNormalizedViewDir():
                                 dataCollector.TemplateDataCollectorInstance.GetTangenViewDir();
                return(GetOutputVectorItem(0, outputId, varName));
            }


            if (dataCollector.PortCategory == MasterNodePortCategory.Vertex || dataCollector.PortCategory == MasterNodePortCategory.Tessellation)
            {
                string result = GeneratorUtils.GenerateViewDirection(ref dataCollector, UniqueId, m_viewDirSpace);
                return(GetOutputVectorItem(0, outputId, result));
            }
            else
            {
                if (m_viewDirSpace == ViewSpace.World)
                {
                    if (dataCollector.DirtyNormal)
                    {
                        dataCollector.AddToInput(UniqueId, SurfaceInputs.WORLD_POS);
                        string result = GeneratorUtils.GenerateViewDirection(ref dataCollector, UniqueId);
                        return(GetOutputVectorItem(0, outputId, result));
                    }
                    else
                    {
                        dataCollector.AddToInput(UniqueId, SurfaceInputs.VIEW_DIR, PrecisionType.Float);
                        return(GetOutputVectorItem(0, outputId, m_currentInputValueStr));
                        //return base.GenerateShaderForOutput( outputId, ref dataCollector, ignoreLocalVar );
                    }
                }
                else
                {
                    dataCollector.ForceNormal = true;
                    return(base.GenerateShaderForOutput(outputId, ref dataCollector, ignoreLocalVar));
                }
            }
        }
        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 (dataCollector.IsTemplate)
            {
                dataCollector.AddToIncludes(UniqueId, Constants.UnityLightingLib);
                //string worldPos = dataCollector.TemplateDataCollectorInstance.GetWorldPos();
                string worldViewDir = dataCollector.TemplateDataCollectorInstance.GetViewDir(false, MasterNodePortCategory.Fragment);
                //string worldNormal = dataCollector.TemplateDataCollectorInstance.GetWorldNormal( PrecisionType.Float );

                string worldNormal = string.Empty;
                if (m_inputPorts[0].IsConnected)
                {
                    if (m_normalSpace == ViewSpace.Tangent)
                    {
                        worldNormal = dataCollector.TemplateDataCollectorInstance.GetWorldNormal(UniqueId, m_currentPrecisionType, m_inputPorts[0].GeneratePortInstructions(ref dataCollector), OutputId);
                    }
                    else
                    {
                        worldNormal = m_inputPorts[0].GeneratePortInstructions(ref dataCollector);
                    }
                }
                else
                {
                    worldNormal = dataCollector.TemplateDataCollectorInstance.GetWorldNormal(PrecisionType.Float, false, MasterNodePortCategory.Fragment);
                }

                string tempsmoothness = m_inputPorts[1].GeneratePortInstructions(ref dataCollector);
                string tempocclusion  = m_inputPorts[2].GeneratePortInstructions(ref dataCollector);

                dataCollector.AddLocalVariable(UniqueId, "UnityGIInput data;");
                dataCollector.AddLocalVariable(UniqueId, "UNITY_INITIALIZE_OUTPUT( UnityGIInput, data );");
                //dataCollector.AddLocalVariable( UniqueId, "data.worldPos = " + worldPos + ";" );
                //dataCollector.AddLocalVariable( UniqueId, "data.worldViewDir = " + worldViewDir + ";" );
                dataCollector.AddLocalVariable(UniqueId, "data.probeHDR[0] = unity_SpecCube0_HDR;");
                dataCollector.AddLocalVariable(UniqueId, "data.probeHDR[1] = unity_SpecCube1_HDR;");
                dataCollector.AddLocalVariable(UniqueId, "#if UNITY_SPECCUBE_BLENDING || UNITY_SPECCUBE_BOX_PROJECTION //specdataif0");
                dataCollector.AddLocalVariable(UniqueId, "\tdata.boxMin[0] = unity_SpecCube0_BoxMin;");
                dataCollector.AddLocalVariable(UniqueId, "#endif //specdataif0");
                dataCollector.AddLocalVariable(UniqueId, "#if UNITY_SPECCUBE_BOX_PROJECTION //specdataif1");
                dataCollector.AddLocalVariable(UniqueId, "\tdata.boxMax[0] = unity_SpecCube0_BoxMax;");
                dataCollector.AddLocalVariable(UniqueId, "\tdata.probePosition[0] = unity_SpecCube0_ProbePosition;");
                dataCollector.AddLocalVariable(UniqueId, "\tdata.boxMax[1] = unity_SpecCube1_BoxMax;");
                dataCollector.AddLocalVariable(UniqueId, "\tdata.boxMin[1] = unity_SpecCube1_BoxMin;");
                dataCollector.AddLocalVariable(UniqueId, "\tdata.probePosition[1] = unity_SpecCube1_ProbePosition;");
                dataCollector.AddLocalVariable(UniqueId, "#endif //specdataif1");

                dataCollector.AddLocalVariable(UniqueId, "Unity_GlossyEnvironmentData g" + OutputId + " = UnityGlossyEnvironmentSetup( " + tempsmoothness + ", " + worldViewDir + ", " + worldNormal + ", float3(0,0,0));");
                dataCollector.AddLocalVariable(UniqueId, m_currentPrecisionType, WirePortDataType.FLOAT3, "indirectSpecular" + OutputId, "UnityGI_IndirectSpecular( data, " + tempocclusion + ", " + worldNormal + ", g" + OutputId + " )");
                return("indirectSpecular" + OutputId);
            }

            if (dataCollector.GenType == PortGenType.NonCustomLighting || dataCollector.CurrentCanvasMode != NodeAvailability.CustomLighting)
            {
                return("float3(0,0,0)");
            }

            string normal = string.Empty;

            if (m_inputPorts[0].IsConnected)
            {
                dataCollector.AddToInput(UniqueId, SurfaceInputs.WORLD_NORMAL, m_currentPrecisionType);
                dataCollector.AddToInput(UniqueId, SurfaceInputs.INTERNALDATA, addSemiColon: false);
                dataCollector.ForceNormal = true;

                normal = m_inputPorts[0].GeneratePortInstructions(ref dataCollector);
                if (m_normalSpace == ViewSpace.Tangent)
                {
                    normal = "WorldNormalVector( " + Constants.InputVarStr + " , " + normal + " )";
                }

                dataCollector.AddLocalVariable(UniqueId, "float3 indirectNormal" + OutputId + " = " + normal + ";");
                normal = "indirectNormal" + OutputId;
            }
            else
            {
                if (dataCollector.IsFragmentCategory)
                {
                    dataCollector.AddToInput(UniqueId, SurfaceInputs.WORLD_NORMAL, m_currentPrecisionType);
                    if (dataCollector.DirtyNormal)
                    {
                        dataCollector.AddToInput(UniqueId, SurfaceInputs.INTERNALDATA, addSemiColon: false);
                        dataCollector.ForceNormal = true;
                    }
                }

                normal = GeneratorUtils.GenerateWorldNormal(ref dataCollector, UniqueId);
            }

            string smoothness = m_inputPorts[1].GeneratePortInstructions(ref dataCollector);
            string occlusion  = m_inputPorts[2].GeneratePortInstructions(ref dataCollector);
            string viewDir    = "data.worldViewDir";

            if (dataCollector.PortCategory == MasterNodePortCategory.Vertex || dataCollector.PortCategory == MasterNodePortCategory.Tessellation)
            {
                string worldPos = GeneratorUtils.GenerateWorldPosition(ref dataCollector, UniqueId);
                viewDir = GeneratorUtils.GenerateViewDirection(ref dataCollector, UniqueId);

                dataCollector.AddLocalVariable(UniqueId, "UnityGIInput data;");
                dataCollector.AddLocalVariable(UniqueId, "UNITY_INITIALIZE_OUTPUT( UnityGIInput, data );");
                dataCollector.AddLocalVariable(UniqueId, "data.worldPos = " + worldPos + ";");
                dataCollector.AddLocalVariable(UniqueId, "data.worldViewDir = " + viewDir + ";");
                dataCollector.AddLocalVariable(UniqueId, "data.probeHDR[0] = unity_SpecCube0_HDR;");
                dataCollector.AddLocalVariable(UniqueId, "data.probeHDR[1] = unity_SpecCube1_HDR;");
                dataCollector.AddLocalVariable(UniqueId, "#if UNITY_SPECCUBE_BLENDING || UNITY_SPECCUBE_BOX_PROJECTION //specdataif0");
                dataCollector.AddLocalVariable(UniqueId, "data.boxMin[0] = unity_SpecCube0_BoxMin;");
                dataCollector.AddLocalVariable(UniqueId, "#endif //specdataif0");
                dataCollector.AddLocalVariable(UniqueId, "#if UNITY_SPECCUBE_BOX_PROJECTION //specdataif1");
                dataCollector.AddLocalVariable(UniqueId, "data.boxMax[0] = unity_SpecCube0_BoxMax;");
                dataCollector.AddLocalVariable(UniqueId, "data.probePosition[0] = unity_SpecCube0_ProbePosition;");
                dataCollector.AddLocalVariable(UniqueId, "data.boxMax[1] = unity_SpecCube1_BoxMax;");
                dataCollector.AddLocalVariable(UniqueId, "data.boxMin[1] = unity_SpecCube1_BoxMin;");
                dataCollector.AddLocalVariable(UniqueId, "data.probePosition[1] = unity_SpecCube1_ProbePosition;");
                dataCollector.AddLocalVariable(UniqueId, "#endif //specdataif1");
            }

            dataCollector.AddLocalVariable(UniqueId, "Unity_GlossyEnvironmentData g" + OutputId + " = UnityGlossyEnvironmentSetup( " + smoothness + ", " + viewDir + ", " + normal + ", float3(0,0,0));");
            dataCollector.AddLocalVariable(UniqueId, m_currentPrecisionType, WirePortDataType.FLOAT3, "indirectSpecular" + OutputId, "UnityGI_IndirectSpecular( data, " + occlusion + ", " + normal + ", g" + OutputId + " )");

            return("indirectSpecular" + OutputId);
        }
Example #5
0
        public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar)
        {
            if (m_outputPorts[0].IsLocalValue)
            {
                return(m_outputPorts[0].LocalValue);
            }

            if (dataCollector.IsFragmentCategory)
            {
                dataCollector.AddToInput(UniqueId, SurfaceInputs.WORLD_POS);
            }

            string viewdir = GeneratorUtils.GenerateViewDirection(ref dataCollector, UniqueId, ViewSpace.World);

            string normal = string.Empty;

            if (m_inputPorts[0].IsConnected)
            {
                normal = m_inputPorts[0].GenerateShaderForOutput(ref dataCollector, WirePortDataType.FLOAT3, ignoreLocalvar, true);

                if (dataCollector.IsFragmentCategory)
                {
                    dataCollector.AddToInput(UniqueId, SurfaceInputs.INTERNALDATA, addSemiColon: false);

                    if (m_normalSpace == ViewSpace.Tangent)
                    {
                        dataCollector.AddToInput(UniqueId, SurfaceInputs.WORLD_NORMAL, m_currentPrecisionType);
                        dataCollector.ForceNormal = true;
                        normal = "WorldNormalVector( " + Constants.InputVarStr + " , " + normal + " )";
                    }
                }
                else
                {
                    if (m_normalSpace == ViewSpace.Tangent)
                    {
                        string wtMatrix = GeneratorUtils.GenerateWorldToTangentMatrix(ref dataCollector, UniqueId, m_currentPrecisionType);
                        normal = "mul( " + normal + "," + wtMatrix + " )";
                    }
                }
            }
            else
            {
                if (dataCollector.IsFragmentCategory)
                {
                    dataCollector.AddToInput(UniqueId, SurfaceInputs.WORLD_NORMAL, m_currentPrecisionType);
                    if (dataCollector.DirtyNormal)
                    {
                        dataCollector.AddToInput(UniqueId, SurfaceInputs.INTERNALDATA, addSemiColon: false);
                    }
                }

                normal = dataCollector.IsTemplate ? dataCollector.TemplateDataCollectorInstance.GetWorldNormal() : GeneratorUtils.GenerateWorldNormal(ref dataCollector, UniqueId);
            }

            string bias  = m_inputPorts[1].GenerateShaderForOutput(ref dataCollector, WirePortDataType.FLOAT, ignoreLocalvar, true);
            string scale = m_inputPorts[2].GenerateShaderForOutput(ref dataCollector, WirePortDataType.FLOAT, ignoreLocalvar, true);
            string power = m_inputPorts[3].GenerateShaderForOutput(ref dataCollector, WirePortDataType.FLOAT, ignoreLocalvar, true);

            string fresnelNDotVLocalValue = "dot( " + normal + ", " + viewdir + " )";
            string fresnelNDotVLocalVar   = "fresnelNDotV" + OutputId;

            dataCollector.AddLocalVariable(UniqueId, m_currentPrecisionType, WirePortDataType.FLOAT, fresnelNDotVLocalVar, fresnelNDotVLocalValue);

            string fresnelFinalVar = FresnedFinalVar + OutputId;
            string result          = string.Format("( {0} + {1} * pow( 1.0 - {2}, {3} ) )", bias, scale, fresnelNDotVLocalVar, power);

            RegisterLocalVariable(0, result, ref dataCollector, fresnelFinalVar);
            return(m_outputPorts[0].LocalValue);
        }
Example #6
0
        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));
        }
Example #7
0
        public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalVar)
        {
            if (dataCollector.IsTemplate)
            {
                if (m_inputPorts[0].IsConnected)
                {
                    if (m_outputPorts[0].IsLocalValue)
                    {
                        return(m_outputPorts[0].LocalValue);
                    }


                    string value = dataCollector.TemplateDataCollectorInstance.GetWorldReflection(m_inputPorts[0].GeneratePortInstructions(ref dataCollector));
                    RegisterLocalVariable(0, value, ref dataCollector, "worldRefl" + OutputId);
                    return(m_outputPorts[0].LocalValue);
                }
                else
                {
                    return(GetOutputVectorItem(0, outputId, dataCollector.TemplateDataCollectorInstance.GetWorldReflection()));
                }
            }

            bool isVertex = (dataCollector.PortCategory == MasterNodePortCategory.Tessellation || dataCollector.PortCategory == MasterNodePortCategory.Vertex);

            if (isVertex)
            {
                if (m_inputPorts[0].IsConnected)
                {
                    if (m_outputPorts[0].IsLocalValue)
                    {
                        return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue));
                    }

                    string normal  = GeneratorUtils.GenerateWorldNormal(ref dataCollector, UniqueId);
                    string tangent = GeneratorUtils.GenerateWorldTangent(ref dataCollector, UniqueId);
                    dataCollector.AddToVertexLocalVariables(UniqueId, "float3x3 tangentToWorld = CreateTangentToWorldPerVertex( " + normal + ", " + tangent + ", " + Constants.VertexShaderInputStr + ".tangent.w );");
                    string inputTangent = m_inputPorts[0].GeneratePortInstructions(ref dataCollector);
                    dataCollector.AddToVertexLocalVariables(UniqueId, "float3 tangentNormal" + OutputId + " = " + inputTangent + ";");

                    string viewDir = GeneratorUtils.GenerateViewDirection(ref dataCollector, UniqueId);
                    dataCollector.AddToVertexLocalVariables(UniqueId, "float3 modWorldNormal" + OutputId + " = ( tangentToWorld[0] * tangentNormal" + OutputId + ".x + tangentToWorld[1] * tangentNormal" + OutputId + ".y + tangentToWorld[2] * tangentNormal" + OutputId + ".z);");

                    RegisterLocalVariable(0, "reflect( -" + viewDir + ", modWorldNormal" + OutputId + " )", ref dataCollector, "modReflection" + OutputId);
                    return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue));
                }
                else
                {
                    if (m_outputPorts[0].IsLocalValue)
                    {
                        return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue));
                    }

                    string worldNormal = GeneratorUtils.GenerateWorldNormal(ref dataCollector, UniqueId);
                    string viewDir     = GeneratorUtils.GenerateViewDirection(ref dataCollector, UniqueId);

                    RegisterLocalVariable(0, "reflect( -" + viewDir + ", " + worldNormal + " )", ref dataCollector, ReflectionVecValStr + OutputId);
                    return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue));
                }
            }
            else
            {
                if (m_outputPorts[0].IsLocalValue)
                {
                    return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue));
                }

                dataCollector.AddToInput(UniqueId, SurfaceInputs.WORLD_REFL, m_currentPrecisionType);

                string result = string.Empty;
                if (m_inputPorts[0].IsConnected)
                {
                    dataCollector.AddToInput(UniqueId, SurfaceInputs.INTERNALDATA, addSemiColon: false);
                    dataCollector.ForceNormal = true;

                    result = "WorldReflectionVector( " + Constants.InputVarStr + " , " + m_inputPorts[0].GenerateShaderForOutput(ref dataCollector, WirePortDataType.FLOAT3, ignoreLocalVar) + " )";

                    int connCount = 0;
                    for (int i = 0; i < m_outputPorts.Count; i++)
                    {
                        connCount += m_outputPorts[i].ConnectionCount;
                    }

                    if (connCount > 1 || outputId > 0)
                    {
                        dataCollector.AddToLocalVariables(UniqueId, string.Format(ReflectionVecDecStr, ReflectionVecValStr + OutputId, result));

                        RegisterLocalVariable(0, result, ref dataCollector, ReflectionVecValStr + OutputId);
                        return(GetOutputVectorItem(0, outputId, m_outputPorts[0].LocalValue));
                    }
                }
                else
                {
                    dataCollector.AddToInput(UniqueId, SurfaceInputs.INTERNALDATA, addSemiColon: false);
                    result = GeneratorUtils.GenerateWorldReflection(ref dataCollector, UniqueId);
                }

                return(GetOutputVectorItem(0, outputId, result));
                //RegisterLocalVariable( 0, result, ref dataCollector, "worldrefVec" + OutputId );
                //return GetOutputVectorItem( 0, outputId, m_outputPorts[ 0 ].LocalValue );
            }
        }
Example #8
0
        public override string GenerateShaderForOutput(int outputId, ref MasterNodeDataCollector dataCollector, bool ignoreLocalvar)
        {
            if (dataCollector.CurrentCanvasMode != NodeAvailability.CustomLighting)
            {
                return("float3(0,0,0)");
            }

            string normal = string.Empty;

            if (m_inputPorts[0].IsConnected)
            {
                dataCollector.AddToInput(UniqueId, UIUtils.GetInputDeclarationFromType(m_currentPrecisionType, AvailableSurfaceInputs.WORLD_NORMAL), true);
                dataCollector.AddToInput(UniqueId, Constants.InternalData, false);
                dataCollector.ForceNormal = true;

                normal = m_inputPorts[0].GenerateShaderForOutput(ref dataCollector, WirePortDataType.FLOAT3, ignoreLocalvar);
                if (m_normalSpace == ViewSpace.Tangent)
                {
                    normal = "WorldNormalVector( " + Constants.InputVarStr + " , " + normal + " )";
                }

                dataCollector.AddLocalVariable(UniqueId, "float3 indirectNormal" + OutputId + " = " + normal + ";");
                normal = "indirectNormal" + OutputId;
            }
            else
            {
                if (dataCollector.IsFragmentCategory)
                {
                    dataCollector.AddToInput(UniqueId, UIUtils.GetInputDeclarationFromType(m_currentPrecisionType, AvailableSurfaceInputs.WORLD_NORMAL), true);
                }

                normal = GeneratorUtils.GenerateWorldNormal(ref dataCollector, UniqueId);
            }

            string roughness = m_inputPorts[1].GeneratePortInstructions(ref dataCollector);
            string occlusion = m_inputPorts[2].GeneratePortInstructions(ref dataCollector);
            string viewDir   = "data.worldViewDir";

            if (dataCollector.PortCategory == MasterNodePortCategory.Vertex || dataCollector.PortCategory == MasterNodePortCategory.Tessellation)
            {
                string worldPos = GeneratorUtils.GenerateWorldPosition(ref dataCollector, UniqueId);
                viewDir = GeneratorUtils.GenerateViewDirection(ref dataCollector, UniqueId);

                dataCollector.AddLocalVariable(UniqueId, "UnityGIInput data;");
                dataCollector.AddLocalVariable(UniqueId, "UNITY_INITIALIZE_OUTPUT( UnityGIInput, data );");
                dataCollector.AddLocalVariable(UniqueId, "data.worldPos = " + worldPos + ";");
                dataCollector.AddLocalVariable(UniqueId, "data.worldViewDir = " + viewDir + ";");
                dataCollector.AddLocalVariable(UniqueId, "data.probeHDR[0] = unity_SpecCube0_HDR;");
                dataCollector.AddLocalVariable(UniqueId, "data.probeHDR[1] = unity_SpecCube1_HDR;");
                dataCollector.AddLocalVariable(UniqueId, "#if UNITY_SPECCUBE_BLENDING || UNITY_SPECCUBE_BOX_PROJECTION //specdataif0");
                dataCollector.AddLocalVariable(UniqueId, "data.boxMin[0] = unity_SpecCube0_BoxMin;");
                dataCollector.AddLocalVariable(UniqueId, "#endif //specdataif0");
                dataCollector.AddLocalVariable(UniqueId, "#if UNITY_SPECCUBE_BOX_PROJECTION //specdataif1");
                dataCollector.AddLocalVariable(UniqueId, "data.boxMax[0] = unity_SpecCube0_BoxMax;");
                dataCollector.AddLocalVariable(UniqueId, "data.probePosition[0] = unity_SpecCube0_ProbePosition;");
                dataCollector.AddLocalVariable(UniqueId, "data.boxMax[1] = unity_SpecCube1_BoxMax;");
                dataCollector.AddLocalVariable(UniqueId, "data.boxMin[1] = unity_SpecCube1_BoxMin;");
                dataCollector.AddLocalVariable(UniqueId, "data.probePosition[1] = unity_SpecCube1_ProbePosition;");
                dataCollector.AddLocalVariable(UniqueId, "#endif //specdataif1");
            }

            dataCollector.AddLocalVariable(UniqueId, "Unity_GlossyEnvironmentData g" + OutputId + ";");
            dataCollector.AddLocalVariable(UniqueId, "g" + OutputId + ".roughness = " + roughness + ";");
            dataCollector.AddLocalVariable(UniqueId, "g" + OutputId + ".reflUVW = reflect( -" + viewDir + ", " + normal + " );");
            dataCollector.AddLocalVariable(UniqueId, m_currentPrecisionType, WirePortDataType.FLOAT3, "indirectSpecular" + OutputId, "UnityGI_IndirectSpecular( data, " + occlusion + ", " + normal + ", g" + OutputId + " )");

            return("indirectSpecular" + OutputId);
        }
        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));
        }