//! Create Vertex Array Object
public void Create <T_INDEX>(TVertexFormat[] formats, T_INDEX[] indices) where T_INDEX : struct
{
this._index_size = Marshal.SizeOf(default(T_INDEX));
this._no_of_indices = indices.Length;
VertexAttribType v_type = this._elem_size == 8 ? VertexAttribType.Double : VertexAttribType.Float;
GL.CreateVertexArrays(1, out this._vao);
foreach (var vbo in this._vbos)
{
GL.VertexArrayVertexBuffer(this._vao, vbo.Key, vbo.Value, IntPtr.Zero, this._vbos_stride[vbo.Key] * this._elem_size);
}
foreach (var f in formats)
{
GL.VertexArrayAttribFormat(this._vao, f.attribute_index, f.tuple_size, v_type, f.normalize, f.elems_offset * this._elem_size);
GL.VertexArrayAttribBinding(this._vao, f.attribute_index, f.buffer_id);
GL.EnableVertexArrayAttrib(this._vao, f.attribute_index);
}
if (this._no_of_indices > 0)
{
GL.CreateBuffers(1, out this._ibo);
GL.NamedBufferStorage <T_INDEX>(this._ibo, this._no_of_indices * this._index_size, indices, BufferStorageFlags.None);
GL.VertexArrayElementBuffer(this._vao, this._ibo);
}
GL.BindVertexArray(0);
}
public static void VertexAttribArrayObjectATI(UInt32 index, Int32 size, VertexAttribType type, bool normalized, Int32 stride, UInt32 buffer, UInt32 offset)
{
Debug.Assert(Delegates.pglVertexAttribArrayObjectATI != null, "pglVertexAttribArrayObjectATI not implemented");
Delegates.pglVertexAttribArrayObjectATI(index, size, (Int32)type, normalized, stride, buffer, offset);
LogCommand("glVertexAttribArrayObjectATI", null, index, size, type, normalized, stride, buffer, offset);
DebugCheckErrors(null);
}
public int GetVertexCount()
{
int result = -1;
if (this.vbo == null)
{
return(result);
}
int byteLength = this.vbo.Data.Length;
// we know that all data types are in VertexAttribType.
VertexAttribType type = (VertexAttribType)this.dataType;
if (!Enum.IsDefined(typeof(VertexAttribType), type))
{
return(result);
}
uint typeLength = type.GetByteLength(); // byte length of specified type.
uint typeCount = (uint)(this.dataSize == GL.GL_BGRA ? 4 : this.dataSize); // how many elements of specified type in one vertex?
uint vertexLength = typeLength * typeCount + stride; // byte length of a single vertex.
result = (int)(byteLength / vertexLength); // how many vertex?
if ((byteLength % vertexLength) != 0)
{
throw new Exception(string.Format("GetVertexCount() error! [{0} % {1}, t:{2}, s:{3}]", byteLength, vertexLength, type, typeCount));
}
return(result);
}
public static void VertexAttribLFormatNV(UInt32 index, Int32 size, VertexAttribType type, Int32 stride)
{
Debug.Assert(Delegates.pglVertexAttribLFormatNV != null, "pglVertexAttribLFormatNV not implemented");
Delegates.pglVertexAttribLFormatNV(index, size, (Int32)type, stride);
LogCommand("glVertexAttribLFormatNV", null, index, size, type, stride);
DebugCheckErrors(null);
}
public Attribute(int index, int count, VertexAttribType type, int relativeOffset, int divisor = 0)
{
Index = index;
Count = count;
Type = type;
RelativeOffset = relativeOffset;
Divisor = divisor;
}
public static void VertexAttribArray(int index, int bindingIndex, int count, VertexAttribType type,
bool normalised = false, int offset = 0, int divisor = 0)
{
GL.VertexAttribFormat(index, count, type, normalised, offset);
GL.VertexAttribBinding(index, bindingIndex);
GL.VertexBindingDivisor(index, divisor);
GL.EnableVertexAttribArray(index);
}
public VertexAttribute(string name, int index, VertexAttribType type, int components, int offset)
{
Name = name;
Index = index;
Type = type;
Components = components;
Offset = offset;
}
public void SetVertexAttributes(ReadOnlySpan <VertexAttribDescriptor> vertexAttribs)
{
int index = 0;
for (; index < vertexAttribs.Length; index++)
{
VertexAttribDescriptor attrib = vertexAttribs[index];
if (attrib.Equals(_vertexAttribs[index]))
{
continue;
}
FormatInfo fmtInfo = FormatTable.GetFormatInfo(attrib.Format);
if (attrib.IsZero)
{
// Disabling the attribute causes the shader to read a constant value.
// The value is configurable, but by default is a vector of (0, 0, 0, 1).
DisableVertexAttrib(index);
}
else
{
EnableVertexAttrib(index);
}
int offset = attrib.Offset;
int size = fmtInfo.Components;
bool isFloat = fmtInfo.PixelType == PixelType.Float ||
fmtInfo.PixelType == PixelType.HalfFloat;
if (isFloat || fmtInfo.Normalized || fmtInfo.Scaled)
{
VertexAttribType type = (VertexAttribType)fmtInfo.PixelType;
GL.VertexAttribFormat(index, size, type, fmtInfo.Normalized, offset);
}
else
{
VertexAttribIntegerType type = (VertexAttribIntegerType)fmtInfo.PixelType;
GL.VertexAttribIFormat(index, size, type, offset);
}
GL.VertexAttribBinding(index, attrib.BufferIndex);
_vertexAttribs[index] = attrib;
}
_vertexAttribsCount = index;
for (; index < Constants.MaxVertexAttribs; index++)
{
DisableVertexAttrib(index);
}
}
public static void VertexArrayAttribFormat(int obj, int attIndex, int size, VertexAttribType type, bool normalized, int relativeOffset)
{
GL.VertexArrayAttribFormat(obj, attIndex, size, type, normalized, relativeOffset);
if (enableErrorCheck)
{
LogErrors();
}
}
/// <summary>
/// Creates a new attribute description
/// </summary>
/// <param name="name">Name of attribute in GLSL shader</param>
/// <param name="size">Component count</param>
/// <param name="attributeType">Type of components</param>
/// <param name="normalized">Data is normalized</param>
/// <param name="vertexSize">Size of full vertex</param>
/// <param name="offset">Offset from beginning of vertex instance memory</param>
public VertexAttributeDescription(string name, int size, VertexAttribType attributeType, bool normalized, int vertexSize, int offset)
{
Name = name;
Size = size;
AttributeType = attributeType;
Normalized = normalized;
VertexSize = vertexSize;
Offset = offset;
}
public VertexAttribute(int id, byte[] data, VertexAttribType type, int count, bool normalize, bool interleave)
{
Id = id;
Data = data;
Type = type;
AttribCount = count;
ShouldNormalize = normalize;
ShouldInterleave = interleave;
}
public void SetVertexAttributes(VertexAttribDescriptor[] vertexAttribs)
{
int attribIndex = 0;
foreach (VertexAttribDescriptor attrib in vertexAttribs)
{
FormatInfo fmtInfo = FormatTable.GetFormatInfo(attrib.Format);
if (attrib.IsZero)
{
// Disabling the attribute causes the shader to read a constant value.
// The value is configurable, but by default is a vector of (0, 0, 0, 1).
GL.DisableVertexAttribArray(attribIndex);
}
else
{
GL.EnableVertexAttribArray(attribIndex);
}
int offset = attrib.Offset;
int size = fmtInfo.Components;
bool isFloat = fmtInfo.PixelType == PixelType.Float ||
fmtInfo.PixelType == PixelType.HalfFloat;
if (isFloat || fmtInfo.Normalized || fmtInfo.Scaled)
{
VertexAttribType type = (VertexAttribType)fmtInfo.PixelType;
GL.VertexAttribFormat(attribIndex, size, type, fmtInfo.Normalized, offset);
}
else
{
VertexAttribIntegerType type = (VertexAttribIntegerType)fmtInfo.PixelType;
GL.VertexAttribIFormat(attribIndex, size, type, offset);
}
GL.VertexAttribBinding(attribIndex, attrib.BufferIndex);
attribIndex++;
}
for (; attribIndex < 16; attribIndex++)
{
GL.DisableVertexAttribArray(attribIndex);
}
_vertexAttribs = vertexAttribs;
}
/// <summary>
/// Creates a new vertex attribute for use in a VertexBufferFormat object
/// </summary>
/// <param name="attribIndex">Attribute index used to access this attribute in the vertex shader</param>
/// <param name="bindingIndex"></param>
/// <param name="size">The number of components of this vertex attribute (1 for a scalar, 3 for a vec3...)</param>
/// <param name="relativeOffset">Relative offset of this attribute's data inside the source buffer</param>
/// <param name="type">Data type the attribute</param>
/// <param name="dataClass">Specifies how will this value be interpreted by shaders. Float is the default, use Integer for integer values, Double for double precision floats.</param>
/// <param name="normalized">Specifies whether the data of this attribute is normalized to 0..1 range or -1..1 range for signed data types. Only relevant when dataClass is set to float.</param>
public VertexAttribDescription(int attribIndex, int bindingIndex, int size, int relativeOffset, VertexAttribType type, VertexAttribClass dataClass, bool normalized)
{
if (AttribIndex >= VertexBufferFormat.MaxAttributes)
{
throw new Exception("Vertex attribute index is too high!");
}
AttribIndex = attribIndex;
BindingIndex = bindingIndex;
Size = size;
RelativeOffset = relativeOffset;
Type = type;
DataClass = dataClass;
Normalized = normalized;
}
public static uint GetSizeOfType(VertexAttribType type)
{
switch (type)
{
case VertexAttribType.Float:
return(sizeof(float));
case VertexAttribType.UnsignedInt:
return(sizeof(uint));
case VertexAttribType.UnsignedByte:
return(sizeof(byte));
default:
return(0);
}
}
// Integers are being bound
/// <summary>
///
/// </summary>
/// <param name="bindingindex">Binding index to map</param>
/// <param name="attribindex">Attribute to use in GLSL to access this data</param>
/// <param name="components">Number of components per</param>
/// <param name="vat">Type and size of component (Byte,Int,Float etc)</param>
/// <param name="reloffset">The offset, measured in basic machine units of the first element relative to the start of the vertex buffer binding this attribute fetches from.</param>
/// <param name="divisor">For instancing, set to >0 for instance dividing of the data</param>
public void AttributeI(int bindingindex, int attribindex, int components, VertexAttribType vat, int reloffset = 0, int divisor = -1)
{
GL.VertexArrayAttribIFormat(
Id,
attribindex, // attribute index
components, // no of attribs
vat, // type
reloffset); // relative offset, first item
if (divisor >= 0) // normally use binding divisor..
{
GL.VertexAttribDivisor(attribindex, divisor); // set up attribute divisor - doing this after doing the binding divisor screws things up
}
GL.VertexArrayAttribBinding(Id, attribindex, bindingindex); // bind atrib to binding
GL.EnableVertexArrayAttrib(Id, attribindex); // enable attrib
GLOFC.GLStatics.Check();
// System.Diagnostics.Debug.WriteLine("ATTRI " + attribindex + " to " + bindingindex + " Components " + components + " +" + reloffset + " divisor " + divisor);
}
public void SetVertexAttributes(VertexAttribDescriptor[] vertexAttribs)
{
int attribIndex = 0;
foreach (VertexAttribDescriptor attrib in vertexAttribs)
{
FormatInfo fmtInfo = FormatTable.GetFormatInfo(attrib.Format);
GL.EnableVertexAttribArray(attribIndex);
int offset = attrib.Offset;
int size = fmtInfo.Components;
bool isFloat = fmtInfo.PixelType == PixelType.Float ||
fmtInfo.PixelType == PixelType.HalfFloat;
if (isFloat || fmtInfo.Normalized || fmtInfo.Scaled)
{
VertexAttribType type = (VertexAttribType)fmtInfo.PixelType;
GL.VertexAttribFormat(attribIndex, size, type, fmtInfo.Normalized, offset);
}
else
{
VertexAttribIntegerType type = (VertexAttribIntegerType)fmtInfo.PixelType;
GL.VertexAttribIFormat(attribIndex, size, type, offset);
}
GL.VertexAttribBinding(attribIndex, attrib.BufferIndex);
attribIndex++;
}
for (; attribIndex < 16; attribIndex++)
{
GL.DisableVertexAttribArray(attribIndex);
}
_vertexAttribs = vertexAttribs;
}
public void SetPointer(string name, VertexAttribType type)
{
//int uniformLoc = GL.GetUniformLocation(ShaderHandle, name); // can only get pointer right after Linking
switch (type)
{
case VertexAttribType.Position:
if (uniforms.a_position != -1)
{
GL.EnableVertexAttribArray(uniforms.a_position);
GL.VertexAttribPointer(uniforms.a_position, 3, VertexAttribPointerType.Float, false, Vertex.Stride, (IntPtr)0);
}
break;
case VertexAttribType.TextureCoord:
if (uniforms.a_texcoord != -1)
{
GL.EnableVertexAttribArray(uniforms.a_texcoord);
GL.VertexAttribPointer(uniforms.a_texcoord, 2, VertexAttribPointerType.Float, false, Vertex.Stride, (IntPtr)(Vector3.SizeInBytes + Vector3.SizeInBytes + Vector4.SizeInBytes));
}
break;
case VertexAttribType.Normal:
if (uniforms.a_normal != -1)
{
GL.EnableVertexAttribArray(uniforms.a_normal);
GL.VertexAttribPointer(uniforms.a_normal, 3, VertexAttribPointerType.Float, false, Vertex.Stride, (IntPtr)(Vector3.SizeInBytes));
}
break;
case VertexAttribType.Color:
if (uniforms.a_color != -1)
{
GL.EnableVertexAttribArray(uniforms.a_color);
GL.VertexAttribPointer(uniforms.a_color, 4, VertexAttribPointerType.Float, false, Vertex.Stride, (IntPtr)(Vector3.SizeInBytes + Vector3.SizeInBytes));
}
break;
}
}
public static uint GetByteLength(this VertexAttribType type)
{
uint result = 0;
switch (type)
{
case VertexAttribType.Byte: result = sizeof(byte); break;
case VertexAttribType.UnsignedByte: result = sizeof(byte); break;
case VertexAttribType.Short: result = sizeof(short); break;
case VertexAttribType.UnsignedShort: result = sizeof(ushort); break;
case VertexAttribType.Int: result = sizeof(int); break;
case VertexAttribType.UnsignedInt: result = sizeof(uint); break;
case VertexAttribType.HalfFloat: result = sizeof(float) / 2; break;
case VertexAttribType.Float: result = sizeof(float); break;
case VertexAttribType.Double: result = sizeof(double); break;
case VertexAttribType.Fixed: result = sizeof(int); break;
case VertexAttribType.Int2101010Rev: result = sizeof(int); break;
case VertexAttribType.UnsignedInt2101010Rev: result = sizeof(uint); break;
case VertexAttribType.UnsignedInt10f11f11fRev: result = sizeof(uint); break;
default:
throw new NotDealWithNewEnumItemException(typeof(VertexAttribType));
}
return(result);
}
// floats are being bound
/// <summary>
/// Set up a mapping beterrn the binding index, attribindex and indicate components, type, offset and divisor
/// </summary>
/// <param name="bindingindex">Binding index to map</param>
/// <param name="attribindex">Attribute to use in GLSL to access this data</param>
/// <param name="components">Number of components per</param>
/// <param name="vat">Type and size of component (Byte,Int,Float etc)</param>
/// <param name="reloffset">The offset, measured in basic machine units of the first element relative to the start of the vertex buffer binding this attribute fetches from.</param>
/// <param name="divisor">For instancing, set to >0 for instance dividing of the data</param>
public void Attribute(int bindingindex, int attribindex, int components, VertexAttribType vat, int reloffset = 0, int divisor = -1)
{
GL.VertexArrayAttribFormat(
Id,
attribindex, // attribute index
components, // no of components per attribute, 1-4
vat, // type
false, // does not need to be normalized as it is already, floats ignore this flag anyway
reloffset); // relative offset, first item
// ORDER Important, .. found that out
if (divisor >= 0) // normally use binding divisor..
{
GL.VertexAttribDivisor(attribindex, divisor);
}
GL.VertexArrayAttribBinding(Id, attribindex, bindingindex); // bind atrib to binding - do this after attrib format
GL.EnableVertexArrayAttrib(Id, attribindex);
GLOFC.GLStatics.Check();
// System.Diagnostics.Debug.WriteLine("ATTR " + attribindex + " to " + bindingindex + " Components " + components + " +" + reloffset + " divisor " + divisor);
}
public int GetDataIndex(uint indexID)
{
int result = -1;
if (this.vbo == null)
{
return(result);
}
int byteLength = this.vbo.Data.Length;
// we know that all data types are in VertexAttribType.
VertexAttribType type = (VertexAttribType)this.dataType;
if (!Enum.IsDefined(typeof(VertexAttribType), type))
{
return(result);
}
uint typeLength = type.GetByteLength(); // byte length of specified type.(float, int, uint, ..)
uint typeCount = (uint)(this.dataSize == GL.GL_BGRA ? 4 : this.dataSize); // how many elements of specified type in one vertex? (1, 2, 3 or 4)
uint vertexLength = typeLength * typeCount + stride; // byte length of a single vertex.
result = (int)(vertexLength * indexID + this.startPos);
return(result);
}
public static void SetAttributePointer <T>(this VertexArrayBinding @this, T attribute, int size, VertexAttribType attribType, bool normalized, int stride, int offset)
where T : IAttribute => @this.SetAttributePointer(attribute.Index, size, attribType, normalized, stride, offset);
public abstract void VertexAttribFormat([Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] int size, [Flow(FlowDirection.In)] VertexAttribType type, [Flow(FlowDirection.In)] bool normalized, [Flow(FlowDirection.In)] uint stride);
public static void VertexAttribIPointer(uint indx, int size, VertexAttribType type, int stride, IntPtr ptr)
{
CheckCurrent();
_bindings.glVertexAttribIPointer(indx, size, (int)type, stride, ptr);
CheckError();
}
public partial void VertexAttribFormat([Flow(FlowDirection.In)] uint attribindex, [Flow(FlowDirection.In)] int size, [Flow(FlowDirection.In)] VertexAttribType type, [Flow(FlowDirection.In)] bool normalized, [Flow(FlowDirection.In)] uint relativeoffset);
void SetUpAttribute(VertexArrayObject vao, ShaderProgram program, string name, int size, VertexAttribType type, bool normalized, uint relativeOffset, uint bindingIndex)
{
if (program.TryGetAttributeLocation(name, out var location))
{
vao.AttributeFormat(location, size, type, normalized, relativeOffset);
vao.AttributeBinding(location, bindingIndex);
vao.EnableAttribute(location);
}
else
{
Console.Write($" Missing attribute in shader: {name}...");
}
}
private unsafe PassBuffer[] VertexShaderStage(int count, DrawElementsType type, IntPtr indices, VertexArrayObject vao, ShaderProgram program, GLBuffer indexBuffer)
{
PassBuffer[] passBuffers = null;
VertexShader vs = program.VertexShader; if (vs == null)
{
return(passBuffers);
}
// init pass-buffers to record output from vertex shader.
FieldInfo[] outFieldInfos = (from item in vs.outVariableDict select item.Value.fieldInfo).ToArray();
uint vertexCount = GetVertexCount(vao, indexBuffer, type);
//int vertexSize = GetVertexSize(outFieldInfos);
passBuffers = new PassBuffer[1 + outFieldInfos.Length];
void *[] pointers = new void *[1 + outFieldInfos.Length];
{
// the first pass-buffer stores gl_Position.
var passBuffer = new PassBuffer(PassType.Vec4, (int)vertexCount);
pointers[0] = (void *)passBuffer.Mapbuffer();
passBuffers[0] = passBuffer;
}
for (int i = 1; i < passBuffers.Length; i++)
{
var outField = outFieldInfos[i - 1];
PassType passType = outField.FieldType.GetPassType();
var passBuffer = new PassBuffer(passType, (int)vertexCount);
pointers[i] = (void *)passBuffer.Mapbuffer();
passBuffers[i] = passBuffer;
}
// execute vertex shader for each vertex.
byte[] indexData = indexBuffer.Data;
int indexLength = indexData.Length / ByteLength(type);
GCHandle pin = GCHandle.Alloc(indexData, GCHandleType.Pinned);
IntPtr pointer = pin.AddrOfPinnedObject();
var gl_VertexIDList = new List <uint>();
for (int indexID = indices.ToInt32() / ByteLength(type), c = 0; c < count && indexID < indexLength; indexID++, c++)
{
uint gl_VertexID = GetVertexID(pointer, type, indexID);
if (gl_VertexIDList.Contains(gl_VertexID))
{
continue;
}
else
{
gl_VertexIDList.Add(gl_VertexID);
}
var instance = vs.CreateCodeInstance() as VertexCodeBase; // an executable vertex shader.
instance.gl_VertexID = (int)gl_VertexID; // setup gl_VertexID.
// setup "in SomeType varName;" vertex attributes.
Dictionary <uint, VertexAttribDesc> locVertexAttribDict = vao.LocVertexAttribDict;
foreach (InVariable inVar in vs.inVariableDict.Values) // Dictionary<string, InVariable>.Values
{
VertexAttribDesc desc = null;
if (locVertexAttribDict.TryGetValue(inVar.location, out desc))
{
byte[] dataStore = desc.vbo.Data;
int byteIndex = desc.GetDataIndex(gl_VertexID);
VertexAttribType vertexAttribType = (VertexAttribType)desc.dataType;
object value = dataStore.ToStruct(inVar.fieldInfo.FieldType, byteIndex);
inVar.fieldInfo.SetValue(instance, value);
}
}
// setup "uniform SomeType varName;" in vertex shader.
Dictionary <string, UniformValue> nameUniformDict = program.nameUniformDict;
foreach (UniformVariable uniformVar in vs.UniformVariableDict.Values)
{
string name = uniformVar.fieldInfo.Name;
UniformValue obj = null;
if (nameUniformDict.TryGetValue(name, out obj))
{
if (obj.value != null)
{
uniformVar.fieldInfo.SetValue(instance, obj.value);
}
}
}
instance.main(); // execute vertex shader code.
// copy data to pass-buffer.
{
PassBuffer passBuffer = passBuffers[0];
var array = (vec4 *)pointers[0];
array[gl_VertexID] = instance.gl_Position;
}
for (int i = 1; i < passBuffers.Length; i++)
{
var outField = outFieldInfos[i - 1];
var obj = outField.GetValue(instance);
switch (outField.FieldType.GetPassType())
{
case PassType.Float: { var array = (float *)pointers[i]; array[gl_VertexID] = (float)obj; } break;
case PassType.Vec2: { var array = (vec2 *)pointers[i]; array[gl_VertexID] = (vec2)obj; } break;
case PassType.Vec3: { var array = (vec3 *)pointers[i]; array[gl_VertexID] = (vec3)obj; } break;
case PassType.Vec4: { var array = (vec4 *)pointers[i]; array[gl_VertexID] = (vec4)obj; } break;
case PassType.Mat2: { var array = (mat2 *)pointers[i]; array[gl_VertexID] = (mat2)obj; } break;
case PassType.Mat3: { var array = (mat3 *)pointers[i]; array[gl_VertexID] = (mat3)obj; } break;
case PassType.Mat4: { var array = (mat4 *)pointers[i]; array[gl_VertexID] = (mat4)obj; } break;
default:
throw new NotImplementedException();
}
// a general way to do this:
//var obj = outField.GetValue(instance);
//byte[] bytes = obj.ToBytes();
//PassBuffer passBuffer = passBuffers[i];
//var array = (byte*)passBuffer.AddrOfPinnedObject();
//for (int t = 0; t < bytes.Length; t++)
//{
// array[gl_VertexID * vertexSize + t] = bytes[t];
//}
}
}
pin.Free();
for (int i = 0; i < passBuffers.Length; i++)
{
passBuffers[i].Unmapbuffer();
}
return(passBuffers);
}
public void ConvertShaderDataTypeToOpenGL(ShaderDataType type, VertexAttribType openGlType)
{
Assert.Equal(openGlType,
OpenGLVertexArray.ToOpenGLDataType(type));
}
private void VertexAttribPointer(uint index, int size, VertexAttribType type, bool normalized, int stride, IntPtr pointer)
{
// TODO: GL_INVALID_VALUE is generated if index is greater than or equal to GL_MAX_VERTEX_ATTRIBS.
if (size != 1 && size != 2 && size != 3 && size != 4 && size != GL.GL_BGRA)
{
SetLastError(ErrorCode.InvalidValue); return;
}
if (!Enum.IsDefined(typeof(VertexAttribType), type))
{
SetLastError(ErrorCode.InvalidEnum); return;
}
if (stride < 0)
{
SetLastError(ErrorCode.InvalidValue); return;
}
if (size == GL.GL_BGRA)
{
if (type != VertexAttribType.UnsignedByte &&
type != VertexAttribType.Int2101010Rev &&
type != VertexAttribType.UnsignedInt2101010Rev)
{
SetLastError(ErrorCode.InvalidOperation); return;
}
if (normalized == false)
{
SetLastError(ErrorCode.InvalidOperation); return;
}
}
if (type == VertexAttribType.Int2101010Rev || type == VertexAttribType.UnsignedInt2101010Rev)
{
if (size != 4 && size != GL.GL_BGRA)
{
SetLastError(ErrorCode.InvalidOperation); return;
}
}
if (type == VertexAttribType.UnsignedInt10f11f11fRev)
{
if (size != 3)
{
SetLastError(ErrorCode.InvalidOperation); return;
}
}
VertexArrayObject vao = this.currentVertexArrayObject;
if (vao == null)
{
SetLastError(ErrorCode.InvalidOperation); return;
}
GLBuffer buffer = this.currentBufferDict[BindBufferTarget.ArrayBuffer];
// GL_INVALID_OPERATION is generated if zero is bound to the GL_ARRAY_BUFFER buffer object binding point and the pointer argument is not NULL.
// TODO: why only when "pointer argument is not NULL"?
if (buffer == null)
{
SetLastError(ErrorCode.InvalidOperation); return;
}
VertexAttribDesc desc = null;
if (!vao.LocVertexAttribDict.TryGetValue(index, out desc))
{
desc = new VertexAttribDesc();
vao.LocVertexAttribDict.Add(index, desc);
}
desc.inLocation = index;
desc.vbo = buffer;
desc.dataSize = size;
desc.dataType = (uint)type;
desc.normalize = normalized;
desc.startPos = (uint)pointer.ToInt32();
desc.stride = (uint)stride;
}
internal static int SizeOf(this VertexAttribType type) =>
type switch
{
public partial void VertexAttribFormat([Flow(FlowDirection.In)] uint index, [Flow(FlowDirection.In)] int size, [Flow(FlowDirection.In)] VertexAttribType type, [Flow(FlowDirection.In)] Boolean normalized, [Flow(FlowDirection.In)] uint stride);
