public VertexMeta( short stream, VertexElementFormat format, VertexElementUsage usage ) { this.Stream = stream; this.Format = format; this.Usage = usage; }
public VertexAttribute(VertexElementUsage usage, int index, string name, int location) { Usage = usage; Index = index; Name = name ?? throw new ArgumentNullException(nameof(name)); Location = location; }
internal void BindAttribute(VertexElementUsage usage, string name) { ThreadingHelper.BlockOnUIThread(() => { GL.BindAttribLocation(program, (int)usage, name); }); }
public VertexMeta( VertexElementFormat format, VertexElementUsage usage, byte usageIndex ) { this.Format = format; this.Usage = usage; this.UsageIndex = usageIndex; }
public VertexChannel this[VertexElementUsage elementUsage] { get { return(_channels[_order[elementUsage]]); } }
public VertexElement(VertexElementUsage usage, int usageIndex, VertexElementType type) : this() { this.Usage = usage; this.UsageIndex = usageIndex; this.Type = type; }
public VertexElement(int offset, VertexElementFormat elementFormat, VertexElementUsage elementUsage, int usageIndex) { this.offset = offset; this.elementFormat = elementFormat; this.elementUsage = elementUsage; this.usageIndex = usageIndex; }
private static BoundingBox?GetBoundingBox(ModelMeshPart meshPart, Matrix transform) { if (meshPart.VertexBuffer == null) { return(null); } VertexDeclaration vd = meshPart.VertexBuffer.VertexDeclaration; VertexElement[] elements = vd.GetVertexElements(); VertexElementUsage usage = VertexElementUsage.Position; Func <VertexElement, bool> elementPredicate = ve => ve.VertexElementUsage == usage && ve.VertexElementFormat == VertexElementFormat.Vector3; if (!elements.Any(elementPredicate)) { return(null); } VertexElement element = elements.First(elementPredicate); Vector3[] positions = new Vector3[meshPart.NumVertices]; meshPart.VertexBuffer.GetData((meshPart.VertexOffset * vd.VertexStride) + element.Offset, positions, 0, positions.Length, vd.VertexStride); if (positions == null) { return(null); } Vector3[] transformedPositions = new Vector3[positions.Length]; Vector3.Transform(positions, ref transform, transformedPositions); return(BoundingBox.CreateFromPoints(transformedPositions)); }
/// <summary> /// Initializes a new instance of the <see cref="VertexElement"/> struct. /// </summary> /// <param name="offset">The offset in bytes from the beginning of the stream to the vertex element.</param> /// <param name="elementFormat">The element format.</param> /// <param name="elementUsage">The HLSL semantic of the element in the vertex shader input-signature.</param> /// <param name="usageIndex">The semantic index, which is required if the semantic is used for more than one vertex element.</param> public VertexElement(int offset, VertexElementFormat elementFormat, VertexElementUsage elementUsage, int usageIndex) { _offset = offset; _format = elementFormat; _usageIndex = usageIndex; _usage = elementUsage; }
public VertexElement(VertexElementFormat type, VertexElementUsage kind, TextureUnit unit) : this() { Type = type; Kind = kind; Unit = unit; }
public VertexElement(int offset, VertexElementFormat elementFormat, VertexElementUsage elementUsage, int usageIndex) { this.Offset = offset; this.VertexElementFormat = elementFormat; this.VertexElementUsage = elementUsage; this.UsageIndex = usageIndex; }
/// public VertexMeta( VertexElementFormat format, VertexElementUsage usage, VertexElementMethod method ) { this.Format = format; this.Usage = usage; this.Method = method; }
protected internal override VertexDeclaration Read( ContentReader reader, VertexDeclaration existingInstance ) { int vertexStride = reader.ReadInt32(); int elementCount = reader.ReadInt32(); VertexElement[] elements = new VertexElement[elementCount]; for (int i = 0; i < elementCount; i += 1) { int offset = reader.ReadInt32(); VertexElementFormat elementFormat = (VertexElementFormat)reader.ReadInt32(); VertexElementUsage elementUsage = (VertexElementUsage)reader.ReadInt32(); int usageIndex = reader.ReadInt32(); elements[i] = new VertexElement( offset, elementFormat, elementUsage, usageIndex ); } /* TODO: This process generates alot of duplicate VertexDeclarations * which in turn complicates other systems trying to share GPU resources * like DX11 vertex input layouts. * * We should consider caching vertex declarations here and returning * previously created declarations when they are in our cache. */ return(new VertexDeclaration(vertexStride, elements)); }
public AttributeInfo(int size, int elementsCount, VertexElementFormat format, VertexElementUsage usage) { Size = size; ElementsCount = elementsCount; Format = format; Usage = usage; }
public VertexElement(int offset, VertexElementFormat format, VertexElementUsage usage, int usageIndex) { Offset = offset; Format = format; Usage = usage; UsageIndex = usageIndex; }
public override string ToString() { return("{{Offset:" + Offset.ToString() + " Format:" + VertexElementFormat.ToString() + " Usage:" + VertexElementUsage.ToString() + " UsageIndex: " + UsageIndex.ToString() + "}}"); }
/// public VertexMeta(VertexElementFormat format, VertexElementUsage usage, VertexElementMethod method) { this.Format = format; this.Usage = usage; this.Method = method; }
public int GetIndex(VertexElementUsage elementUsage) { int index = -1; _order.TryGetValue(elementUsage, out index); return(index); }
/// <summary> /// Initializes a new instance of the <see cref="VertexElement"/> struct. /// </summary> /// <param name="offset">The offset in bytes from the beginning of the stream to the vertex element.</param> /// <param name="elementFormat">The element format.</param> /// <param name="elementUsage">The HLSL semantic of the element in the vertex shader input-signature.</param> /// <param name="usageIndex">The semantic index, which is required if the semantic is used for more than one vertex element.</param> public VertexElement( int offset, VertexElementFormat elementFormat, VertexElementUsage elementUsage, int usageIndex) { Offset = offset; VertexElementFormat = elementFormat; VertexElementUsage = elementUsage; UsageIndex = usageIndex; }
public VertexMeta(short stream, VertexElementFormat format, VertexElementUsage usage) { this.Stream = stream; this.Format = format; this.Usage = usage; }
public VertexMeta(VertexElementFormat format, VertexElementUsage usage, byte usageIndex) { this.Format = format; this.Usage = usage; this.UsageIndex = usageIndex; }
public VertexElementLayout(int stream, int offset, VertexElementType type, VertexElementUsage usage, int usageIndex) { Stream = stream; Offset = offset; Type = type; Usage = usage; UsageIndex = usageIndex; }
public static string Convert(VertexElementUsage usage) { if (!vertexElementUsages.ContainsKey(usage)) { throw new NotSupportedException("Usage is not supported."); } return(vertexElementUsages[usage]); }
internal int GetAttribLocation(VertexElementUsage usage, int index) { for (int i = 0; i < _attributes.Length; ++i) { if ((_attributes[i].usage == usage) && (_attributes[i].index == index)) return _attributes[i].location; } return -1; }
internal int GetAttribLocation(VertexElementUsage usage, int index) { for (int index1 = 0; index1 < this._attributes.Length; ++index1) { if (this._attributes[index1].usage == usage) return this._attributes[index1].location + index; } return -1; }
public VertexMeta( short stream, VertexElementFormat format, VertexElementUsage usage, VertexElementMethod method ) { this.Stream = stream; this.Format = format; this.Usage = usage; this.Method = method; }
public VertexMeta( short stream, VertexElementFormat format, VertexElementUsage usage, byte usageIndex ) { this.Stream = stream; this.Format = format; this.Usage = usage; this.UsageIndex = usageIndex; }
public VertexElement(short stream, short offset, VertexElementFormat elementFormat, VertexElementMethod elementMethod, VertexElementUsage elementUsage, byte usageIndex) { this.stream = stream; this.offset = offset; this.usageIndex = usageIndex; this.format = elementFormat; this.method = elementMethod; this.usage = elementUsage; }
/// <summary> /// Initializes a new instance of the <see cref="VertexElement"/> structure. /// </summary> /// <param name="position">The element's position within the vertex data, in bytes.</param> /// <param name="format">The element's vertex format.</param> /// <param name="usage">The element's usage hint.</param> /// <param name="index">The element's usage index.</param> /// <param name="name">The element's name in shaders, or <see langword="null"/> to use an imlpementation-specific default name.</param> public VertexElement(Int32 position, VertexElementFormat format, VertexElementUsage usage, Int32 index, String name = null) { Contract.EnsureRange(index >= 0 && index < UsageIndexCount, nameof(index)); this.Name = name; this.Position = position; this.Index = index; this.Format = format; this.Usage = usage; }
public static string Convert(VertexElementUsage usage) { string str; if (!vertexElementUsages.TryGetValue(usage, out str)) { throw new NotSupportedException("Usage is not supported."); } return(str); }
public VertexMeta(short stream, VertexElementFormat format, VertexElementUsage usage, VertexElementMethod method) { this.Stream = stream; this.Format = format; this.Usage = usage; this.Method = method; }
public Attribute(VertexElementUsage usage_, int index_, string name_, short format_) { usage = usage_; index = index_; name = name_; format = format_; }
public VertexMeta(short stream, VertexElementFormat format, VertexElementUsage usage, byte usageIndex) { this.Stream = stream; this.Format = format; this.Usage = usage; this.UsageIndex = usageIndex; }
internal int GetAttribLocation(VertexElementUsage usage, int index) { //for (int i = 0; i < Attributes.Length; ++i) //{ // if ((Attributes[i].usage == usage) && (Attributes[i].index == index)) // return Attributes[i].location; //} return(-1); }
public bool HasElement(VertexElementUsage usage, VertexElementType type) { for (int i = 0; i < elements.Length; i++) { if (elements[i].Usage == usage && elements[i].Type == type) { return(true); } } return(false); }
public bool HasElement(VertexElementUsage usage, int usageIndex) { for (int i = 0; i < elements.Length; i++) { if (elements[i].Usage == usage && elements[i].UsageIndex == usageIndex) { return(true); } } return(false); }
/// <summary> /// /// </summary> public VertexElement( Int32 offset, VertexElementFormat elementFormat, VertexElementUsage elementUsage, Int32 usageIndex) { this._offset = offset; this._usageIndex = usageIndex; this._format = elementFormat; this._usage = elementUsage; }
public int CreateChannel(VertexElementFormat format, VertexElementUsage usage, int index) { if (vertexData.Count > 0) { throw new System.InvalidOperationException("Can't add a new vertex channel when indices are already added."); } VertexElement ve = new VertexElement(0, 0, format, VertexElementMethod.Default, usage, (byte)index); dataChannels.Add(ve); return(dataChannels.Count - 1); }
internal int GetAttribLocation(VertexElementUsage usage, int index) { for (int i = 0; i < _attributes.Length; ++i) { if ((_attributes[i].usage == usage) && (_attributes[i].index == index)) { return(_attributes[i].location); } } return(-1); }
internal int GetAttribLocation(VertexElementUsage usage, int index) { for (int index1 = 0; index1 < this._attributes.Length; ++index1) { if (this._attributes[index1].usage == usage && this._attributes[index1].index == index) { return(this._attributes[index1].location); } } return(-1); }
public VertexElement( int offset, VertexElementFormat elementFormat, VertexElementUsage elementUsage, int usageIndex ) : this() { Offset = offset; UsageIndex = usageIndex; VertexElementFormat = elementFormat; VertexElementUsage = elementUsage; }
/// <summary> /// Return all the elements of a certain type. /// </summary> /// <param name="meshPart"></param> /// <param name="usage"></param> /// <returns></returns> public static Vector3[] GetVertexElement(this ModelMeshPart meshPart, VertexElementUsage usage) { VertexDeclaration vd = meshPart.VertexBuffer.VertexDeclaration; VertexElement[] elements = vd.GetVertexElements(); Func<VertexElement, bool> elementPredicate = ve => ve.VertexElementUsage == usage && ve.VertexElementFormat == VertexElementFormat.Vector3; if (!elements.Any(elementPredicate)) return null; VertexElement element = elements.First(elementPredicate); Vector3[] vertexData = new Vector3[meshPart.NumVertices]; meshPart.VertexBuffer.GetData((meshPart.VertexOffset * vd.VertexStride) + element.Offset, vertexData, 0, vertexData.Length, vd.VertexStride); return vertexData; }
/// <summary> /// Processes a vertex, updating the current bounding box if it lies outside of it. /// </summary> /// <param name="x">The X component of the vertex.</param> /// <param name="y">The Y component of the vertex.</param> /// <param name="z">The Z component of the vertex.</param> /// <param name="usage">The vertex's usage.</param> public void ProcessVertex(float x, float y, float z, VertexElementUsage usage) { switch (usage) { case VertexElementUsage.Position: CalculatedBox.MinX = Math.Min(CalculatedBox.MinX, x); CalculatedBox.MinY = Math.Min(CalculatedBox.MinY, y); CalculatedBox.MinZ = Math.Min(CalculatedBox.MinZ, z); CalculatedBox.MaxX = Math.Max(CalculatedBox.MaxX, x); CalculatedBox.MaxY = Math.Max(CalculatedBox.MaxY, y); CalculatedBox.MaxZ = Math.Max(CalculatedBox.MaxZ, z); break; case VertexElementUsage.TexCoords: CalculatedBox.MinU = Math.Min(CalculatedBox.MinU, x); CalculatedBox.MinV = Math.Min(CalculatedBox.MinV, y); CalculatedBox.MaxU = Math.Max(CalculatedBox.MaxU, x); CalculatedBox.MaxV = Math.Max(CalculatedBox.MaxV, y); break; } }
private void DecodeSingleElement(ICollection<VertexElement> list, int index, int streamIndex, VertexElementUsage usage, ref int usageIndex) { var declTypes = DeclarationTypes; var usageFlags = UsageFlags; var usageFlagMask = (uint)(1 << index); var type = GetType(declTypes, index); var size = GetSize(type); if ((usageFlags & usageFlagMask) != 0) { var element = new VertexElement() { UsageIndex = usageIndex++, StreamIndex = streamIndex, Usage = usage, Type = type, Size = size, }; list.Add(element); } }
public int GetInputIndex(VertexElementUsage usage, int usageIndex) { foreach (ShaderInput input in Input) { if (input.Usage == usage && input.UsageIndex == usageIndex) return input.Index; } return -1; }
public void ToSemantic(GraphicStreamUsage graphicStreamUsage, VertexElementUsage usage) { Assert.AreEqual(usage, graphicStreamUsage.ToVertexElementUsage()); }
public static bool TryDecodeUsage(string encodedName, out VertexElementUsage usage) { throw new NotImplementedException(); }
public int GetIndex(VertexElementUsage elementUsage) { int index = -1; _order.TryGetValue(elementUsage, out index); return index; }
public VertexChannel this[VertexElementUsage elementUsage] { get { return _channels[_order[elementUsage]]; } }
/// <summary> /// Determines if an element in the layout has a certain usage. /// </summary> /// <param name="usage">The VertexElementUsage to search for.</param> /// <returns>true if an element with the given usage is present in the layout.</returns> public bool HasElement(VertexElementUsage usage) { return _availableUsages.Contains(usage); }
/// <summary> /// Transforms a vertex element based upon a model's bounding box information. /// </summary> /// <param name="x">The X component of the element.</param> /// <param name="y">The Y component of the element.</param> /// <param name="z">The Z component of the element.</param> /// <param name="w">The W component of the element.</param> /// <param name="usage">The usage of the vertex element.</param> /// <param name="boundingBox">The bounding box to transform the element by.</param> private static void TransformElement(ref float x, ref float y, ref float z, ref float w, VertexElementUsage usage, BoundingBox boundingBox) { switch (usage) { case VertexElementUsage.Position: x = x*(boundingBox.MaxX - boundingBox.MinX) + boundingBox.MinX; y = y*(boundingBox.MaxY - boundingBox.MinY) + boundingBox.MinY; z = z*(boundingBox.MaxZ - boundingBox.MinZ) + boundingBox.MinZ; break; case VertexElementUsage.TexCoords: x = x*(boundingBox.MaxU - boundingBox.MinU) + boundingBox.MinU; y = y*(boundingBox.MaxV - boundingBox.MinV) + boundingBox.MinV; break; } }
private void TransformElement(ref float x, ref float y, ref float z, ref float w, VertexElementUsage usage) { if (_bbox == null) return; switch (usage) { case VertexElementUsage.Position: x = (x - _bbox.MinX)/(_bbox.MaxX - _bbox.MinX); y = (y - _bbox.MinY)/(_bbox.MaxY - _bbox.MinY); z = (z - _bbox.MinZ)/(_bbox.MaxZ - _bbox.MinZ); break; case VertexElementUsage.TexCoords: x = (x - _bbox.MinU)/(_bbox.MaxU - _bbox.MinU); y = (y - _bbox.MinV)/(_bbox.MaxV - _bbox.MinV); break; } }
/// <summary>Initializes a new vertex element attribute</summary> /// <param name="usage">What purpose the vertex element will serve</param> public VertexElementAttribute(VertexElementUsage usage) { this.usage = usage; }
private VertexElement FindElementByUsage(VertexElement[] elements, VertexElementUsage usage) { foreach (VertexElement element in elements) { if (element.VertexElementUsage == usage) return element; } return new VertexElement(); }
/// <summary> /// Determines whether this container contains given element type /// </summary> /// <param name="element">element usage</param> /// <returns>True if a vertex channel is contained fitting the element usage</returns> public bool HasElement(VertexElementUsage element) { return (from channel in VertexChannels where channel.Description.VertexElementUsage == element select channel).Any(); }
//vertex shader input requirements... void IShader.GetVertexInput(int index, out VertexElementUsage elementUsage, out int elementIndex) { elementIndex = 0; elementUsage = index == 0 ? VertexElementUsage.Position : VertexElementUsage.TextureCoordinate; }
/// <summary>Initializes a new vertex element attribute</summary> /// <param name="usage">What purpose the vertex element will serve</param> /// <param name="format">Format in in which the data for this element is provided</param> public VertexElementAttribute(VertexElementUsage usage, VertexElementFormat format) : this(usage) { this.format = format; this.formatProvided = true; }