상속: MidMemberDecl
 public MidElementCtorApp(
     SourceRange range,
     MidElementDecl element,
     IEnumerable<MidElementCtorArg> args)
     : base(range, new MidElementType(element))
 {
     _element = element;
     _args = args.ToArray();
 }
 public MidAttributeDecl(
     Identifier name,
     MidElementDecl element,
     MidType type,
     MidExp exp )
 {
     _name = name;
     _element = element;
     _type = type;
     _exp = exp;
 }
예제 #3
0
 public MidAttributeDecl(
     Identifier name,
     MidElementDecl element,
     MidType type,
     MidExp exp)
 {
     _name    = name;
     _element = element;
     _type    = type;
     _exp     = exp;
 }
예제 #4
0
 public MidLocalEmitEnv(
     MidEmitEnv parent,
     IdentifierFactory identifiers,
     MidElementDecl element,
     MidExpFactory exps)
     : base(parent)
 {
     _identifiers = identifiers;
     _element     = element;
     _exps        = exps;
 }
예제 #5
0
        public static void Dump(
            this MidElementDecl element,
            Span span)
        {
            span.WriteLine("element {0} {{", element.Name);
            var inner = span.IndentSpan();

            foreach (var a in element.Attributes)
            {
                a.Dump(inner);
            }
            span.WriteLine("}");
        }
예제 #6
0
        private MidMemberDecl EmitMemberDeclImpl(
            MidFacetDecl midFacet,
            IResElementDecl resElement,
            MidEmitEnv env)
        {
            var midElement = new MidElementDecl(midFacet, resElement.Name);

            midElement.DoneBuilding();

            midFacet.AddElement(midElement);

            return(midElement);
        }
예제 #7
0
        private MidExp EmitAttrExp(
            MidElementDecl midElement,
            MidType midType,
            IResExp resExp,
            MidEmitEnv env)
        {
            var savedElement = _currentElement;

            _currentElement = midElement;

            var result = EmitLocalExp(resExp, env, midElement);

            _currentElement = savedElement;

            return(result);
        }
예제 #8
0
        private MidVal EmitValToElementImpl(
            IResExp resExp,
            MidElementDecl element,
            MidEmitEnv parentEnv)
        {
            var midExp = EmitLocalExp(resExp, parentEnv, element);

            if (midExp is MidVal)
            {
                return((MidVal)midExp);
            }

            var midType = EmitTypeExp(resExp.Type, parentEnv);
            var attr    = element.CacheAttr(
                midExp,
                midType);

            return(_exps.AttributeRef(resExp.Range, attr));
        }
예제 #9
0
        private MidVal EmitValToElement(
            IResExp resExp,
            MidElementDecl element,
            MidEmitEnv parentEnv)
        {
            if (element == _currentElement)
            {
                return(EmitVal(resExp, parentEnv));
            }

            var savedElement = _currentElement;

            _currentElement = element;

            var result = EmitValToElementImpl(
                resExp,
                element,
                parentEnv);

            _currentElement = savedElement;
            return(result);
        }
        public void Collect(
            MidPipelineDecl pipeline,
            MidElementDecl element,
            MidAttributeDecl attribute)
        {
            if (!attribute.IsOutput)
                return;

            if (!(attribute.Type is MidStructRef))
                return;

            // Unmark the attribute as an output...
            attribute.IsOutput = false;

            var structType = (MidStructRef)attribute.Type;

            AttributeInfo attrInfo;
            attrInfo.AttrDecl = attribute;
            attrInfo.Fields = (from f in structType.Fields
                               select CreateField(pipeline, element, attribute, f)).ToArray();

            _replacePass._attrInfos[attribute] = attrInfo;
        }
 public ConnectorTypeHLSL(
     string name,
     MidElementDecl element)
     : base(name)
 {
     _elementDecl = element;
 }
        private EmitValHLSL DeclareAndInitRecord(
            Span span,
            MidElementDecl record,
            EmitValHLSL destVar)
        {
            var recordVal = EvaluateRecordAttrs(span, record);

            DeclareAndInitLocal(
                destVar,
                recordVal,
                span);

            return destVar;
        }
예제 #13
0
 public void AddElement(MidElementDecl element)
 {
     _elements.Add(element);
 }
