public ArrayIndex(string name, VertexAttribPointerType type, int length)
{
Name = name;
Type = type;
Length = length;
Size = GetSize(type) * length;
}
public AttributeShaderVariable(int program, string name, int size, VertexAttribPointerType type, int stride, int offset)
: base(program, name)
{
this.size = size;
this.type = type;
this.offset = offset;
}
/// <summary>
/// Initializes a new instance of the VertexAttribAttribute.
/// </summary>
/// <param name="components">The number of components to read.</param>
/// <param name="type">The type of each component.</param>
/// <param name="normalized">Specifies whether each component should be normalized.</param>
/// <param name="index"></param>
public VertexAttribAttribute(int components, VertexAttribPointerType type, bool normalized, int index)
{
Components = components;
Type = type;
Normalized = normalized;
Index = index;
}
public ComponentType(Type type)
{
var aType = type.GetVertexAttribPointerType();
if (aType.HasValue)
t = aType.Value;
else
throw new ArgumentException("Invalid component type " + type);
}
internal GLVertexBuffer(BufferTarget target, VertexAttribPointerType glType, int stride, int size)
{
this.stride = stride;
this.size = size;
this.glType = glType;
this.target = target;
OGL.GenBuffers(1, out bufferId);
}
/// <summary>
/// 頂点属性を作成する
/// </summary>
/// <param name="name">変数名</param>
/// <param name="type">属性の種類</param>
/// <param name="size">属性の数</param>
/// <param name="offset">属性の位置</param>
/// <param name="normalized">正規化されているかどうか</param>
public VertexAttribution(string name, VertexAttribPointerType type, int size, int offset, bool normalized = false)
{
// 各パラメーターを設定
this.Name = name;
this.Type = type;
this.Size = size;
this.Offset = offset;
this.Normalized = normalized;
}
public VertexAttribute(int index, int nComponents, VertexAttribPointerType type, bool normalized = true, int offset = 0, int stride = 0)
{
this.index = index;
this.nComponents = nComponents;
this.type = type;
this.normalized = normalized;
this.offset = offset;
this.stride = stride;
}
public AttribType(String fn_in, bool bn_in, DrawElementsType egl_de_in,
VertexAttribPointerType egl_dv_in, int inum_in)
{
strNameFromFile = fn_in;
bNormalized = bn_in;
eGLTypeDrawElement = egl_de_in;
eGLTypeDrawVertex = egl_dv_in;
iNumBytes = inum_in;
}
public VertexAttributePointer(int pIndex, int pSize, VertexAttribPointerType pType, bool pIsNormalized, int pStride, int pBufferOffset)
{
this._index = pIndex;
this._size = pSize;
this._type = pType;
this._normalized = pIsNormalized;
this._stride = pStride;
this._bufferOffset = pBufferOffset;
}
/// <summary>
/// Initializes a new instance of the <see cref="VertexArrayAttribute"/> class.
/// </summary>
public VertexArrayAttribute(int index, int size, VertexAttribPointerType type, bool normalized, uint vbo, int stride, int offset)
{
Index = index;
Size = size;
Type = type;
Normalized = normalized;
VBO = vbo;
Stride = stride;
Offset = offset;
}
public VertexAttribute(Shader shader, string name, VertexAttribPointerType type, int size, int stride, bool normalized)
{
this.name = name;
this.type = type;
this.size = size;
this.stride = stride;
this.normalized = normalized;
this.shader = shader;
this.location = shader.GetAttributeLocation(name);
}
/// <summary>
/// Initializes a new instance of the <see cref="VertexAttribute"/> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="size">The size.</param>
/// <param name="type">The type.</param>
/// <param name="stride">The stride.</param>
/// <param name="offset">The offset.</param>
/// <param name="normalize">Whether to normalise the attribute's value when passing it to the shader.</param>
public VertexAttribute(string name, int size, VertexAttribPointerType type,
int stride, int offset, bool normalize = false)
{
this.name = name;
this.size = size;
this.type = type;
this.stride = stride;
this.offset = offset;
this.normalize = normalize;
}
public void SetBufferObject(int index, GPUBuffer buffer, int elementCount, VertexAttribPointerType type)
{
GPUStateMachine.BindVertexArray(id);
GL.EnableVertexAttribArray(index);
GPUStateMachine.BindBuffer(buffer.target, buffer.id);
GL.VertexAttribPointer(index, elementCount, type, false, 0, 0);
GPUStateMachine.UnbindBuffer(buffer.target);
GPUStateMachine.UnbindVertexArray();
}
public void VertexAttribPointer(
int location,
int numberOfComponents,
VertexAttribPointerType type,
bool normalised,
int vertexStride,
int offset)
{
GraphicsContext.Assert();
GL.VertexAttribPointer(location, numberOfComponents, type, normalised, vertexStride, offset);
OpenGlErrorHelper.CheckGlError();
}
public void Add(int location, int count, VertexAttribPointerType type, bool isNormalized)
{
if (count < 1 || count > 4) throw new ArgumentOutOfRangeException(nameof(count));
int entryAlignment = GetAlignment(type);
int entryOffset = Align(_vertexSize, entryAlignment);
_entries.Add(new Entry(location, count, type, isNormalized, entryAlignment, entryOffset));
int singleSize = GetSize(type);
int entrySize = (count - 1) * Align(singleSize, entryAlignment) + singleSize;
_vertexSize = entryOffset + entrySize;
_vertexStride = Align(_vertexSize, _entries[0].Alignment);
}
public VertexElement(
int offset,
string usage,
VertexAttribPointerType type,
int numberOfComponents,
bool normalised)
{
Offset = offset;
Usage = usage;
PointerType = type;
NumberOfComponents = numberOfComponents;
Normalised = normalised;
}
private static int GetAlignment(VertexAttribPointerType type)
{
switch (type)
{
case VertexAttribPointerType.Byte: return 1;
case VertexAttribPointerType.Float: return 4;
case VertexAttribPointerType.Int: return 4;
case VertexAttribPointerType.Short: return 2;
case VertexAttribPointerType.UnsignedByte: return 1;
case VertexAttribPointerType.UnsignedInt: return 4;
case VertexAttribPointerType.UnsignedShort: return 2;
default: throw new NotImplementedException($"VertexSpecification.GetAlignment not implemented for 'VertexAttribPointerType.{type}'");
}
}
public AttributeInfo( ShaderProgram shader, string identifier,
int size, int offset, int divisor, int inputOffset,
VertexAttribPointerType pointerType =
VertexAttribPointerType.Float,
bool normalize = false )
{
Shader = shader;
Identifier = identifier;
Location = GL.GetAttribLocation( shader.Program, Identifier );
Size = size;
Offset = offset;
Divisor = divisor;
InputOffset = inputOffset;
PointerType = pointerType;
Normalize = normalize;
}
public void EnableAttrib(
VboPosition id, int attribArrayIdx = -1,
VertexAttribPointerType type = VertexAttribPointerType.Float,
bool normalized = false,
int stride = 0, int offset = 0)
{
if (attribArrayIdx < 0)
attribArrayIdx = (int)id;
VboBase vboBase = this[id];
GL.BindVertexArray(Handle);
vboBase.Bind();
GL.EnableVertexAttribArray(attribArrayIdx);
GL.VertexAttribPointer(attribArrayIdx, vboBase.ElementSize, type, normalized, stride, offset);
//GL.BindVertexArray(0);
//VboBase.Unbind();
}
private static int GetSize(VertexAttribPointerType type)
{
switch (type)
{
case VertexAttribPointerType.Byte:
case VertexAttribPointerType.UnsignedByte:
return sizeof(byte);
case VertexAttribPointerType.Short:
case VertexAttribPointerType.UnsignedShort:
return sizeof(short);
case VertexAttribPointerType.Int:
case VertexAttribPointerType.UnsignedInt:
return sizeof(int);
case VertexAttribPointerType.Float:
return sizeof(float);
case VertexAttribPointerType.Double:
return sizeof(double);
case VertexAttribPointerType.HalfFloat:
return sizeof(float) / 2;
default:
throw new ArgumentOutOfRangeException("type");
}
}
public static void VertexAttribPointer(int index, int size, VertexAttribPointerType type, bool normalized,
int stride, int offset)
{
ES20.GL.VertexAttribPointer(index, size, type, normalized, stride, offset);
CheckError();
}
public abstract void VertexAttribIPointer <T0>([Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] int size, [Flow(FlowDirection.In)] VertexAttribPointerType type, [Flow(FlowDirection.In)] uint stride, [Count(Computed = "size, type, stride"), Flow(FlowDirection.In)] ref T0 pointer) where T0 : unmanaged;
public ComponentType(VertexAttribPointerType type)
{
t = type;
}
public VertexMemberAttribute(int count, VertexAttribPointerType type)
{
Count = count;
Type = type;
Normalized = false;
}
public void AddAttribute(int index, int size, VertexAttribPointerType type, bool normalized, int stride, int offset)
{
attributes[index] = new VertexAttribute(size, type, normalized, stride, offset);
}
public ElementFormat(VertexAttribPointerType type, int size, bool normalized = false)
{
Type = type;
Size = size;
Normalized = normalized;
}
private void BindVertexLayout(GalPipelineState New)
{
foreach (GalVertexBinding Binding in New.VertexBindings)
{
if (!Binding.Enabled || !Rasterizer.TryGetVbo(Binding.VboKey, out int VboHandle))
{
continue;
}
if (VaoHandle == 0)
{
VaoHandle = GL.GenVertexArray();
//Vertex arrays shouldn't be used anywhere else in OpenGL's backend
//if you want to use it, move this line out of the if
GL.BindVertexArray(VaoHandle);
}
foreach (GalVertexAttrib Attrib in Binding.Attribs)
{
GL.EnableVertexAttribArray(Attrib.Index);
GL.BindBuffer(BufferTarget.ArrayBuffer, VboHandle);
bool Unsigned =
Attrib.Type == GalVertexAttribType.Unorm ||
Attrib.Type == GalVertexAttribType.Uint ||
Attrib.Type == GalVertexAttribType.Uscaled;
bool Normalize =
Attrib.Type == GalVertexAttribType.Snorm ||
Attrib.Type == GalVertexAttribType.Unorm;
VertexAttribPointerType Type = 0;
if (Attrib.Type == GalVertexAttribType.Float)
{
Type = VertexAttribPointerType.Float;
}
else
{
Type = AttribTypes[Attrib.Size] + (Unsigned ? 1 : 0);
}
int Size = AttribElements[Attrib.Size];
int Offset = Attrib.Offset;
if (Attrib.Type == GalVertexAttribType.Sint ||
Attrib.Type == GalVertexAttribType.Uint)
{
IntPtr Pointer = new IntPtr(Offset);
VertexAttribIntegerType IType = (VertexAttribIntegerType)Type;
GL.VertexAttribIPointer(Attrib.Index, Size, IType, Binding.Stride, Pointer);
}
else
{
GL.VertexAttribPointer(Attrib.Index, Size, Type, Normalize, Binding.Stride, Offset);
}
}
}
}
public AttribBuffer(T[] data, string attributeName, VertexAttribPointerType attribPointerType) : base(data)
{
AttributeName = attributeName;
AttribPointerType = attribPointerType;
}
public void AddAttribute( string identifier, int size, int divisor = 0, int inputOffset = -1,
VertexAttribPointerType pointerType = VertexAttribPointerType.Float,
bool normalize = false )
{
if ( inputOffset == -1 )
inputOffset = VertexDataSize;
AttributeInfo info = new AttributeInfo( this, identifier, size, VertexDataStride,
divisor, inputOffset - VertexDataSize, pointerType, normalize );
VertexDataStride += info.Length;
VertexDataSize += info.Size;
myAttributes.Add( info );
ErrorCheck( "addattrib:" + identifier );
}
private void CheckAttribute(int count, VertexAttribPointerType type)
{
var entry = Specification[_specificationIndex];
if (entry.Count != count || entry.Type != type) throw new InvalidOperationException("Invalid vertex attribute type");
++_specificationIndex;
}
private static bool IsInteger(VertexAttribPointerType type)
{
switch (type)
{
case VertexAttribPointerType.Byte:
case VertexAttribPointerType.UnsignedByte:
case VertexAttribPointerType.Short:
case VertexAttribPointerType.UnsignedShort:
case VertexAttribPointerType.Int:
case VertexAttribPointerType.UnsignedInt:
return true;
default:
return false;
}
}
/// <summary>
/// Initializes a new instance of the VertexAttribAttribute.
/// </summary>
/// <param name="components">The number of components to read.</param>
/// <param name="type">The type of each component.</param>
/// <param name="normalized">Specifies whether each component should be normalized.</param>
public VertexAttribAttribute(int components, VertexAttribPointerType type, bool normalized)
: this(components, type, normalized, -1)
{
}
/// <summary>
/// Initializes a new instance of the VertexAttribAttribute.<br/>
/// Normalization defaults to false.
/// </summary>
/// <param name="components">The number of components to read.</param>
/// <param name="type">The type of each component.</param>
public VertexAttribAttribute(int components, VertexAttribPointerType type)
: this(components, type, false, -1)
{
}
public partial void VertexAttribArrayObject([Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] int size, [Flow(FlowDirection.In)] VertexAttribPointerType type, [Flow(FlowDirection.In)] bool normalized, [Flow(FlowDirection.In)] uint stride, [Flow(FlowDirection.In)] uint buffer, [Flow(FlowDirection.In)] uint offset);
public void AddPointer(ShaderProgram shader, string shaderArgName, int itemCount, VertexAttribPointerType itemType, int stride, int offset) => AddPointer(shader.GetAttribLocation(shaderArgName), itemCount, itemType, stride, offset, 0);
public void SendVertexBuffer(int Index, byte[] Buffer, int Stride, GalVertexAttrib[] Attribs)
{
if (Index < 0)
{
throw new ArgumentOutOfRangeException(nameof(Index));
}
if (Buffer.Length == 0 || Stride == 0)
{
return;
}
EnsureVbInitialized(Index);
VertexBuffer Vb = VertexBuffers[Index];
Vb.PrimCount = Buffer.Length / Stride;
VertexBuffers[Index] = Vb;
IntPtr Length = new IntPtr(Buffer.Length);
GL.BindBuffer(BufferTarget.ArrayBuffer, Vb.VboHandle);
GL.BufferData(BufferTarget.ArrayBuffer, Length, Buffer, BufferUsageHint.StreamDraw);
GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
GL.BindVertexArray(Vb.VaoHandle);
for (int Attr = 0; Attr < 16; Attr++)
{
GL.DisableVertexAttribArray(Attr);
}
foreach (GalVertexAttrib Attrib in Attribs)
{
if (Attrib.Index >= 3)
{
break;
}
GL.EnableVertexAttribArray(Attrib.Index);
GL.BindBuffer(BufferTarget.ArrayBuffer, Vb.VboHandle);
int Size = 0;
switch (Attrib.Size)
{
case GalVertexAttribSize._8:
case GalVertexAttribSize._16:
case GalVertexAttribSize._32:
Size = 1;
break;
case GalVertexAttribSize._8_8:
case GalVertexAttribSize._16_16:
case GalVertexAttribSize._32_32:
Size = 2;
break;
case GalVertexAttribSize._8_8_8:
case GalVertexAttribSize._11_11_10:
case GalVertexAttribSize._16_16_16:
case GalVertexAttribSize._32_32_32:
Size = 3;
break;
case GalVertexAttribSize._8_8_8_8:
case GalVertexAttribSize._10_10_10_2:
case GalVertexAttribSize._16_16_16_16:
case GalVertexAttribSize._32_32_32_32:
Size = 4;
break;
}
bool Signed =
Attrib.Type == GalVertexAttribType.Snorm ||
Attrib.Type == GalVertexAttribType.Sint ||
Attrib.Type == GalVertexAttribType.Sscaled;
bool Normalize =
Attrib.Type == GalVertexAttribType.Snorm ||
Attrib.Type == GalVertexAttribType.Unorm;
VertexAttribPointerType Type = 0;
switch (Attrib.Type)
{
case GalVertexAttribType.Snorm:
case GalVertexAttribType.Unorm:
case GalVertexAttribType.Sint:
case GalVertexAttribType.Uint:
case GalVertexAttribType.Uscaled:
case GalVertexAttribType.Sscaled:
{
switch (Attrib.Size)
{
case GalVertexAttribSize._8:
case GalVertexAttribSize._8_8:
case GalVertexAttribSize._8_8_8:
case GalVertexAttribSize._8_8_8_8:
{
Type = Signed
? VertexAttribPointerType.Byte
: VertexAttribPointerType.UnsignedByte;
break;
}
case GalVertexAttribSize._16:
case GalVertexAttribSize._16_16:
case GalVertexAttribSize._16_16_16:
case GalVertexAttribSize._16_16_16_16:
{
Type = Signed
? VertexAttribPointerType.Short
: VertexAttribPointerType.UnsignedShort;
break;
}
case GalVertexAttribSize._10_10_10_2:
case GalVertexAttribSize._11_11_10:
case GalVertexAttribSize._32:
case GalVertexAttribSize._32_32:
case GalVertexAttribSize._32_32_32:
case GalVertexAttribSize._32_32_32_32:
{
Type = Signed
? VertexAttribPointerType.Int
: VertexAttribPointerType.UnsignedInt;
break;
}
}
break;
}
case GalVertexAttribType.Float:
{
Type = VertexAttribPointerType.Float;
break;
}
}
GL.VertexAttribPointer(
Attrib.Index,
Size,
Type,
Normalize,
Stride,
Attrib.Offset);
}
GL.BindVertexArray(0);
}
public unsafe void VertexAttributePointer(uint index, int count, VertexAttribPointerType type, uint vertexSize, int offSet)
{
_gl.VertexAttribPointer(index, count, type, false, vertexSize * (uint)sizeof(TVertexType), (void *)(offSet * sizeof(TVertexType)));
_gl.EnableVertexAttribArray(index);
}
public void EnableTextureVertices(int size, VertexAttribPointerType type, bool normalized, int stride, float[] vertices)
{
GL.EnableVertexAttribArray(maTexCoordHandle);
GL.VertexAttribPointer(maTexCoordHandle, size, type, normalized, stride, vertices);
}
public ElementFormat(VertexAttribPointerType type, byte size, bool normalized = false)
{
Type = type;
Size = size;
Normalized = normalized;
}
private void AssertVertexElementProperties(
VertexElement element,
int offset,
VertexAttribPointerType type,
int numberOfComponents,
bool normalised)
{
element.ShouldSatisfyAllConditions(
() => element.Offset.ShouldBe(offset),
() => element.PointerType.ShouldBe(type),
() => element.NumberOfComponents.ShouldBe(numberOfComponents),
() => element.Normalised.ShouldBe(normalised)
);
}
/// <summary>
/// extend the vertex array layout
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="type"></param>
/// <param name="count"></param>
public void Add <T>(VertexAttribPointerType type, int count) where T : struct
{
element.Add(new VertexArrayLayout(type, Marshal.SizeOf <T>(), count, false));
stride += sizeof(float) * count;
}
/// <summary>
/// Creates a <see cref="VertexAttribSource"/> with a given <see cref="BufferObjectSubset"/> and specifies
/// a vertex attribute where the data format in the shader and the buffer don't match and need conversion.
/// </summary>
/// <param name="bufferSubset">The <see cref="BufferObjectSubset"/> where the vertex attrib data is located. Must be a subset usable for vertex data.</param>
/// <param name="attribType">The type of attribute declared in the shader.</param>
/// <param name="normalized">Whether the data needs to be normalized (uint/ushort/byte -> float between 0 and 1, or int/short/sbyte -> float between -1 and 1).</param>
/// <param name="dataBaseType">The base type of the data found on the buffer. If normalized is true, this must be an integer type.</param>
/// <param name="attribDivisor">The divisor that defines how reading this attribute advances on instanced rendering.</param>
public VertexAttribSource(DataBufferSubset bufferSubset, AttributeType attribType, bool normalized, VertexAttribPointerType dataBaseType, uint attribDivisor = 0)
: this(bufferSubset, new VertexAttribDescription(attribType, normalized, dataBaseType, attribDivisor))
{
}
public VertexMemberAttribute(int count, VertexAttribPointerType type, bool normalized)
{
Count = count;
Type = type;
Normalized = normalized;
}
public void VertexAttributePointer(uint index, int count, VertexAttribPointerType type, uint vertexSize, int offset)
{
gl.VertexAttribPointer(index, count, type, false, (uint)(vertexSize * sizeof(float)), (void *)(offset));
gl.EnableVertexAttribArray(index);
}
public abstract unsafe void VertexAttribIPointer([Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] int size, [Flow(FlowDirection.In)] VertexAttribPointerType type, [Flow(FlowDirection.In)] uint stride, [Count(Computed = "size, type, stride"), Flow(FlowDirection.In)] void *pointer);
public void VertexAttributePointer(uint index, int count, VertexAttribPointerType type, string fieldName)
{
gl.VertexAttribPointer(index, count, type, false, (uint)(sizeof(VertexType)), (void *)Marshal.OffsetOf <VertexType>(fieldName));
gl.EnableVertexAttribArray(index);
}
public void AddAttribute <Type>(int attributeLocation, Type[] array, int baseTypeCount, VertexAttribPointerType type) where Type : struct
{
if (-1 == attributeLocation)
{
throw new ArgumentException("Invalid attribute location");
}
if (0 == array.Length)
{
throw new ArgumentException("Empty attribute array");
}
if (0 != _count && array.Length != _count)
{
throw new ArgumentException("Attribute arrays with different sizes given");
}
_count = array.Length;
int byteSize = Marshal.SizeOf(array[0]) * array.Length;
var buffer = GL.GenBuffer();
_buffers.Add(buffer);
GL.BindVertexArray(_vertexArray); // activate vertex array; from now on state is stored;
GL.BindBuffer(BufferTarget.ArrayBuffer, buffer); // activate buffer
GL.BufferData(BufferTarget.ArrayBuffer, byteSize, array, BufferUsageHint.StaticDraw); //copy data over to GPU
GL.EnableVertexAttribArray(attributeLocation); // activate this vertex attribute for the active vertex array
GL.VertexAttribPointer(attributeLocation, baseTypeCount, type, false, 0, 0); // specify what our buffer contains
GL.BindVertexArray(0); // deactivate vertex array; state storing is stopped;
GL.BindBuffer(BufferTarget.ArrayBuffer, 0); // deactivate buffer; just to be on the cautious side;
GL.DisableVertexAttribArray(attributeLocation); // cleanup state...
}
public VertexAttributePointer(int pIndex, int pSize, VertexAttribPointerType pType)
: this(pIndex, pSize, pType, false, 0, 0)
{
}
private void BindVertexLayout(GalPipelineState New)
{
foreach (GalVertexBinding binding in New.VertexBindings)
{
if (!binding.Enabled || !_rasterizer.TryGetVbo(binding.VboKey, out int vboHandle))
{
continue;
}
if (_vaoHandle == 0)
{
_vaoHandle = GL.GenVertexArray();
// Vertex arrays shouldn't be used anywhere else in OpenGL's backend
// if you want to use it, move this line out of the if
GL.BindVertexArray(_vaoHandle);
}
foreach (GalVertexAttrib attrib in binding.Attribs)
{
// Skip uninitialized attributes.
if (attrib.Size == 0)
{
continue;
}
GL.BindBuffer(BufferTarget.ArrayBuffer, vboHandle);
bool unsigned =
attrib.Type == GalVertexAttribType.Unorm ||
attrib.Type == GalVertexAttribType.Uint ||
attrib.Type == GalVertexAttribType.Uscaled;
bool normalize =
attrib.Type == GalVertexAttribType.Snorm ||
attrib.Type == GalVertexAttribType.Unorm;
VertexAttribPointerType type = 0;
if (attrib.Type == GalVertexAttribType.Float)
{
type = GetType(_floatAttribTypes, attrib);
}
else
{
if (unsigned)
{
type = GetType(_unsignedAttribTypes, attrib);
}
else
{
type = GetType(_signedAttribTypes, attrib);
}
}
if (!_attribElements.TryGetValue(attrib.Size, out int size))
{
throw new InvalidOperationException("Invalid attribute size \"" + attrib.Size + "\"!");
}
int offset = attrib.Offset;
if (binding.Stride != 0)
{
GL.EnableVertexAttribArray(attrib.Index);
if (attrib.Type == GalVertexAttribType.Sint ||
attrib.Type == GalVertexAttribType.Uint)
{
IntPtr pointer = new IntPtr(offset);
VertexAttribIntegerType iType = (VertexAttribIntegerType)type;
GL.VertexAttribIPointer(attrib.Index, size, iType, binding.Stride, pointer);
}
else
{
GL.VertexAttribPointer(attrib.Index, size, type, normalize, binding.Stride, offset);
}
}
else
{
GL.DisableVertexAttribArray(attrib.Index);
SetConstAttrib(attrib);
}
if (binding.Instanced && binding.Divisor != 0)
{
GL.VertexAttribDivisor(attrib.Index, 1);
}
else
{
GL.VertexAttribDivisor(attrib.Index, 0);
}
}
}
}
public void writeGeomToStream(StreamWriter s, ref uint index)
{
int vertcount = metaData.vertrend_graphics - metaData.vertrstart_graphics + 1;
MemoryStream vms = new MemoryStream(gobject.meshDataDict[metaData.Hash].vs_buffer);
MemoryStream ims = new MemoryStream(gobject.meshDataDict[metaData.Hash].is_buffer);
BinaryReader vbr = new BinaryReader(vms);
BinaryReader ibr = new BinaryReader(ims);
//Start Writing
//Object name
s.WriteLine("o " + name);
//Get Verts
//Preset Matrices for faster export
Matrix4 wMat = this.worldMat;
Matrix4 nMat = Matrix4.Invert(Matrix4.Transpose(wMat));
vbr.BaseStream.Seek(0, SeekOrigin.Begin);
for (int i = 0; i < vertcount; i++)
{
Vector4 v;
VertexAttribPointerType ntype = gobject.bufInfo[0].type;
int v_section_bytes = 0;
switch (ntype)
{
case VertexAttribPointerType.HalfFloat:
uint v1 = vbr.ReadUInt16();
uint v2 = vbr.ReadUInt16();
uint v3 = vbr.ReadUInt16();
//uint v4 = Convert.ToUInt16(vbr.ReadUInt16());
//Transform vector with worldMatrix
v = new Vector4(Utils.Half.decompress(v1), Utils.Half.decompress(v2), Utils.Half.decompress(v3), 1.0f);
v_section_bytes = 6;
break;
case VertexAttribPointerType.Float: //This is used in my custom vbos
float f1 = vbr.ReadSingle();
float f2 = vbr.ReadSingle();
float f3 = vbr.ReadSingle();
//Transform vector with worldMatrix
v = new Vector4(f1, f2, f3, 1.0f);
v_section_bytes = 12;
break;
default:
throw new Exception("Unimplemented Vertex Type");
}
v = Vector4.Transform(v, this.worldMat);
//s.WriteLine("v " + Half.decompress(v1).ToString() + " "+ Half.decompress(v2).ToString() + " " + Half.decompress(v3).ToString());
s.WriteLine("v " + v.X.ToString() + " " + v.Y.ToString() + " " + v.Z.ToString());
vbr.BaseStream.Seek(gobject.vx_size - v_section_bytes, SeekOrigin.Current);
}
//Get Normals
vbr.BaseStream.Seek(gobject.offsets[2] + 0, SeekOrigin.Begin);
for (int i = 0; i < vertcount; i++)
{
Vector4 vN;
VertexAttribPointerType ntype = gobject.bufInfo[2].type;
int n_section_bytes = 0;
switch (ntype)
{
case (VertexAttribPointerType.Float):
float f1, f2, f3;
f1 = vbr.ReadSingle();
f2 = vbr.ReadSingle();
f3 = vbr.ReadSingle();
vN = new Vector4(f1, f2, f3, 1.0f);
n_section_bytes = 12;
break;
case (VertexAttribPointerType.HalfFloat):
uint v1, v2, v3;
v1 = vbr.ReadUInt16();
v2 = vbr.ReadUInt16();
v3 = vbr.ReadUInt16();
vN = new Vector4(Utils.Half.decompress(v1), Utils.Half.decompress(v2), Utils.Half.decompress(v3), 1.0f);
n_section_bytes = 6;
break;
case (VertexAttribPointerType.Int2101010Rev):
int i1, i2, i3;
uint value;
byte[] a32 = new byte[4];
a32 = vbr.ReadBytes(4);
value = BitConverter.ToUInt32(a32, 0);
//Convert Values
i1 = _2sComplement.toInt((value >> 00) & 0x3FF, 10);
i2 = _2sComplement.toInt((value >> 10) & 0x3FF, 10);
i3 = _2sComplement.toInt((value >> 20) & 0x3FF, 10);
//int i4 = _2sComplement.toInt((value >> 30) & 0x003, 10);
float norm = (float)Math.Sqrt(i1 * i1 + i2 * i2 + i3 * i3);
vN = new Vector4(Convert.ToSingle(i1) / norm,
Convert.ToSingle(i2) / norm,
Convert.ToSingle(i3) / norm,
1.0f);
n_section_bytes = 4;
//Debug.WriteLine(vN);
break;
default:
throw new Exception("UNIMPLEMENTED NORMAL TYPE. PLEASE REPORT");
}
//uint v4 = Convert.ToUInt16(vbr.ReadUInt16());
//Transform normal with normalMatrix
vN = Vector4.Transform(vN, nMat);
s.WriteLine("vn " + vN.X.ToString() + " " + vN.Y.ToString() + " " + vN.Z.ToString());
vbr.BaseStream.Seek(gobject.vx_size - n_section_bytes, SeekOrigin.Current);
}
//Get UVs, only for mesh objects
vbr.BaseStream.Seek(Math.Max(gobject.offsets[1], 0) + gobject.vx_size * metaData.vertrstart_graphics, SeekOrigin.Begin);
for (int i = 0; i < vertcount; i++)
{
Vector2 uv;
int uv_section_bytes = 0;
if (gobject.offsets[1] != -1) //Check if uvs exist
{
uint v1 = vbr.ReadUInt16();
uint v2 = vbr.ReadUInt16();
uint v3 = vbr.ReadUInt16();
//uint v4 = Convert.ToUInt16(vbr.ReadUInt16());
uv = new Vector2(Utils.Half.decompress(v1), Utils.Half.decompress(v2));
uv_section_bytes = 0x6;
}
else
{
uv = new Vector2(0.0f, 0.0f);
uv_section_bytes = gobject.vx_size;
}
s.WriteLine("vt " + uv.X.ToString() + " " + (1.0 - uv.Y).ToString());
vbr.BaseStream.Seek(gobject.vx_size - uv_section_bytes, SeekOrigin.Current);
}
//Some Options
s.WriteLine("usemtl(null)");
s.WriteLine("s off");
//Get indices
ibr.BaseStream.Seek(0, SeekOrigin.Begin);
bool start = false;
uint fstart = 0;
for (int i = 0; i < metaData.batchcount / 3; i++)
{
uint f1, f2, f3;
//NEXT models assume that all gstream meshes have uint16 indices
f1 = ibr.ReadUInt16();
f2 = ibr.ReadUInt16();
f3 = ibr.ReadUInt16();
if (!start && this.type != TYPES.COLLISION)
{
fstart = f1; start = true;
}
else if (!start && this.type == TYPES.COLLISION)
{
fstart = 0; start = true;
}
uint f11, f22, f33;
f11 = f1 - fstart + index;
f22 = f2 - fstart + index;
f33 = f3 - fstart + index;
s.WriteLine("f " + f11.ToString() + "/" + f11.ToString() + "/" + f11.ToString() + " "
+ f22.ToString() + "/" + f22.ToString() + "/" + f22.ToString() + " "
+ f33.ToString() + "/" + f33.ToString() + "/" + f33.ToString() + " ");
}
index += (uint)vertcount;
}
public void AddPointer(int shaderArgIndex, int itemCount, VertexAttribPointerType itemType, int stride, int offset) => AddPointer(shaderArgIndex, itemCount, itemType, stride, offset, 0);
public partial void VertexAttribP1([Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] VertexAttribPointerType type, [Flow(FlowDirection.In)] Boolean normalized, [Flow(FlowDirection.In)] uint value);
public static unsafe void VertexAttribPointer <T0>(this ArbVertexProgram thisApi, [Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] int size, [Flow(FlowDirection.In)] VertexAttribPointerType type, [Flow(FlowDirection.In)] bool normalized, [Flow(FlowDirection.In)] uint stride, [Count(Computed = "size, type, stride"), Flow(FlowDirection.In)] ReadOnlySpan <T0> pointer) where T0 : unmanaged
{
// SpanOverloader
thisApi.VertexAttribPointer(index, size, type, normalized, stride, in pointer.GetPinnableReference());
}
public void EnableAttribute(int id, int size, VertexAttribPointerType type, int stride, int offset)
{
GL.EnableVertexAttribArray(id);
GL.VertexAttribPointer(id, size, type, false, stride * sizeof(float), offset * sizeof(float));
}
private void BindVertexLayout(GalPipelineState New)
{
foreach (GalVertexBinding Binding in New.VertexBindings)
{
if (!Binding.Enabled || !Rasterizer.TryGetVbo(Binding.VboKey, out int VboHandle))
{
continue;
}
if (VaoHandle == 0)
{
VaoHandle = GL.GenVertexArray();
//Vertex arrays shouldn't be used anywhere else in OpenGL's backend
//if you want to use it, move this line out of the if
GL.BindVertexArray(VaoHandle);
}
foreach (GalVertexAttrib Attrib in Binding.Attribs)
{
//Skip uninitialized attributes.
if (Attrib.Size == 0)
{
continue;
}
GL.BindBuffer(BufferTarget.ArrayBuffer, VboHandle);
bool Unsigned =
Attrib.Type == GalVertexAttribType.Unorm ||
Attrib.Type == GalVertexAttribType.Uint ||
Attrib.Type == GalVertexAttribType.Uscaled;
bool Normalize =
Attrib.Type == GalVertexAttribType.Snorm ||
Attrib.Type == GalVertexAttribType.Unorm;
VertexAttribPointerType Type = 0;
if (Attrib.Type == GalVertexAttribType.Float)
{
Type = GetType(FloatAttribTypes, Attrib);
}
else
{
if (Unsigned)
{
Type = GetType(UnsignedAttribTypes, Attrib);
}
else
{
Type = GetType(SignedAttribTypes, Attrib);
}
}
if (!AttribElements.TryGetValue(Attrib.Size, out int Size))
{
throw new InvalidOperationException("Invalid attribute size \"" + Attrib.Size + "\"!");
}
int Offset = Attrib.Offset;
if (Binding.Stride != 0)
{
GL.EnableVertexAttribArray(Attrib.Index);
if (Attrib.Type == GalVertexAttribType.Sint ||
Attrib.Type == GalVertexAttribType.Uint)
{
IntPtr Pointer = new IntPtr(Offset);
VertexAttribIntegerType IType = (VertexAttribIntegerType)Type;
GL.VertexAttribIPointer(Attrib.Index, Size, IType, Binding.Stride, Pointer);
}
else
{
GL.VertexAttribPointer(Attrib.Index, Size, Type, Normalize, Binding.Stride, Offset);
}
}
else
{
GL.DisableVertexAttribArray(Attrib.Index);
SetConstAttrib(Attrib);
}
if (Binding.Instanced && Binding.Divisor != 0)
{
GL.VertexAttribDivisor(Attrib.Index, 1);
}
else
{
GL.VertexAttribDivisor(Attrib.Index, 0);
}
}
}
}
public abstract void VertexAttribP4([Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] VertexAttribPointerType type, [Flow(FlowDirection.In)] bool normalized, [Count(Count = 1), Flow(FlowDirection.In)] ref uint value);
public static void VertexAttribPointer(uint index, int size, VertexAttribPointerType type, bool normalized, int stride, int offset)
{
VertexAttribPointer(index, size, type, normalized, stride, (IntPtr)offset);
}
unsafe static int GetGLTypeSize(VertexAttribPointerType type)
{
switch(type)
{
case VertexAttribPointerType.UnsignedByte:
return sizeof(byte);
case VertexAttribPointerType.UnsignedShort:
return sizeof(short);
case VertexAttribPointerType.Byte:
return sizeof(byte);
case VertexAttribPointerType.Float:
return sizeof(float);
//case VertexAttribPointerType.Fixed:
}
/*switch(type)
{
case All.Byte:
return sizeof(byte);
case All.UnsignedByte:
return sizeof(byte);
case All.UnsignedShort:
return sizeof(short);
case All.Int:
return sizeof(int);
case All.UnsignedInt:
return sizeof(uint);
case All.Float:
return sizeof(float);
}*/
return 0;
}
public static void VertexAttribPointer(int index, int size, VertexAttribPointerType type, bool normalized, int stride, int offset)
{
VertexAttribPointer(index, size, type, normalized, stride, (IntPtr)offset);
}
/// <summary>
/// Creates a <see cref="VertexAttribSource"/> that specifies padding for an
/// amount of bytes calculated based on the baseType and size parameters.
/// </summary>
/// <param name="bufferSubset">The buffer subset in which the padding will be applied.</param>
/// <param name="baseType">The base type of the attribute.</param>
/// <param name="size">The size of the attribute.</param>
public static VertexAttribSource CreatePadding(DataBufferSubset bufferSubset, VertexAttribPointerType baseType, uint size)
{
return(new VertexAttribSource(bufferSubset, VertexAttribDescription.CreatePadding(baseType, size)));
}