GenerateConnectorType() public method

public GenerateConnectorType ( MidElementDecl element ) : ConnectorTypeHLSL
element MidElementDecl
return ConnectorTypeHLSL
        public override void EmitImplSetup()
        {
            var constantElement = GetElement("Constant");
            var uniformElement = GetElement("Uniform");
            var coarseVertexElement = GetElement("CoarseVertex");

            InitBlock.AppendComment("D3D11 Hull Shader");

            var tessEnabledAttr = FindAttribute( constantElement, "__D3D11TessellationEnabled" );
            if( tessEnabledAttr == null )
            {
                return;
            }

            var superPatchElement = GetElement( "__InputPatch" );
            var inputPatchElement = GetElement( "InputPatch" );
            var outputPatchElement = GetElement( "OutputPatch" );
            var controlPointElement = GetElement( "ControlPoint" );

            var patchEdgeElement = GetElement( "PatchEdge" );
            var patchCornerElement = GetElement( "PatchCorner" );
            var patchInteriorElement = GetElement( "PatchInterior" );

            hlslContext = new EmitContextHLSL(SharedHLSL, Range, this.EmitClass.GetName());
            var entryPointSpan = hlslContext.EntryPointSpan;
            entryPointSpan = hlslContext.PushErrorMask(entryPointSpan, "X3550");

            var inputCoarseVertexCount = GetAttribute(constantElement, "HS_InputCoarseVertexCount");
            var outputControlPointCount = GetAttribute(constantElement, "HS_OutputControlPointCount");

            var tsDomain = GetAttribute(constantElement, "TS_Domain");
            var tsPartitioning = GetAttribute(constantElement, "TS_Partitioning");
            var tsOutputTopology = GetAttribute(constantElement, "TS_OutputTopology");
            var tsMaxTessFactor = GetAttribute(constantElement, "TS_MaxTessFactor");

            var hsPatchEdgeCount = GetAttribute(constantElement, "HS_PatchEdgeCount");
            var hsPatchInsideCount = GetAttribute(constantElement, "HS_PatchInsideCount");
            var hsPatchCornerCount = GetAttribute(constantElement, "HS_PatchCornerCount");

            var hsCullPatchAttr = GetAttribute(outputPatchElement, "HS_CullPatch");

            hlslContext.GenerateConnectorType(coarseVertexElement);
            hlslContext.GenerateConnectorType(controlPointElement);
            hlslContext.GenerateConnectorType(outputPatchElement);

            // OutputPatch entry point

            var outputPatchConnector = hlslContext.GenerateConnectorType(outputPatchElement);
            entryPointSpan.WriteLine("{0} __patchMain(",
                outputPatchConnector);

            bool first = true;
            hlslContext.DeclareParamAndBind(
                GetAttribute(superPatchElement, "HS_InputCoarseVertices"),
                null,
                ref first,
                entryPointSpan);

            // \todo:
            // @OutputPatch Array[ControlPoint, HS_OutputControlPointCount] HS_OutputControlPoints

            hlslContext.DeclareParamAndBind(
                GetAttribute(superPatchElement, "HS_PatchID"),
                "SV_PrimitiveID",
                ref first,
                entryPointSpan);

            entryPointSpan.WriteLine("\t)");
            entryPointSpan.WriteLine("{");

            // Declare the output patch variable, but don't initialize it
            var outputPatch = outputPatchConnector.CreateVal( "HS_OutputPatch" );
            hlslContext.DeclareLocal( outputPatch, entryPointSpan );

            // Do any input-patch initialization stuff
            var ip2op = hlslContext.EmitTempRecordCtor(
                entryPointSpan,
                inputPatchElement,
                GetAttribute(outputPatchElement, "__ip2op"));

            // Iterate over the corners of the patch, and initialize each
            entryPointSpan.WriteLine( "for( uint HS_CornerID = 0; HS_CornerID < {0}; HS_CornerID++ )",
                hlslContext.EmitAttribRef( hsPatchCornerCount, null ) );
            entryPointSpan.WriteLine("{" );

            hlslContext.BindAttr(
                GetAttribute( patchCornerElement, "__ip2pc" ),
                ip2op );

            var patchCornerIDAttr = GetAttribute( patchCornerElement, "HS_PatchCornerID" );
            var hsCornerIDVal = new SimpleValHLSL( "HS_CornerID",
                    (RealTypeHLSL) hlslContext.EmitType( patchCornerIDAttr.Type ) );
            hlslContext.BindAttr(
                patchCornerIDAttr,
                hsCornerIDVal );

            var hsPatchCornersAttr = GetAttribute( outputPatchElement, "HS_PatchCorners" );
            var hsPatchCornersVal = hlslContext.FetchAttr(
                outputPatch,
                hsPatchCornersAttr.Attribute,
                entryPointSpan );
            hlslContext.BindAttr(hsPatchCornersAttr, hsPatchCornersVal);
            var hsPatchCornerVal = hlslContext.GetElem(
                hsPatchCornersVal,
                hsCornerIDVal);

            hlslContext.InitRecord(
                entryPointSpan,
                patchCornerElement,
                hsPatchCornerVal );

            entryPointSpan.WriteLine( "}" );

            entryPointSpan.WriteLine( "for( uint HS_EdgeID = 0; HS_EdgeID < {0}; HS_EdgeID++ )",
                hlslContext.EmitAttribRef(hsPatchEdgeCount, null));
            entryPointSpan.WriteLine( "{" );

            hlslContext.BindAttr(
                GetAttribute(patchEdgeElement, "__ip2pe"),
                ip2op);

            hlslContext.BindAttr(
                GetAttribute(patchEdgeElement, "__op2pe"),
                outputPatch);

            var patchEdgeIDAttr = GetAttribute(patchEdgeElement, "HS_PatchEdgeID");
            var hsEdgeIDVal = new SimpleValHLSL("HS_EdgeID",
                (RealTypeHLSL)hlslContext.EmitType(patchEdgeIDAttr.Type));
            hlslContext.BindAttr(
                patchEdgeIDAttr,
                hsEdgeIDVal );

            var hsPatchEdgesAttr = GetAttribute(outputPatchElement, "HS_PatchEdges");
            var hsPatchEdgesVal = hlslContext.FetchAttr(
                outputPatch,
                hsPatchEdgesAttr.Attribute,
                entryPointSpan );
            hlslContext.BindAttr(hsPatchEdgesAttr, hsPatchEdgesVal);
            var hsPatchEdgeVal = hlslContext.GetElem(
                hsPatchEdgesVal,
                hsEdgeIDVal);
            hlslContext.InitRecord(
                entryPointSpan,
                patchEdgeElement,
                hsPatchEdgeVal);

            var hsEdgeFactorSrcVal = hlslContext.FetchAttr(
                hsPatchEdgeVal,
                GetAttribute(patchEdgeElement, "HS_EdgeFactor").Attribute,
                entryPointSpan);

            var hsEdgeFactorsAttr = GetAttribute(outputPatchElement, "HS_EdgeFactors").Attribute;
            var hsEdgeFactorsVal = hlslContext.FetchAttr(
                outputPatch,
                hsEdgeFactorsAttr,
                entryPointSpan);
            hlslContext.BindAttr(hsEdgeFactorsAttr, hsEdgeFactorsVal);
            var hsEdgeFactorDstVal = hlslContext.GetElem(
                hsEdgeFactorsVal,
                hsEdgeIDVal);
            hlslContext.Assign(
                hsEdgeFactorDstVal,
                hsEdgeFactorSrcVal,
                entryPointSpan);
            entryPointSpan.WriteLine("}");

            var hsPatchInsideCountStr = hlslContext.EmitAttribRef(hsPatchInsideCount, null).ToString();
            var onlyOneInside = hsPatchInsideCountStr == "1";

            if (!onlyOneInside)
            {
                entryPointSpan.WriteLine("for( uint HS_InsideID = 0; HS_InsideID < {0}; HS_InsideID++ )",
                    hlslContext.EmitAttribRef(hsPatchInsideCount, null));
                entryPointSpan.WriteLine("{");
            }
            else
            {
                entryPointSpan.WriteLine("uint HS_InsideID = 0;");
            }

            hlslContext.BindAttr(
                GetAttribute(patchInteriorElement, "__ip2pi"),
                ip2op);

            hlslContext.BindAttr(
                GetAttribute(patchInteriorElement, "__op2pi"),
                outputPatch);

            var hsPatchInsideIDAttr = GetAttribute(patchInteriorElement, "HS_PatchInteriorID");
            var hsInsideIDVal = new SimpleValHLSL("HS_InsideID",
                (RealTypeHLSL)hlslContext.EmitType(hsPatchInsideIDAttr.Type));
            hlslContext.BindAttr(
                hsPatchInsideIDAttr,
                hsInsideIDVal);

            var hsPatchInteriorsAttr = GetAttribute(outputPatchElement, "HS_PatchInteriors");
            var hsPatchInteriorsVal = hlslContext.FetchAttr(
                outputPatch,
                hsPatchInteriorsAttr.Attribute,
                entryPointSpan);
            hlslContext.BindAttr(hsPatchInteriorsAttr, hsPatchInteriorsVal);

            var hsPatchInteriorVal = hlslContext.GetElem(
                hsPatchInteriorsVal,
                hsInsideIDVal);
            hlslContext.InitRecord(
                entryPointSpan,
                patchInteriorElement,
                hsPatchInteriorVal);

            var hsInsideFactorSrcVal = hlslContext.FetchAttr(
                hsPatchInteriorVal,
                GetAttribute(patchInteriorElement, "HS_InsideFactor").Attribute,
                entryPointSpan);

            var hsInsideFactorsAttr = GetAttribute(outputPatchElement, "HS_InsideFactors").Attribute;
            var hsInsideFactorsVal = hlslContext.FetchAttr(
                outputPatch,
                hsInsideFactorsAttr,
                entryPointSpan);
            hlslContext.BindAttr(hsInsideFactorsAttr, hsInsideFactorsVal);
            var hsInsideFactorDstVal = hlslContext.GetElem(
                hsInsideFactorsVal,
                hsInsideIDVal);
            hlslContext.Assign(
                hsInsideFactorDstVal,
                hsInsideFactorSrcVal,
                entryPointSpan);

            if (!onlyOneInside)
            {
                entryPointSpan.WriteLine("}");
            }

            hlslContext.InitRecord(
                entryPointSpan,
                outputPatchElement,
                outputPatch);

            var hsCullPatchVal = hlslContext.EmitAttribRef(hsCullPatchAttr, entryPointSpan);

            entryPointSpan.WriteLine("if( {0} )", hsCullPatchVal);
            entryPointSpan.WriteLine("{");

            var hsEdgeFactor0Val = hlslContext.GetElem(
                hsEdgeFactorsVal,
                new SimpleValHLSL("0", new ScalarTypeHLSL("int")));
            hlslContext.Assign(
                hsEdgeFactor0Val,
                new SimpleValHLSL("0.0f", new ScalarTypeHLSL("float")),
                entryPointSpan);

            entryPointSpan.WriteLine("}");

            entryPointSpan.WriteLine( "\treturn {0};", outputPatch );

            entryPointSpan.WriteLine("}");

            // ControlPoint entry point

            foreach (var a in inputPatchElement.Attributes)
                hlslContext.UnbindAttribute(a);

            // Bind a bunch of attributes that really represent constants:
            hlslContext.BindAttrLit(
                GetAttribute(constantElement, "TriangleDomain"),
                "tri");
            hlslContext.BindAttrLit(
                GetAttribute(constantElement, "QuadDomain"),
                "quad");
            hlslContext.BindAttrLit(
                GetAttribute(constantElement, "FractionalOddPartitioning"),
                "fractional_odd");
            hlslContext.BindAttrLit(
                GetAttribute(constantElement, "IntegerPartitioning"),
                "integer");
            hlslContext.BindAttrLit(
                GetAttribute(constantElement, "TriangleCWTopology"),
                "triangle_cw");

            entryPointSpan.WriteLine("[domain(\"{0}\")]",
                hlslContext.EmitAttrLit( tsDomain ));
            entryPointSpan.WriteLine("[partitioning(\"{0}\")]",
                hlslContext.EmitAttrLit( tsPartitioning ));
            entryPointSpan.WriteLine("[outputtopology(\"{0}\")]",
                hlslContext.EmitAttrLit( tsOutputTopology ));
            entryPointSpan.WriteLine("[outputcontrolpoints({0})]",
                hlslContext.EmitAttrLit( outputControlPointCount ));
            entryPointSpan.WriteLine("[patchconstantfunc(\"__patchMain\")]");
            //            entryPointSpan.WriteLine("[maxtessfactor({0:f})]",
            //                hlslContext.EmitAttribRef(
            //                    tsMaxTessFactor,
            //                    null));
            entryPointSpan.WriteLine("{0} main(",
                hlslContext.GenerateConnectorType(controlPointElement));

            first = true;
            hlslContext.DeclareParamAndBind(
                GetAttribute(superPatchElement, "HS_InputCoarseVertices"),
                null,
                ref first,
                entryPointSpan);
            hlslContext.DeclareParamAndBind(
                GetAttribute(superPatchElement, "HS_PatchID"),
                "SV_PrimitiveID",
                ref first,
                entryPointSpan);

            hlslContext.DeclareParamAndBind(
                GetAttribute(controlPointElement, "HS_ControlPointID"),
                "SV_OutputControlPointID",
                ref first,
                entryPointSpan);

            entryPointSpan.WriteLine("\t)");
            entryPointSpan.WriteLine("{");

            hlslContext.EmitTempRecordCtor(
                entryPointSpan,
                inputPatchElement,
                GetAttribute(controlPointElement, "__ip2ocp"));

            var cpOutput = hlslContext.EmitConnectorCtor(
                entryPointSpan,
                controlPointElement);

            entryPointSpan.WriteLine("\treturn {0};", cpOutput);

            entryPointSpan.WriteLine("}");

            hlslContext.EmitConstantBufferDecl();

            EmitShaderSetup(
                hlslContext,
                "hs_5_0",
                "Hull",
                "HS");
        }
        public override void EmitImplSetup()
        {
            constantElement = GetElement("Constant");
            var uniformElement = GetElement("Uniform");
            var fineVertexElement = GetElement("FineVertex");
            var rasterVertexElement = GetElement("RasterVertex");

            InitBlock.AppendComment("D3D11 Domain Shader");

            var tessEnabledAttr = FindAttribute( constantElement, "__D3D11TessellationEnabled" );
            if( tessEnabledAttr  == null )
            {
                return;
            }

            var outputPatchElement = GetElement( "OutputPatch" );
            var controlPointElement = GetElement( "ControlPoint" );

            // \todo: Need to check whether GS is enabled.
            var gsEnabledAttr = FindAttribute( constantElement, "__D3D11GeometryShaderEnabled" );
            var outputElement = fineVertexElement;
            if( gsEnabledAttr == null )
            {
                outputElement = rasterVertexElement;
            }

            hlslContext = new EmitContextHLSL(SharedHLSL, Range, this.EmitClass.GetName());
            var entryPointSpan = hlslContext.EntryPointSpan;

            var outputControlPointCount = GetAttribute(constantElement, "HS_OutputControlPointCount");
            var tsDomain = GetAttribute(constantElement, "TS_Domain");

            // Bind a bunch of attributes that really represent constants:
            hlslContext.BindAttrLit(
                GetAttribute(constantElement, "TriangleDomain"),
                "tri");
            hlslContext.BindAttrLit(
                GetAttribute(constantElement, "QuadDomain"),
                "quad");
            hlslContext.BindAttrLit(
                GetAttribute(constantElement, "FractionalOddPartitioning"),
                "fractional_odd");
            hlslContext.BindAttrLit(
                GetAttribute(constantElement, "IntegerPartitioning"),
                "integer");
            hlslContext.BindAttrLit(
                GetAttribute(constantElement, "TriangleCWTopology"),
                "triangle_cw");

            hlslContext.GenerateConnectorType(controlPointElement);
            hlslContext.GenerateConnectorType(outputElement);

            entryPointSpan.WriteLine("[domain(\"{0}\")]",
                hlslContext.EmitAttrLit( tsDomain ));
            entryPointSpan.WriteLine("{0} main(",
                hlslContext.GenerateConnectorType(outputElement));

            bool first = true;
            if (outputPatchElement.Attributes.Any((a) => a.IsOutput))
            {
                hlslContext.DeclareConnectorAndBind(
                    outputPatchElement,
                    GetAttribute(fineVertexElement, "__op2dv"),
                    ref first,
                    entryPointSpan);
            }

            // \todo: These should not be required, but seem related
            // to an fxc bug where it expects the tess-factor inputs
            // to be re-declared in the DS...
            var edgeFactors = GetAttribute(outputPatchElement, "HS_EdgeFactors");
            var insideFactors = GetAttribute(outputPatchElement, "HS_InsideFactors");

            /*
            hlslContext.DeclareParamAndBind(
                edgeFactors,
                "SV_TessFactor",
                ref first,
                entryPointSpan);

            hlslContext.DeclareParamAndBind(
                insideFactors,
                "SV_InsideTessFactor",
                ref first,
                entryPointSpan);
            */

            hlslContext.DeclareParamAndBind(
                GetAttribute(fineVertexElement, "DS_DomainLocation"),
                "SV_DomainLocation",
                ref first,
                entryPointSpan);

            hlslContext.DeclareParamAndBind(
                GetAttribute(fineVertexElement, "DS_InputControlPoints"),
                null,
                ref first,
                entryPointSpan);
            /*

            entryPointSpan.WriteLine(",");
            entryPointSpan.WriteLine("\tconst OutputPatch<{0}, {1}> DS_InputControlPoints",
                hlslContext.GenerateConnectorType(outputControlPointElement),
                hlslContext.EmitAttribRef(
                    outputControlPointCount,
                    null));
            */

            entryPointSpan.WriteLine("\t)");
            entryPointSpan.WriteLine("{");

            if (fineVertexElement != outputElement)
            {
                hlslContext.EmitTempRecordCtor(
                    entryPointSpan,
                    fineVertexElement,
                    GetAttribute(rasterVertexElement, "__f2rhelper"));
            }

            var output = hlslContext.EmitConnectorCtor(
                entryPointSpan,
                outputElement );

            entryPointSpan.WriteLine("\treturn {0};", output);
            entryPointSpan.WriteLine("}");

            hlslContext.EmitConstantBufferDecl();

            EmitShaderSetup(
                hlslContext,
                "ds_5_0",
                "Domain",
                "DS");
        }
        public override void EmitImplSetup()
        {
            var uniformElement = GetElement("Uniform");
            var vertexElement = GetElement("CoarseVertex");
            var assembledVertex = GetElement("AssembledVertex");

            var constantElement = GetElement("Constant");
            var tessEnabledAttr = FindAttribute( constantElement, "__D3D11TessellationEnabled" );
            var gsEnabledAttr = FindAttribute( constantElement, "__D3D11GeometryShaderEnabled" );

            // \todo: We eventually need to support both tessellation enabled/disabled...

            var fineVertexElement = GetElement("FineVertex");
            var rasterVertexElement = GetElement("RasterVertex");

            var outputElement = vertexElement;
            if( tessEnabledAttr == null )
            {
                if( gsEnabledAttr == null )
                {
                    outputElement = rasterVertexElement;
                }
                else
                {
                    outputElement = fineVertexElement;
                }
            }

            InitBlock.AppendComment("D3D11 Vertex Shader");

            var outputAttributes = new List<MidAttributeDecl>();
            foreach (var a in outputElement.Attributes)
            {
                if (a.IsOutput) outputAttributes.Add(a);
            }

            hlslContext = new EmitContextHLSL(SharedHLSL, Range, this.EmitClass.GetName());

            var entryPointSpan = hlslContext.EntryPointSpan;

            entryPointSpan.WriteLine("{0} main(",
                hlslContext.GenerateConnectorType(outputElement));

            bool first = true;

            hlslContext.DeclareConnectorAndBind(
                assembledVertex,
                GetAttribute(vertexElement, "__ia2vs"),
                ref first,
                entryPointSpan);

            hlslContext.DeclareParamAndBind(
                GetAttribute(vertexElement, "VS_VertexID"),
                "SV_VertexID",
                ref first,
                entryPointSpan);
            hlslContext.DeclareParamAndBind(
                GetAttribute(vertexElement, "VS_InstanceID"),
                "SV_InstanceID",
                ref first,
                entryPointSpan);

            entryPointSpan.WriteLine("\t)");
            entryPointSpan.WriteLine("{");

            if( tessEnabledAttr == null )
            {
                hlslContext.EmitTempRecordCtor(
                    entryPointSpan,
                    vertexElement,
                    GetAttribute(fineVertexElement, "__c2fhelper"));

                if( gsEnabledAttr == null )
                {
                    hlslContext.EmitTempRecordCtor(
                        entryPointSpan,
                        fineVertexElement,
                        GetAttribute(rasterVertexElement, "__f2rhelper"));
                }
            }

            var resultVal = hlslContext.EmitConnectorCtor(
                entryPointSpan,
                outputElement);
            entryPointSpan.WriteLine("\treturn {0};", resultVal);
            entryPointSpan.WriteLine("}");

            hlslContext.EmitConstantBufferDecl();

            //

            EmitShaderSetup(
                hlslContext,
                "vs_5_0",
                "Vertex",
                "VS");
        }
        public override void EmitImplSetup()
        {
            constantElement = GetElement( "Constant" );

            InitBlock.AppendComment( "D3D11 Geometry Shader" );

            var gsEnabledAttr = FindAttribute( constantElement, "__D3D11GeometryShaderEnabled" );
            if( gsEnabledAttr == null )
            {
                return;
            }

            var uniformElement = GetElement( "Uniform" );
            var fineVertexElement = GetElement( "FineVertex" );
            var rasterVertexElement = GetElement( "RasterVertex" );
            var geometryInputElement = GetElement( "GeometryInput" );
            var geometryOutputElement = GetElement( "GeometryOutput" );

            hlslContext = new EmitContextHLSL( SharedHLSL, Range, this.EmitClass.GetName() );
            var entryPointSpan = hlslContext.EntryPointSpan;

            var gsInstanceCount = GetAttribute( constantElement, "GS_InstanceCount" );
            var gsInputVertexCount = GetAttribute( constantElement, "GS_InputVertexCount" );
            var gsMaxOutputVertexCount = GetAttribute( constantElement, "GS_MaxOutputVertexCount" );
            var gsInstanceID = GetAttribute( geometryInputElement, "GS_InstanceID" );
            var gsInputVertices = GetAttribute( geometryInputElement, "GS_InputVertices" );
            var gsOutputStream = GetAttribute( geometryOutputElement, "GS_OutputStream" );

            hlslContext.GenerateConnectorType(fineVertexElement);
            hlslContext.GenerateConnectorType(rasterVertexElement);

            entryPointSpan.WriteLine( "[instance({0})]",
                hlslContext.EmitAttrLit( gsInstanceCount ) );
            entryPointSpan.WriteLine( "[maxvertexcount({0})]",
                hlslContext.EmitAttrLit( gsMaxOutputVertexCount ) );
            entryPointSpan.WriteLine( "void main(" );

            bool first = true;

            // \todo: "triangle" or appropriate prefix...
            hlslContext.DeclareParamAndBind(
                gsInputVertices,
                hlslContext.MakeArrayType(
                    hlslContext.GenerateConnectorType(fineVertexElement),
                    hlslContext.EmitAttribRef(gsInputVertexCount, null)),
                null,
                ref first,
                entryPointSpan,
                prefix: "triangle ");

            hlslContext.DeclareParamAndBind(
                gsOutputStream,
                null,
                ref first,
                entryPointSpan,
                prefix: "inout ");

            hlslContext.DeclareParamAndBind(
                gsInstanceID,
                "SV_GSInstanceID",
                ref first,
                entryPointSpan );

            entryPointSpan.WriteLine( "\t)" );
            entryPointSpan.WriteLine( "{" );

            var gi2go = hlslContext.EmitTempRecordCtor(
                entryPointSpan,
                geometryInputElement,
                GetAttribute(geometryOutputElement, "__gi2go"));

            hlslContext.BindAttr(
                GetAttribute(rasterVertexElement, "__gi2rv"),
                gi2go);

            var output = hlslContext.EmitConnectorCtor(
                entryPointSpan,
                geometryOutputElement );

            entryPointSpan.WriteLine( "}" );

            hlslContext.EmitConstantBufferDecl();

            EmitShaderSetup(
                hlslContext,
                "gs_5_0",
                "Geometry",
                "GS" );
        }