예제 #14
0
 public MidElementType(
     MidElementDecl element)
 {
     _element = element;
 }
        public IAggTypeHLSL EmitType(MidElementDecl element)
        {
            IAggTypeHLSL result;
            if (_elementTypes.TryGetValue(element, out result))
                return result;

            // Actually emit the type, then...
            var name = string.Format("Tup_{0}", element.Name.ToString());
            TupleTypeHLSL tupleType = new TupleTypeHLSL(name);
            _elementTypes[element] = tupleType;

            foreach (var a in element.Attributes)
            {
                if (!a.IsOutput) continue;

                var attrName = MapName(a);

                tupleType.AddField(
                    attrName,
                    EmitType(a.Type));
            }

            return tupleType;
        }
        // Main shader body stuff
        public EmitValHLSL EmitConnectorCtor(
            Span span,
            MidElementDecl element)
        {
            var name = _shared.GenerateName("__result");
            var type = GenerateConnectorType(element);
            var val = type.CreateVal(name);

            DeclareAndInitRecord(
                span,
                element,
                val);

            return val;
        }
 public ElementCtorInfo(
     string name,
     MidElementDecl elementDecl,
     IEnumerable<MidAttributeDecl> inputAttributes)
 {
     _name = name;
     _elementDecl = elementDecl;
     _inputAttributes = inputAttributes.ToArray();
 }
        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");
        }
예제 #19
0
 public void SimplifyElement(MidElementDecl element)
 {
     foreach (var a in element.Attributes)
         SimplifyAttribute(a);
 }
예제 #20
0
 public void CollectElementInfo( MidElementDecl element )
 {
     foreach( var a in element.Attributes )
         CollectAttributeInfo( a );
     foreach( var wrapper in element.AttributeWrappers )
     {
         _mapOldToWrapper[ wrapper.Attribute ] = wrapper;
     }
 }
예제 #21
0
        protected MidAttributeWrapperDecl GetAttribute(MidElementDecl element, string name)
        {
            var result = FindAttribute(element, name);
            if (result != null)
                return result;

            throw new NotImplementedException();
        }
예제 #22
0
        protected MidAttributeWrapperDecl FindAttribute(MidElementDecl element, string name)
        {
            foreach (var a in element.AttributeWrappers)
            {
                if (a.Name == Identifiers.simpleIdentifier(name))
                    return a;
            }

            return null;
        }
        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" );
        }
        private EmitValHLSL EvaluateRecordAttrs(
            Span span,
            MidElementDecl record )
        {
            var recordType = EmitType(record);
            var attribVals = (from a in record.Attributes
                              where a.IsOutput
                              select EmitAttribRef(a, span)).Eager();

            var recordVal = new TupleValHLSL(
                recordType,
                attribVals);
            return recordVal;
        }
        private ElementCtorInfo GetElementCtor(MidElementDecl elementDecl)
        {
            ElementCtorInfo result;
            if (_elementCtors.TryGetValue(elementDecl, out result))
                return result;

            string name = "Ctor_" + elementDecl.Name.ToString();
            var inputAttributes = (from a in elementDecl.Attributes
                                   where a.Exp == null // \todo: real test for input-ness
                                   select a).ToArray();

            result = new ElementCtorInfo(
                name,
                elementDecl,
                inputAttributes);

            var span = new Span();

            span.WriteLine("void {0}(", name);

            var resultType = EmitType(elementDecl);

            bool first = true;
            var resultParam = DeclareOutParam("__result", resultType, span, ref first);

            foreach (var a in inputAttributes)
            {
                var attrName = MapName(a);
                var attrType = EmitType(a.Type);

                var attrParam = DeclareParam(
                    attrName,
                    attrType,
                    span,
                    ref first);

                _attrVals[a] = attrParam;

            }
            span.WriteLine(")");
            span.WriteLine("{");

            var resultAttrs = (from a in elementDecl.Attributes
                               where a.IsOutput
                               select EmitAttribRef(a, span)).ToArray();

            var resultVal = new TupleValHLSL(
                (IAggTypeHLSL) resultType,
                resultAttrs);

            Assign(resultParam, resultVal, span);

            span.WriteLine("}");

            _subroutineHeaderSpan.Add(span);

            _elementCtors[elementDecl] = result;
            return result;
        }
