Exemple #1
0
 public VertexInputBindingDescription
 (
     uint binding = default,
     uint stride  = default,
     VertexInputRate inputRate = default
 )
 {
     Binding   = binding;
     Stride    = stride;
     InputRate = inputRate;
 }
Exemple #2
0
        internal static VkVertexInputRate ConvertVertexInputRate(this VertexInputRate rate)
        {
            switch (rate)
            {
            case VertexInputRate.Vertex:
                return(VkVertexInputRate.Vertex);

            case VertexInputRate.Instance:
                return(VkVertexInputRate.Instance);

            default:
                throw new ArgumentOutOfRangeException(nameof(rate));
            }
        }
        /// <summary>
        /// Create a new instance of <see cref="VertexLayoutDescriptor"/> struct. The stride is assumed to be the sum of the size of all elements.
        /// </summary>
        /// <param name="attributes">An array of <see cref="VertexAttributeDescriptor"/> objects, each describing a single element
        /// of vertex data.</param>
        public VertexLayoutDescriptor(params VertexAttributeDescriptor[] attributes)
        {
            Attributes = attributes;
            var stride = 0;

            for (int i = 0; i < attributes.Length; i++)
            {
                int elementSize = VertexFormatUtil.GetSizeInBytes(attributes[i].Format);
                if (attributes[i].Offset != 0)
                {
                    stride = attributes[i].Offset + elementSize;
                }
                else
                {
                    stride += elementSize;
                }
            }

            Stride    = stride;
            InputRate = VertexInputRate.Vertex;
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="VertexInputBinding"/> class.
 /// </summary>
 /// <param name="binding">The binding number that this structure describes.</param>
 /// <param name="stride">
 /// The distance in bytes between two consecutive elements within the buffer.
 /// </param>
 /// <param name="inputRate">
 /// Specifies whether vertex attribute addressing is a function of the vertex index or of the
 /// instance index.
 /// </param>
 public VertexInputBinding(int binding, int stride, VertexInputRate inputRate)
 {
     Binding   = binding;
     Stride    = stride;
     InputRate = inputRate;
 }
 /// <summary>
 /// Create a new instance of <see cref="VertexLayoutDescriptor"/> struct.
 /// </summary>
 /// <param name="stride">The number of bytes in between successive elements in the <see cref="GraphicsBuffer"/>.</param>
 /// <param name="inputRate">The <see cref="VertexInputRate"/>.</param>
 /// <param name="attributes">An array of <see cref="VertexAttributeDescriptor"/> objects, each describing a single element
 /// of vertex data.</param>
 public VertexLayoutDescriptor(int stride, VertexInputRate inputRate, params VertexAttributeDescriptor[] attributes)
 {
     Stride     = stride;
     Attributes = attributes;
     InputRate  = inputRate;
 }
 /// <summary>
 ///
 /// </summary>
 public VertexInputBindingDescription(uint binding, uint stride, VertexInputRate inputRate)
 {
     this.Binding   = binding;
     this.Stride    = stride;
     this.InputRate = inputRate;
 }
Exemple #7
0
        public VertexInput[] GetVertexInput(IEnumerable <uint> bindingsWithInstanceRate = null)
        {
            List <VertexInput> vertexInputs = new List <VertexInput>();

            IEnumerable <VertexInputSegment> vertexInputSegments = _segmentCollection.GetSegments <VertexInputSegment>();

            for (int i = 0; i < vertexInputSegments.Count(); i++)
            {
                VertexInputSegment vertexInputSegment = vertexInputSegments.ElementAt(i);

                Type type = Constants.GlslToNetType[vertexInputSegment.GlslType];

                VertexInputRate inputRate = VertexInputRate.Vertex;
                if (bindingsWithInstanceRate != null && bindingsWithInstanceRate.Contains(vertexInputSegment.Binding))
                {
                    inputRate = VertexInputRate.Instance;
                }

                uint   stride = Constants.TypeToSize[type];
                Format format = Constants.TypeToVertexInputFormat[type];

                if (!Constants.TypesWithMultipleLocations.Contains(type))
                {
                    VertexInput vertexInput = new VertexInput()
                    {
                        Name      = vertexInputSegment.Name,
                        GlslType  = vertexInputSegment.GlslType,
                        Binding   = vertexInputSegment.Binding,
                        InputRate = inputRate,
                        Stride    = stride,
                        Format    = format,
                        Location  = vertexInputSegment.Binding,
                        Offset    = 0,
                    };

                    vertexInputs.Add(vertexInput);
                }
                else
                {
                    int occupiedSpaces = Constants.TypeToOccupiedVertexInputLocations[type];

                    for (uint j = 0; j < occupiedSpaces; j++)
                    {
                        uint offset = (uint)j * Constants.TypeToOffsetStrideSize[type];

                        VertexInput vertexInput = new VertexInput()
                        {
                            Name      = vertexInputSegment.Name,
                            GlslType  = vertexInputSegment.GlslType,
                            Binding   = vertexInputSegment.Binding,
                            InputRate = inputRate,
                            Stride    = stride,
                            Format    = format,
                            Location  = vertexInputSegment.Binding + j,
                            Offset    = offset,
                        };

                        vertexInputs.Add(vertexInput);
                    }
                }
            }

            return(vertexInputs.ToArray());
        }