public OpenGLIndexBuffer(object indices, uint count)
{
this.count = count;
bufferID = Gl.CreateBuffer();
Gl.BindBuffer(BufferTarget.ElementArrayBuffer, bufferID);
Gl.BufferData(BufferTarget.ElementArrayBuffer, count * sizeof(uint), indices, BufferUsage.StaticDraw);
}
protected void UpdateBuffer()
{
if (firstRender)
{
firstRender = false;
VAO = Gl.CreateVertexArray();
Gl.BindVertexArray(VAO);
Gl.BindBuffer(BufferTarget.ArrayBuffer, Texture.baseVBO);
Gl.VertexAttribPointer(0, 2, VertexAttribType.Float, false, 4 * sizeof(float), (IntPtr)0);
Gl.VertexAttribPointer(1, 2, VertexAttribType.Float, false, 4 * sizeof(float), (IntPtr)(2 * sizeof(float)));
Gl.EnableVertexAttribArray(0);
Gl.EnableVertexAttribArray(1);
ibo = Gl.CreateBuffer();
Gl.BindBuffer(BufferTarget.ArrayBuffer, ibo);
Gl.VertexAttribPointer(2, 2, VertexAttribType.Float, false, 4 * sizeof(float), (IntPtr)0);
Gl.VertexAttribPointer(3, 2, VertexAttribType.Float, false, 4 * sizeof(float), (IntPtr)(2 * sizeof(float)));
Gl.EnableVertexAttribArray(2);
Gl.EnableVertexAttribArray(3);
Gl.VertexAttribDivisor(2, 1);
Gl.VertexAttribDivisor(3, 1);
}
Gl.BindBuffer(BufferTarget.ArrayBuffer, ibo);
Gl.BufferData(BufferTarget.ArrayBuffer, (uint)bufferData.Length * sizeof(float), bufferData, BufferUsage.DynamicDraw);
updateBuffer = false;
}
public override void SetBuffers()
{
vAO = Gl.GenVertexArray();
vBO = Gl.GenBuffer();
eBO = Gl.GenBuffer();
Gl.BindVertexArray(VAO);
Gl.BindBuffer(BufferTarget.ArrayBuffer, VBO);
Gl.BufferData(BufferTarget.ArrayBuffer, ((uint)Vertices.Length) * sizeof(float), Vertices, BufferUsage.StaticDraw);
Gl.BindBuffer(BufferTarget.ElementArrayBuffer, EBO);
Gl.BufferData(BufferTarget.ElementArrayBuffer, ((uint)Indices.Length) * sizeof(uint), Indices, BufferUsage.StaticDraw);
Gl.VertexAttribPointer(0, 3, VertexAttribType.Float, false, (int)VertexStride * sizeof(float), IntPtr.Zero);
Gl.EnableVertexAttribArray(0);
Gl.VertexAttribPointer(1, 3, VertexAttribType.Float, false, (int)VertexStride * sizeof(float), IntPtr.Zero + 3 * sizeof(float));
Gl.EnableVertexAttribArray(1);
Gl.VertexAttribPointer(2, 3, VertexAttribType.Float, false, (int)VertexStride * sizeof(float), IntPtr.Zero + 6 * sizeof(float));
Gl.EnableVertexAttribArray(2);
Gl.VertexAttribPointer(3, 2, VertexAttribType.Float, false, (int)VertexStride * sizeof(float), IntPtr.Zero + 9 * sizeof(float));
Gl.EnableVertexAttribArray(3);
Gl.BindBuffer(BufferTarget.ArrayBuffer, 0);
Gl.BindVertexArray(0);
}
public static Geometry GenerateGeometry(GeometryData geometryData, float[] vertices, float[] normals, float[] texCoords, PrimitiveType primitiveType = PrimitiveType.Triangles)
{
if (vertices.Length % 3 != 0 || normals.Length % 3 != 0 || texCoords.Length % 2 != 0)
{
throw new ArgumentException($"Invalid count of input variables");
}
var geometry = new Geometry(geometryData, primitiveType);
geometry.m_VerticesCount = vertices.Length / 3;
geometry.VAO = Gl.GenVertexArray();
Gl.BindVertexArray(geometry.VAO);
geometry.m_VertexBuffer = Gl.GenBuffer();
Gl.BindBuffer(BufferTarget.ArrayBuffer, geometry.m_VertexBuffer);
Gl.BufferData(BufferTarget.ArrayBuffer, (uint)(sizeof(float) * vertices.Length), vertices, BufferUsage.StaticDraw);
Gl.VertexAttribPointer(POSITION_LOCATION, 3, VertexAttribType.Float, false, 0, IntPtr.Zero);
Gl.EnableVertexAttribArray(POSITION_LOCATION);
geometry.m_NormalBuffer = Gl.GenBuffer();
Gl.BindBuffer(BufferTarget.ArrayBuffer, geometry.m_NormalBuffer);
Gl.BufferData(BufferTarget.ArrayBuffer, (uint)(sizeof(float) * normals.Length), normals, BufferUsage.StaticDraw);
Gl.VertexAttribPointer(NORMAL_LOCATION, 3, VertexAttribType.Float, false, 0, IntPtr.Zero);
Gl.EnableVertexAttribArray(NORMAL_LOCATION);
geometry.m_TexCoordBuffer = Gl.GenBuffer();
Gl.BindBuffer(BufferTarget.ArrayBuffer, geometry.m_TexCoordBuffer);
Gl.BufferData(BufferTarget.ArrayBuffer, (uint)(sizeof(float) * texCoords.Length), texCoords, BufferUsage.StaticDraw);
Gl.VertexAttribPointer(TEX_COORD_LOCATION, 2, VertexAttribType.Float, false, 0, IntPtr.Zero);
Gl.EnableVertexAttribArray(TEX_COORD_LOCATION);
Gl.BindBuffer(BufferTarget.ArrayBuffer, 0);
return(geometry);
}
private static UInt32 CreateBuffer(uint size, float[] data)
{
UInt32 buffer = 0;
try {
buffer = Gl.GenBuffer();
Gl.BindBuffer(BufferTargetARB.ArrayBuffer, buffer);
if (data != null)
{
GCHandle dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
try {
Gl.BufferData(BufferTargetARB.ArrayBuffer, size, dataHandle.AddrOfPinnedObject(), BufferUsageARB.StaticDraw);
} finally {
dataHandle.Free();
}
}
else
{
Gl.BufferData(BufferTargetARB.ArrayBuffer, size, IntPtr.Zero, BufferUsageARB.StaticDraw);
}
return(buffer);
} catch {
if (buffer != 0)
{
Gl.DeleteBuffers(buffer);
}
throw;
}
}
public void update(Chunk chunk)
{
if (vaoID_ == 0)
{
vaoID_ = Gl.GenVertexArray();
Gl.GenBuffers(vboID_);
}
Gl.ShadeModel(ShadingModel.Smooth);
Gl.BindVertexArray(vaoID_);
if (chunk.vertices.Count() > 0)
{
Gl.BindBuffer(BufferTarget.ArrayBuffer, vboID_[0]);
Gl.BufferData(BufferTarget.ArrayBuffer, (uint)chunk.vertices.Count() * sizeof(float) * 3, chunk.vertices.ToArray(), BufferUsage.DynamicDraw);
Gl.VertexAttribPointer(Shader.ATTRIB_VERTICES_POS, 3, VertexAttribType.Float, false, 0, IntPtr.Zero);
Gl.EnableVertexAttribArray(Shader.ATTRIB_VERTICES_POS);
}
if (chunk.triangles.Count() > 0)
{
Gl.BindBuffer(BufferTarget.ElementArrayBuffer, vboID_[1]);
Gl.BufferData(BufferTarget.ElementArrayBuffer, (uint)chunk.triangles.Count() * sizeof(int), chunk.triangles.ToArray(), BufferUsage.DynamicDraw);
current_fc = chunk.triangles.Count();
}
Gl.BindVertexArray(0);
Gl.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
Gl.BindBuffer(BufferTarget.ArrayBuffer, 0);
}
private void UpdateBuffer(Texture texture)
{
if (texture is null)
{
return;
}
if (firstRender)
{
firstRender = false;
vao = Gl.CreateVertexArray();
Gl.BindVertexArray(vao);
Gl.BindBuffer(BufferTarget.ArrayBuffer, texture.baseVBO);
Gl.VertexAttribPointer(0, 2, VertexAttribType.Float, false, 4 * sizeof(float), (IntPtr)0);
Gl.VertexAttribPointer(1, 2, VertexAttribType.Float, false, 4 * sizeof(float), (IntPtr)(2 * sizeof(float)));
Gl.EnableVertexAttribArray(0);
Gl.EnableVertexAttribArray(1);
ibo = Gl.CreateBuffer();
Gl.BindBuffer(BufferTarget.ArrayBuffer, ibo);
Gl.VertexAttribPointer(2, 2, VertexAttribType.Float, false, 4 * sizeof(float), (IntPtr)0);
Gl.VertexAttribPointer(3, 2, VertexAttribType.Float, false, 4 * sizeof(float), (IntPtr)(2 * sizeof(float)));
Gl.EnableVertexAttribArray(2);
Gl.EnableVertexAttribArray(3);
Gl.VertexAttribDivisor(2, 1);
Gl.VertexAttribDivisor(3, 1);
}
Gl.BindBuffer(BufferTarget.ArrayBuffer, ibo);
Gl.BufferData(BufferTarget.ArrayBuffer, (uint)tilesBuffer.Length * sizeof(float), tilesBuffer, BufferUsage.DynamicDraw);
updateBuffer = false;
}
public override void Resize(uint size)
{
this.size = size;
Gl.BindBuffer(BufferTarget.ArrayBuffer, handle[0]);
Gl.BufferData(BufferTarget.ArrayBuffer, new IntPtr(size), IntPtr.Zero, SPBufferUsageToOpenGL(usage));
}
/// <summary>
/// Reset the allocated GPU buffer for this BufferObject.
/// </summary>
/// <param name="size">
/// A <see cref="UInt32"/> that determine the size of the buffer object GPU buffer, in bytes.
/// </param>
protected void AllocateGpuBuffer(uint size, object data)
{
// Define buffer object (type, size and hints)
Gl.BufferData((int)BufferType, size, data, (int)Hint);
// Store GPU buffer size
_GpuBufferSize = size;
}
private void DrawBatch(Batch batch)
{
Gl.BindVertexArray(VAO);
Gl.BindBuffer(BufferTargetARB.ArrayBuffer, VBO);
Gl.BufferData(BufferTargetARB.ArrayBuffer, batch.VertexCount * (uint)VertexStride, batch.Vertices, BufferUsageARB.StreamDraw);
Gl.BindBuffer(BufferTargetARB.ElementArrayBuffer, EBO);
Gl.BufferData(BufferTargetARB.ElementArrayBuffer, batch.VertexCount * sizeof(int), batch.Indices, BufferUsageARB.StreamDraw);
// Vertex position
Gl.EnableVertexAttribArray(0);
Gl.VertexAttribPointer(0, 3, (int)VertexPointerType.Float, false, VertexStride, 0);
// Color
Gl.EnableVertexAttribArray(1);
Gl.VertexAttribPointer(1, 4, Gl.UNSIGNED_BYTE, true, VertexStride, Vector3.SizeInBytes);
// UV
Gl.EnableVertexAttribArray(2);
Gl.VertexAttribPointer(2, 2, (int)VertexPointerType.Float, false, VertexStride, Vector3.SizeInBytes + Color.SizeInBytes);
shader.Use();
Gl.BindTexture(batch.Texture.TextureTarget, batch.Texture.TextureID);
Gl.DrawArrays(PrimitiveType.Triangles, 0, (int)(batch.VertexCount / 3));
Gl.BindBuffer(BufferTargetARB.ArrayBuffer, 0);
Gl.BindBuffer(BufferTargetARB.ElementArrayBuffer, 0);
Gl.DisableVertexAttribArray(0);
Gl.DisableVertexAttribArray(1);
Gl.DisableVertexAttribArray(2);
Gl.BindVertexArray(0);
}
public void BufferData()
{
Gl.BindVertexArray(arrayHandle);
if (used > 0 && dirty)
{
unsafe
{
fixed(int *p = data)
{
Gl.BindBuffer(BufferTarget.ArrayBuffer, bufferHandle);
// BufferSubData if we can
if (used <= lastUsed < used)
{
Gl.BufferSubData(BufferTarget.ArrayBuffer, (IntPtr)0, (uint)(used * vertexSize), (IntPtr)p);
}
else
{
Gl.BufferData(BufferTarget.ArrayBuffer, (uint)(used * vertexSize), (IntPtr)p, BufferUsage.StaticDraw);
lastUsed = used;
}
Gl.BindBuffer(BufferTarget.ArrayBuffer, 0);
}
}
dirty = false;
// Clear the data from memory as it is now stored on the GPU
data = null;
}
Gl.BindVertexArray(0);
}
public void update(Vector4[] points)
{
if (vaoID_ == 0)
{
vaoID_ = Gl.GenVertexArray();
Gl.GenBuffers(vboID_);
}
Gl.ShadeModel(ShadingModel.Smooth);
index.Clear();
for (int c = 0; c < points.Count(); c++)
{
index.Add(c);
}
Gl.BindVertexArray(vaoID_);
if (points.Count() > 0)
{
Gl.BindBuffer(BufferTarget.ArrayBuffer, vboID_[0]);
Gl.BufferData(BufferTarget.ArrayBuffer, (uint)points.Count() * sizeof(float) * 4, points, BufferUsage.DynamicDraw);
Gl.VertexAttribPointer(Shader.ATTRIB_VERTICES_POS, 4, VertexAttribType.Float, false, 0, IntPtr.Zero);
Gl.EnableVertexAttribArray(Shader.ATTRIB_VERTICES_POS);
}
Gl.BindBuffer(BufferTarget.ElementArrayBuffer, vboID_[1]);
Gl.BufferData(BufferTarget.ElementArrayBuffer, (uint)index.Count() * sizeof(int), index.ToArray(), BufferUsage.DynamicDraw);
current_fc = index.Count();
Gl.BindVertexArray(0);
Gl.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
Gl.BindBuffer(BufferTarget.ArrayBuffer, 0);
}
// Initialize Opengl buffers
public void initialize()
{
shaderImage.it = new Shader(Shader.IMAGE_VERTEX_SHADER, Shader.IMAGE_FRAGMENT_SHADER);
texID = Gl.GetUniformLocation(shaderImage.it.getProgramId(), "texImage");
float[] g_quad_vertex_buffer_data = new float[18] {
-1.0f, -1.0f, 0.0f,
1.0f, -1.0f, 0.0f,
-1.0f, 1.0f, 0.0f,
-1.0f, 1.0f, 0.0f,
1.0f, -1.0f, 0.0f,
1.0f, 1, 0.0f
};
quad_vb = Gl.GenBuffer();
Gl.BindBuffer(BufferTarget.ArrayBuffer, quad_vb);
Gl.BufferData(BufferTarget.ArrayBuffer, (uint)(sizeof(float) * g_quad_vertex_buffer_data.Length), g_quad_vertex_buffer_data, BufferUsage.StaticDraw);
Gl.BindBuffer(BufferTarget.ArrayBuffer, 0);
Gl.Enable(EnableCap.Texture2d);
imageTex = Gl.GenTexture();
Gl.BindTexture(TextureTarget.Texture2d, imageTex);
Gl.TexParameter(TextureTarget.Texture2d, TextureParameterName.TextureWrapS, Gl.CLAMP_TO_BORDER);
Gl.TexParameter(TextureTarget.Texture2d, TextureParameterName.TextureWrapT, Gl.CLAMP_TO_BORDER);
Gl.TexParameter(TextureTarget.Texture2d, TextureParameterName.TextureWrapR, Gl.CLAMP_TO_BORDER);
Gl.TexParameter(TextureTarget.Texture2d, TextureParameterName.TextureMinFilter, Gl.LINEAR);
Gl.TexParameter(TextureTarget.Texture2d, TextureParameterName.TextureMagFilter, Gl.LINEAR);
Gl.TexImage2D(TextureTarget.Texture2d, 0, InternalFormat.Rgba, (int)resolution.width, (int)resolution.height, 0, PixelFormat.Rgba, PixelType.UnsignedByte, null);
Gl.BindTexture(TextureTarget.Texture2d, 0);
}
public void SetupMesh()
{
var vertexStructSize = 14 * sizeof(float);
vao = Gl.GenVertexArray();
Gl.BindVertexArray(vao);
vbo = Gl.GenBuffer();
ebo = Gl.GenBuffer();
var glVertices = new List <float>();
foreach (var vertex in Vertices)
{
glVertices.AddRange(new[] {
vertex.Position.x,
vertex.Position.y,
vertex.Position.z,
vertex.Normal.x,
vertex.Normal.y,
vertex.Normal.z,
vertex.Tangent.x,
vertex.Tangent.y,
vertex.Tangent.z,
vertex.BiTangent.x,
vertex.BiTangent.y,
vertex.BiTangent.z,
vertex.TexCoords.x,
vertex.TexCoords.y
});
}
Gl.BindBuffer(BufferTarget.ArrayBuffer, vbo);
Gl.BufferData(BufferTarget.ArrayBuffer, (uint)glVertices.Count * sizeof(float), glVertices.ToArray(), BufferUsage.StaticDraw);
Gl.BindBuffer(BufferTarget.ElementArrayBuffer, ebo);
Gl.BufferData(BufferTarget.ElementArrayBuffer, (uint)Indices.Length * sizeof(uint), Indices, BufferUsage.StaticDraw);
Gl.EnableVertexAttribArray(0);
Gl.VertexAttribPointer(0, 3, VertexAttribType.Float, false, vertexStructSize, (IntPtr)0);
Gl.EnableVertexAttribArray(1);
Gl.VertexAttribPointer(1, 3, VertexAttribType.Float, false, vertexStructSize, (IntPtr)(3 * sizeof(float)));
Gl.EnableVertexAttribArray(2);
Gl.VertexAttribPointer(2, 3, VertexAttribType.Float, false, vertexStructSize, (IntPtr)(6 * sizeof(float)));
Gl.EnableVertexAttribArray(3);
Gl.VertexAttribPointer(3, 3, VertexAttribType.Float, false, vertexStructSize, (IntPtr)(9 * sizeof(float)));
Gl.EnableVertexAttribArray(4);
Gl.VertexAttribPointer(4, 2, VertexAttribType.Float, false, vertexStructSize, (IntPtr)(12 * sizeof(float)));
Gl.BindVertexArray(0);
}
public void CopyData(T[] data)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
Gl.BufferData(BufferTarget.ArrayBuffer, (this.vertexSize * (uint)data.Length), data, usage);
}
public void BufferData(long size, IntPtr data, Usage usage)
{
unsafe
{
Gl.BufferData(Target, (void *)size, data.ToPointer(), (uint)usage);
GlHelper.GetError();
}
}
private void bindindicesBuffer(uint[] indices)
{
uint vboId = Gl.GenBuffer();
VBOS.Add(vboId);
Gl.BindBuffer(BufferTarget.ElementArrayBuffer, vboId);
Gl.BufferData(BufferTarget.ElementArrayBuffer, (uint)(indices.Length * sizeof(uint)), indices, BufferUsage.StaticDraw);
}
public void CopyRawData(byte[] data)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
Gl.BufferData(BufferTarget.ElementArrayBuffer, (uint)data.Length, data, usage);
}
public void TestBufferData()
{
if (!HasVersion(1, 5) && !IsGlExtensionSupported("GL_ARB_vertex_buffer_object") && !HasEsVersion(1, 0))
{
Assert.Inconclusive("OpenGL 1.5 or GL_ARB_vertex_buffer_object not supported or OpenGL ES 1.0");
}
int arrayBufferGet;
uint arrayBuffer = Gl.GenBuffer();
try {
Assert.AreNotEqual(0, arrayBuffer, "Gl.GenBuffer failure");
Assert.IsFalse(Gl.IsBuffer(arrayBuffer));
Gl.BindBuffer(BufferTarget.ArrayBuffer, arrayBuffer);
Assert.IsTrue(Gl.IsBuffer(arrayBuffer));
Gl.Get(Gl.ARRAY_BUFFER_BINDING, out arrayBufferGet);
Assert.AreEqual((int)arrayBuffer, arrayBufferGet);
Random random = new Random();
byte[] arrayBufferData = new byte[64], arrayBufferDataGet = new byte[64];
for (int i = 0; i < arrayBufferData.Length; i++)
{
arrayBufferData[i] = (Byte)random.Next(Byte.MaxValue);
}
int arrayBufferDataParam;
Gl.BufferData(BufferTarget.ArrayBuffer, (uint)arrayBufferData.Length, arrayBufferData, BufferUsage.StaticDraw);
Gl.GetBufferParameter(BufferTarget.ArrayBuffer, Gl.BUFFER_SIZE, out arrayBufferDataParam);
Assert.AreEqual(arrayBufferData.Length, arrayBufferDataParam);
Gl.GetBufferParameter(BufferTarget.ArrayBuffer, Gl.BUFFER_USAGE, out arrayBufferDataParam);
Assert.AreEqual((int)BufferUsage.StaticDraw, arrayBufferDataParam);
if (HasVersion(1, 5) || IsGlExtensionSupported("GL_ARB_vertex_buffer_object"))
{
Gl.GetBufferSubData(BufferTarget.ArrayBuffer, IntPtr.Zero, (uint)arrayBufferData.Length, arrayBufferDataGet);
for (int i = 0; i < arrayBufferDataGet.Length; i++)
{
Assert.AreEqual(arrayBufferData[i], arrayBufferDataGet[i]);
}
}
Gl.BindBuffer(BufferTarget.ArrayBuffer, 0);
Gl.Get(Gl.ARRAY_BUFFER_BINDING, out arrayBufferGet);
Assert.AreEqual(0, arrayBufferGet);
} finally {
if (arrayBuffer != 0)
{
Gl.DeleteBuffers(new UInt32[] { arrayBuffer });
Assert.IsFalse(Gl.IsBuffer(arrayBuffer));
}
}
}
public void initialize(uint maxNumVertices, uint[] texChannels, ushort[] indices, uint maxNumRenderCalls)
{
{
uint positionsDataSize = (uint)(maxNumVertices * Marshal.SizeOf(typeof(Neutrino._math.vec3)));
positionsId_ = Gl.GenBuffer();
positions_ = new Neutrino._math.vec3[maxNumVertices];
Gl.BindBuffer(BufferTarget.ArrayBuffer, positionsId_);
Gl.BufferData(BufferTarget.ArrayBuffer, (IntPtr)positionsDataSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);
}
{
uint colorsDataSize = (uint)(maxNumVertices * Marshal.SizeOf(typeof(uint)));
colorsId_ = Gl.GenBuffer();
colors_ = new uint[maxNumVertices];
Gl.BindBuffer(BufferTarget.ArrayBuffer, colorsId_);
Gl.BufferData(BufferTarget.ArrayBuffer, (IntPtr)colorsDataSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);
}
texChannels_ = new TexChannel[texChannels.Length];
for (uint texIndex = 0; texIndex < texChannels.Length; ++texIndex)
{
TexChannel texChannel = new TexChannel();
uint texDataSize = (uint)(maxNumVertices * texChannels[texIndex] * Marshal.SizeOf(typeof(float)));
texChannel.dimensions_ = texChannels[texIndex];
texChannel.id_ = Gl.GenBuffer();
texChannel.data_ = new float[maxNumVertices * texChannels[texIndex]];
Gl.BindBuffer(BufferTarget.ArrayBuffer, texChannel.id_);
Gl.BufferData(BufferTarget.ArrayBuffer, (IntPtr)texDataSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);
texChannels_[texIndex] = texChannel;
}
{
uint indicesDataSize = (uint)(indices.Length * Marshal.SizeOf(typeof(ushort)));
indicesId_ = Gl.GenBuffer();
indicesData_ = Marshal.AllocHGlobal((int)indicesDataSize);
{
IntPtr ptr = indicesData_;
for (uint i = 0; i < indices.Length; ptr = IntPtr.Add(ptr, Marshal.SizeOf(typeof(ushort))), ++i)
{
Marshal.WriteInt16(ptr, (short)indices[i]);
}
}
Gl.BindBuffer(BufferTarget.ElementArrayBuffer, indicesId_);
Gl.BufferData(BufferTarget.ElementArrayBuffer, (IntPtr)indicesDataSize, indicesData_, BufferUsageHint.StaticDraw);
}
numVertices_ = 0;
renderCalls_ = new Neutrino.RenderCall[maxNumRenderCalls];
numRenderCalls_ = 0;
}
static void Main(string[] args)
{
Glfw.Init();
Glfw.WindowHint(Hint.ContextVersionMajor, 4);
Glfw.WindowHint(Hint.ContextVersionMinor, 6);
Glfw.WindowHint(Hint.OpenglProfile, Profile.Compatibility);
Window window = Glfw.CreateWindow(1080, 720, "Yeet", Monitor.None, Window.None);
// `Gl.Initialize()` has to be don before `Glfw.MakeContextCurrent(window)`
// [How Do I Initialize OpenGL.NET with GLFW.Net?](https://stackoverflow.com/questions/61318104/how-do-i-initialize-opengl-net-with-glfw-net/61319044?noredirect=1#comment108476826_61319044)
Gl.Initialize();
Glfw.MakeContextCurrent(window);
var v = Gl.GetString(StringName.Version);
Console.WriteLine(v);
uint vao = Gl.CreateVertexArray();
Gl.BindVertexArray(vao);
uint vbo = Gl.GenBuffer();
Gl.BindBuffer(BufferTarget.ArrayBuffer, vbo);
var vertices = new float[] { -0.5f, -0.5f, 0.5f, -0.5f, 0.0f, 0.5f };
Gl.BufferData(BufferTarget.ArrayBuffer, (uint)(4 * vertices.Length), null, BufferUsage.StaticDraw);
IntPtr unmanagedPointer = Marshal.AllocHGlobal(4 * vertices.Length);
Marshal.Copy(vertices, 0, unmanagedPointer, vertices.Length);
Gl.BufferSubData(BufferTarget.ArrayBuffer, new IntPtr(0), (uint)(4 * vertices.Length), unmanagedPointer);
Marshal.FreeHGlobal(unmanagedPointer);
//Gl.BufferSubData(BufferTarget.ArrayBuffer, new IntPtr(0), (uint)(4 * vertices.Length), vertices);
Gl.VertexAttribPointer(0, 2, VertexAttribType.Float, false, 0, null);
while (!Glfw.WindowShouldClose(window))
{
Glfw.PollEvents();
Gl.ClearColor(0.0f, 1.0f, 1.0f, 1.0f);
Gl.Clear(ClearBufferMask.ColorBufferBit);
Gl.BindVertexArray(vao);
Gl.EnableVertexAttribArray(0);
Gl.DrawArrays(PrimitiveType.Triangles, 0, 3);
Gl.DisableVertexAttribArray(0);
Gl.BindVertexArray(0);
Glfw.SwapBuffers(window);
}
Glfw.DestroyWindow(window);
Glfw.Terminate();
}
void bindIndicesBuffer(int[] indices)
{
uint vboID = Gl.GenBuffer();
_vbos.Add(vboID);
Gl.BindBuffer(BufferTarget.ElementArrayBuffer, vboID);
Gl.BufferData(BufferTarget.ElementArrayBuffer, (uint)(indices.Length * sizeof(int)), indices, BufferUsage.StaticDraw);
}
public void BufferData(int newLength)
{
currentLength = newLength;
// Bind, buffer and unbind
Gl.BindBuffer(BufferTarget.ArrayBuffer, bufferHandle);
Gl.BufferData(BufferTarget.ArrayBuffer, (uint)(currentLength * vertexSize), IntPtr.Zero, BufferUsage.DynamicDraw);
Gl.BindBuffer(BufferTarget.ArrayBuffer, 0);
}
/// <summary>
/// Initializes a new instance of the <see cref="OpenGLVertexBuffer"/> class.
/// </summary>
/// <param name="vertices">The vertices.</param>
/// <exception cref="ArgumentNullException"></exception>
public OpenGLVertexBuffer(float[] vertices)
{
_vertices = vertices ?? throw new ArgumentNullException();
var size = (uint)(vertices.Length * sizeof(float));
_id = Gl.GenBuffer();
Gl.BindBuffer(BufferTarget.ArrayBuffer, _id);
Gl.BufferData(BufferTarget.ArrayBuffer, size, vertices, BufferUsage.StaticDraw);
}
/// <summary>
/// Initializes a new instance of the <see cref="OpenGLIndexBuffer"/> class.
/// </summary>
/// <param name="indices">The indices.</param>
/// <exception cref="ArgumentNullException"></exception>
public OpenGLIndexBuffer(int[] indices)
{
_indices = indices ?? throw new ArgumentNullException();
var size = (uint)(indices.Length * sizeof(int));
_id = Gl.GenBuffer();
Gl.BindBuffer(BufferTarget.ElementArrayBuffer, _id);
Gl.BufferData(BufferTarget.ElementArrayBuffer, size, indices, BufferUsage.StaticDraw);
}
/// <summary>
/// Update the reference Buffer, using this technique.
/// </summary>
/// <param name="ctx">
/// A <see cref="GraphicsContext"/> used for allocating resources.
/// </param>
public override void Create(GraphicsContext ctx)
{
if (ctx.Extensions.DirectStateAccess_ARB || ctx.Version.IsCompatible(Gl.Version_450))
{
if (!ctx.Extensions.BufferStorage_ARB || !Buffer.Immutable)
{
// Emulates glBufferStorage error checking (only for size)
if (Buffer.Immutable && Buffer.Size != 0)
{
throw new GlException(ErrorCode.InvalidOperation);
}
Gl.NamedBufferData(Buffer.ObjectName, _Size, _Array, Buffer.Hint);
}
else
{
if (Buffer.Immutable)
{
Gl.NamedBufferStorage(Buffer.ObjectName, _Size, _Array, Buffer.UsageMask);
}
else
{
Gl.NamedBufferData(Buffer.ObjectName, _Size, _Array, Buffer.Hint);
}
}
}
else
{
if (!ctx.Extensions.BufferStorage_ARB || !Buffer.Immutable)
{
// Emulates glBufferStorage error checking (only for size)
if (Buffer.Immutable && Buffer.Size != 0)
{
throw new GlException(ErrorCode.InvalidOperation);
}
Gl.BufferData(Buffer.Target, _Size, _Array, Buffer.Hint);
}
else
{
if (Buffer.Immutable)
{
Gl.BufferStorage(Buffer.Target, _Size, _Array, Buffer.UsageMask);
}
else
{
Gl.BufferData(Buffer.Target, _Size, _Array, Buffer.Hint);
}
}
}
// Explictly check for errors
Gl.CheckErrors();
Buffer.Size = _Size;
}
private void AddDataToBuffer(uint index, double[] data)
{
uint vboId = Gl.GenBuffer();
vbos.Add(vboId);
Gl.BindBuffer(BufferTarget.ArrayBuffer, vboId);
Gl.BufferData(BufferTarget.ArrayBuffer, (uint)(8 * data.Length), data, BufferUsage.StaticDraw);
Gl.VertexAttribPointer(index, 2, VertexAttribType.Double, false, 0, IntPtr.Zero);
Gl.BindBuffer(BufferTarget.ArrayBuffer, 0);
}
private void StoreDataInAttributeList(uint attribute_number, int coordinateSize, float[] data)
{
uint vboID = Gl.GenBuffer();
VBOS.Add(vboID);
Gl.BindBuffer(BufferTarget.ArrayBuffer, vboID);
Gl.BufferData(BufferTarget.ArrayBuffer, (uint)(data.Length * sizeof(float)), data, BufferUsage.StaticDraw);
Gl.VertexAttribPointer(attribute_number, coordinateSize, VertexAttribType.Float, false, 0, IntPtr.Zero);
Gl.BindBuffer(BufferTarget.ArrayBuffer, 0);
}
public GpuSpace(DiscreteBounds bounds)
{
_buffer = Gl.GenBuffer();
_texture = Gl.GenTexture();
Bounds = bounds;
Gl.BindBuffer(BufferTarget.TextureBuffer, _buffer);
Gl.BufferData(BufferTarget.TextureBuffer, (uint)Marshal.SizeOf <VoxelFace>() * (uint)bounds.Length, null, BufferUsage.DynamicDraw);
}
private uint CreateAndInitializeVertexAttribArray <T>(AttributeType location, T[] array)
{
uint buffer = Gl.GenBuffer();
Gl.EnableVertexAttribArray((uint)location);
Gl.BindBuffer(BufferTarget.ArrayBuffer, buffer);
Gl.BufferData(BufferTarget.ArrayBuffer, (uint)(Marshal.SizeOf(typeof(T)) * array.Length), array, BufferUsage.StaticDraw);
Gl.VertexAttribPointer((uint)location, Marshal.SizeOf(typeof(T)) / Marshal.SizeOf(typeof(float)), VertexAttribType.Float, false, 0, IntPtr.Zero);
return(buffer);
}
