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 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;
}
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 Attribute(VertexElementUsage usage_,
int index_,
string name_,
short format_)
{
usage = usage_;
index = index_;
name = name_;
format = format_;
}
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]];
}
}
public VertexElementLayout(int stream, int offset, VertexElementType type, VertexElementUsage usage, int usageIndex)
{
Stream = stream;
Offset = offset;
Type = type;
Usage = usage;
UsageIndex = usageIndex;
}
/// <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;
}