예제 #26
0
 public static void UnmarkOutputs( MidElementDecl element )
 {
     foreach( var a in element.Attributes )
         UnmarkOutputs( a );
 }
 public void DeclareConnectorAndBind(
     MidElementDecl element,
     MidAttributeWrapperDecl attr,
     ref bool firstParam,
     Span span)
 {
     var attrType = GenerateConnectorType(element);
     DeclareParamAndBind(
         attr,
         attrType,
         null,
         ref firstParam,
         span );
 }
 public void AddElement(MidElementDecl element)
 {
     _elements.Add(element);
 }
        public EmitValHLSL EmitTempRecordCtor(
            Span span,
            MidElementDecl recordToConstruct,
            MidAttributeWrapperDecl wrapper )
        {
            var attr = wrapper.Attribute;
            var attrName = attr.Name.ToString();
            var attrType = EmitType(attr.Type);
            var attrVal = attrType.CreateVal(attrName);
            BindAttr(attr, attrVal);

            return DeclareAndInitRecord(
                span,
                recordToConstruct,
                attrVal);
        }
        // Generate "connector" struct type for a particular stage
        public ConnectorTypeHLSL GenerateConnectorType(MidElementDecl element)
        {
            if (_elementTypes.ContainsKey(element) && !_connectorTypes.ContainsKey(element))
            {
                throw new NotImplementedException();
            }

            ConnectorTypeHLSL result;
            if (_connectorTypes.TryGetValue(element, out result))
                return result;

            // Actually emit the type, then...
            var name = string.Format("T_{0}", element.Name.ToString());
            result = new ConnectorTypeHLSL(name, element);
            _connectorTypes[element] = result;

            _elementTypes[element] = result;

            var span = new Span();

            span.WriteLine("struct {0}", result);
            span.WriteLine("{");
            var memberSpan = span.IndentSpan();
            foreach (var a in element.Attributes)
            {
                // Only output attributes go in the connector
                if (!a.IsOutput) continue;

                var attrName = MapName(a);
                var attrType = EmitType(a.Type);

                var rawName = a.Name.ToString();
                string semantic = "";
                switch (rawName)
                {
                    case "HS_EdgeFactors":
                        semantic = ": SV_TessFactor";
                        break;
                    case "HS_InsideFactors":
                        semantic = ": SV_InsideTessFactor";
                        break;
                    case "__RS_Position":
                        semantic = ": SV_Position";
                        break;
                    case "__RS_RenderTargetArrayIndex":
                        semantic = ": SV_RenderTargetArrayIndex";
                        break;

                    default:
                        semantic = string.Format(" : USER_{0}", attrName);
                        break;
                }

                var attrRep = DeclareConnectorFields(
                    attrType,
                    attrName,
                    semantic,
                    memberSpan.IndentSpan() );

                result.AddField(
                    attrName,
                    attrRep);
            }
            span.WriteLine("};");
            span.WriteLine();

            _typeHeaderSpan.Add(span);

            return result;
        }
 public void ApplyToElement(MidElementDecl element)
 {
     foreach (var a in element.Attributes)
         ApplyToAttribute(a);
 }
        public EmitValHLSL InitRecord(
            Span span,
            MidElementDecl record,
            EmitValHLSL destVar)
        {
            var recordVal = EvaluateRecordAttrs(span, record);

            Assign(
                destVar,
                recordVal,
                span);

            return destVar;
        }
예제 #33
0
 public MidElementType(
     MidElementDecl element)
 {
     _element = element;
 }
        private FieldInfo CreateField(
            MidPipelineDecl pipeline,
            MidElementDecl element,
            MidAttributeDecl attribute,
            MidFieldDecl field)
        {
            var midExp = _exps.FieldRef(
                    attribute.Range,
                    _exps.AttributeRef( attribute.Range, attribute ),
                    field );

            var name = _identifiers.unique(
                string.Format( "{0}_{1}", attribute.Name, field.Name ) );

            var newAttr = element.CacheAttr(
                midExp,
                field.Type);
            newAttr.TrySetName(name, attribute.Range);

            return new FieldInfo{
                AttrDecl = newAttr,
                FieldDecl = field};
        }