620 lines
16 KiB
C
620 lines
16 KiB
C
/* Freetype GL - A C OpenGL Freetype engine
|
|
*
|
|
* Distributed under the OSI-approved BSD 2-Clause License. See accompanying
|
|
* file `LICENSE` for more details.
|
|
*/
|
|
#pragma GCC diagnostic ignored "-Wformat"
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include "vec234.h"
|
|
#include "platform.h"
|
|
#include "vertex-buffer.h"
|
|
|
|
/**
|
|
* Buffer status
|
|
*/
|
|
#define CLEAN (0)
|
|
#define DIRTY (1)
|
|
#define FROZEN (2)
|
|
|
|
// ----------------------------------------------------------------------------
|
|
vertex_buffer_t *vertex_buffer_new(const char *format)
|
|
{
|
|
size_t i, index = 0, stride = 0;
|
|
const char *start = 0, *end = 0;
|
|
GLchar *pointer = 0;
|
|
|
|
vertex_buffer_t *self = (vertex_buffer_t *) malloc(sizeof(vertex_buffer_t));
|
|
if (!self)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
self->format = strdup(format);
|
|
|
|
for (i = 0; i < MAX_VERTEX_ATTRIBUTE; ++i)
|
|
{
|
|
self->attributes[i] = 0;
|
|
}
|
|
|
|
start = format;
|
|
do
|
|
{
|
|
char *desc = 0;
|
|
vertex_attribute_t *attribute;
|
|
GLuint attribute_size = 0;
|
|
end = (char *) (strchr(start + 1, ','));
|
|
|
|
if (end == NULL)
|
|
{
|
|
desc = strdup(start);
|
|
}
|
|
else
|
|
{
|
|
desc = strndup(start, end - start);
|
|
}
|
|
attribute = vertex_attribute_parse(desc);
|
|
start = end + 1;
|
|
free(desc);
|
|
attribute->pointer = pointer;
|
|
|
|
switch (attribute->type)
|
|
{
|
|
case GL_BOOL:
|
|
attribute_size = sizeof(GLboolean);
|
|
break;
|
|
case GL_BYTE:
|
|
attribute_size = sizeof(GLbyte);
|
|
break;
|
|
case GL_UNSIGNED_BYTE:
|
|
attribute_size = sizeof(GLubyte);
|
|
break;
|
|
case GL_SHORT:
|
|
attribute_size = sizeof(GLshort);
|
|
break;
|
|
case GL_UNSIGNED_SHORT:
|
|
attribute_size = sizeof(GLushort);
|
|
break;
|
|
case GL_INT:
|
|
attribute_size = sizeof(GLint);
|
|
break;
|
|
case GL_UNSIGNED_INT:
|
|
attribute_size = sizeof(GLuint);
|
|
break;
|
|
case GL_FLOAT:
|
|
attribute_size = sizeof(GLfloat);
|
|
break;
|
|
default:
|
|
attribute_size = 0;
|
|
}
|
|
stride += attribute->size * attribute_size;
|
|
pointer += attribute->size * attribute_size;
|
|
self->attributes[index] = attribute;
|
|
index++;
|
|
} while (end && (index < MAX_VERTEX_ATTRIBUTE));
|
|
|
|
for (i = 0; i < index; ++i)
|
|
{
|
|
self->attributes[i]->stride = stride;
|
|
}
|
|
|
|
#ifdef FREETYPE_GL_USE_VAO
|
|
self->VAO_id = 0;
|
|
#endif
|
|
|
|
self->vertices = vector_new(stride);
|
|
self->vertices_id = 0;
|
|
self->GPU_vsize = 0;
|
|
|
|
self->indices = vector_new(sizeof(GLuint));
|
|
self->indices_id = 0;
|
|
self->GPU_isize = 0;
|
|
|
|
self->items = vector_new(sizeof(ivec4));
|
|
self->state = DIRTY;
|
|
self->mode = GL_TRIANGLES;
|
|
return self;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void vertex_buffer_delete(vertex_buffer_t *self)
|
|
{
|
|
size_t i;
|
|
|
|
assert(self);
|
|
|
|
for (i = 0; i < MAX_VERTEX_ATTRIBUTE; ++i)
|
|
{
|
|
if (self->attributes[i])
|
|
{
|
|
vertex_attribute_delete(self->attributes[i]);
|
|
}
|
|
}
|
|
|
|
#ifdef FREETYPE_GL_USE_VAO
|
|
if (self->VAO_id)
|
|
{
|
|
glDeleteVertexArrays(1, &self->VAO_id);
|
|
}
|
|
self->VAO_id = 0;
|
|
#endif
|
|
|
|
vector_delete(self->vertices);
|
|
self->vertices = 0;
|
|
if (self->vertices_id)
|
|
{
|
|
glDeleteBuffers(1, &self->vertices_id);
|
|
}
|
|
self->vertices_id = 0;
|
|
|
|
vector_delete(self->indices);
|
|
self->indices = 0;
|
|
if (self->indices_id)
|
|
{
|
|
glDeleteBuffers(1, &self->indices_id);
|
|
}
|
|
self->indices_id = 0;
|
|
|
|
vector_delete(self->items);
|
|
|
|
if (self->format)
|
|
{
|
|
free(self->format);
|
|
}
|
|
self->format = 0;
|
|
self->state = 0;
|
|
free(self);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
const char *vertex_buffer_format(const vertex_buffer_t *self)
|
|
{
|
|
assert(self);
|
|
|
|
return self->format;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
size_t vertex_buffer_size(const vertex_buffer_t *self)
|
|
{
|
|
assert(self);
|
|
|
|
return vector_size(self->items);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void vertex_buffer_print(vertex_buffer_t *self)
|
|
{
|
|
int i = 0;
|
|
static char *gltypes[9] = {
|
|
"GL_BOOL", "GL_BYTE", "GL_UNSIGNED_BYTE",
|
|
"GL_SHORT", "GL_UNSIGNED_SHORT", "GL_INT",
|
|
"GL_UNSIGNED_INT", "GL_FLOAT", "GL_VOID"
|
|
};
|
|
|
|
assert(self);
|
|
|
|
fprintf(stderr, "%ld vertices, %ld indices\n", vector_size(self->vertices),
|
|
vector_size(self->indices));
|
|
while (self->attributes[i])
|
|
{
|
|
int j = 8;
|
|
switch (self->attributes[i]->type)
|
|
{
|
|
case GL_BOOL:
|
|
j = 0;
|
|
break;
|
|
case GL_BYTE:
|
|
j = 1;
|
|
break;
|
|
case GL_UNSIGNED_BYTE:
|
|
j = 2;
|
|
break;
|
|
case GL_SHORT:
|
|
j = 3;
|
|
break;
|
|
case GL_UNSIGNED_SHORT:
|
|
j = 4;
|
|
break;
|
|
case GL_INT:
|
|
j = 5;
|
|
break;
|
|
case GL_UNSIGNED_INT:
|
|
j = 6;
|
|
break;
|
|
case GL_FLOAT:
|
|
j = 7;
|
|
break;
|
|
default:
|
|
j = 8;
|
|
break;
|
|
}
|
|
fprintf(stderr, "%s : %dx%s (+%p)\n", self->attributes[i]->name,
|
|
self->attributes[i]->size, gltypes[j],
|
|
self->attributes[i]->pointer);
|
|
|
|
i += 1;
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void vertex_buffer_upload(vertex_buffer_t *self)
|
|
{
|
|
size_t vsize, isize;
|
|
|
|
if (self->state == FROZEN)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!self->vertices_id)
|
|
{
|
|
glGenBuffers(1, &self->vertices_id);
|
|
}
|
|
if (!self->indices_id)
|
|
{
|
|
glGenBuffers(1, &self->indices_id);
|
|
}
|
|
|
|
vsize = self->vertices->size * self->vertices->item_size;
|
|
isize = self->indices->size * self->indices->item_size;
|
|
|
|
// Always upload vertices first such that indices do not point to non
|
|
// existing data (if we get interrupted in between for example).
|
|
|
|
// Upload vertices
|
|
glBindBuffer(GL_ARRAY_BUFFER, self->vertices_id);
|
|
if (vsize != self->GPU_vsize)
|
|
{
|
|
glBufferData(GL_ARRAY_BUFFER, vsize, self->vertices->items,
|
|
GL_DYNAMIC_DRAW);
|
|
self->GPU_vsize = vsize;
|
|
}
|
|
else
|
|
{
|
|
glBufferSubData(GL_ARRAY_BUFFER, 0, vsize, self->vertices->items);
|
|
}
|
|
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
|
|
// Upload indices
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self->indices_id);
|
|
if (isize != self->GPU_isize)
|
|
{
|
|
glBufferData(GL_ELEMENT_ARRAY_BUFFER, isize, self->indices->items,
|
|
GL_DYNAMIC_DRAW);
|
|
self->GPU_isize = isize;
|
|
}
|
|
else
|
|
{
|
|
glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, isize,
|
|
self->indices->items);
|
|
}
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void vertex_buffer_clear(vertex_buffer_t *self)
|
|
{
|
|
assert(self);
|
|
|
|
self->state = FROZEN;
|
|
vector_clear(self->indices);
|
|
vector_clear(self->vertices);
|
|
vector_clear(self->items);
|
|
self->state = DIRTY;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void vertex_buffer_render_setup(vertex_buffer_t *self, GLenum mode)
|
|
{
|
|
size_t i;
|
|
|
|
#ifdef FREETYPE_GL_USE_VAO
|
|
// Unbind so no existing VAO-state is overwritten,
|
|
// (e.g. the GL_ELEMENT_ARRAY_BUFFER-binding).
|
|
glBindVertexArray(0);
|
|
#endif
|
|
|
|
if (self->state != CLEAN)
|
|
{
|
|
vertex_buffer_upload(self);
|
|
self->state = CLEAN;
|
|
}
|
|
|
|
#ifdef FREETYPE_GL_USE_VAO
|
|
if (self->VAO_id == 0)
|
|
{
|
|
// Generate and set up VAO
|
|
|
|
glGenVertexArrays(1, &self->VAO_id);
|
|
glBindVertexArray(self->VAO_id);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, self->vertices_id);
|
|
|
|
for (i = 0; i < MAX_VERTEX_ATTRIBUTE; ++i)
|
|
{
|
|
vertex_attribute_t *attribute = self->attributes[i];
|
|
if (attribute == 0)
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
vertex_attribute_enable(attribute);
|
|
}
|
|
}
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
|
|
if (self->indices->size)
|
|
{
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self->indices_id);
|
|
}
|
|
}
|
|
|
|
// Bind VAO for drawing
|
|
glBindVertexArray(self->VAO_id);
|
|
#else
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, self->vertices_id);
|
|
|
|
for (i = 0; i < MAX_VERTEX_ATTRIBUTE; ++i)
|
|
{
|
|
vertex_attribute_t *attribute = self->attributes[i];
|
|
if (attribute == 0)
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
vertex_attribute_enable(attribute);
|
|
}
|
|
}
|
|
|
|
if (self->indices->size)
|
|
{
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, self->indices_id);
|
|
}
|
|
#endif
|
|
|
|
self->mode = mode;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void vertex_buffer_render_finish(vertex_buffer_t *self)
|
|
{
|
|
#ifdef FREETYPE_GL_USE_VAO
|
|
glBindVertexArray(0);
|
|
#else
|
|
int i;
|
|
|
|
for (i = 0; i < MAX_VERTEX_ATTRIBUTE; ++i)
|
|
{
|
|
vertex_attribute_t *attribute = self->attributes[i];
|
|
if (attribute == 0)
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
glDisableVertexAttribArray(attribute->index);
|
|
}
|
|
}
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
|
|
#endif
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void vertex_buffer_render_item(vertex_buffer_t *self, size_t index)
|
|
{
|
|
ivec4 *item = (ivec4 *) vector_get(self->items, index);
|
|
assert(self);
|
|
assert(index < vector_size(self->items));
|
|
|
|
if (self->indices->size)
|
|
{
|
|
size_t start = item->istart;
|
|
size_t count = item->icount;
|
|
glDrawElements(self->mode, count, GL_UNSIGNED_INT,
|
|
(void *) (start * sizeof(GLuint)));
|
|
}
|
|
else if (self->vertices->size)
|
|
{
|
|
size_t start = item->vstart;
|
|
size_t count = item->vcount;
|
|
glDrawArrays(self->mode, start * self->vertices->item_size, count);
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void vertex_buffer_render(vertex_buffer_t *self, GLenum mode)
|
|
{
|
|
size_t vcount = self->vertices->size;
|
|
size_t icount = self->indices->size;
|
|
|
|
vertex_buffer_render_setup(self, mode);
|
|
if (icount)
|
|
{
|
|
glDrawElements(mode, icount, GL_UNSIGNED_INT, 0);
|
|
}
|
|
else
|
|
{
|
|
glDrawArrays(mode, 0, vcount);
|
|
}
|
|
vertex_buffer_render_finish(self);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void vertex_buffer_push_back_indices(vertex_buffer_t *self,
|
|
const GLuint *indices, const size_t icount)
|
|
{
|
|
assert(self);
|
|
|
|
self->state |= DIRTY;
|
|
vector_push_back_data(self->indices, indices, icount);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void vertex_buffer_push_back_vertices(vertex_buffer_t *self,
|
|
const void *vertices, const size_t vcount)
|
|
{
|
|
assert(self);
|
|
|
|
self->state |= DIRTY;
|
|
vector_push_back_data(self->vertices, vertices, vcount);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void vertex_buffer_insert_indices(vertex_buffer_t *self, const size_t index,
|
|
const GLuint *indices, const size_t count)
|
|
{
|
|
assert(self);
|
|
assert(self->indices);
|
|
assert(index < self->indices->size + 1);
|
|
|
|
self->state |= DIRTY;
|
|
vector_insert_data(self->indices, index, indices, count);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void vertex_buffer_insert_vertices(vertex_buffer_t *self, const size_t index,
|
|
const void *vertices, const size_t vcount)
|
|
{
|
|
size_t i;
|
|
assert(self);
|
|
assert(self->vertices);
|
|
assert(index < self->vertices->size + 1);
|
|
|
|
self->state |= DIRTY;
|
|
|
|
for (i = 0; i < self->indices->size; ++i)
|
|
{
|
|
if (*(GLuint *) (vector_get(self->indices, i)) > index)
|
|
{
|
|
*(GLuint *) (vector_get(self->indices, i)) += index;
|
|
}
|
|
}
|
|
|
|
vector_insert_data(self->vertices, index, vertices, vcount);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void vertex_buffer_erase_indices(vertex_buffer_t *self, const size_t first,
|
|
const size_t last)
|
|
{
|
|
assert(self);
|
|
assert(self->indices);
|
|
assert(first < self->indices->size);
|
|
assert((last) <= self->indices->size);
|
|
|
|
self->state |= DIRTY;
|
|
vector_erase_range(self->indices, first, last);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void vertex_buffer_erase_vertices(vertex_buffer_t *self, const size_t first,
|
|
const size_t last)
|
|
{
|
|
size_t i;
|
|
assert(self);
|
|
assert(self->vertices);
|
|
assert(first < self->vertices->size);
|
|
assert(last <= self->vertices->size);
|
|
assert(last > first);
|
|
|
|
self->state |= DIRTY;
|
|
for (i = 0; i < self->indices->size; ++i)
|
|
{
|
|
if (*(GLuint *) (vector_get(self->indices, i)) > first)
|
|
{
|
|
*(GLuint *) (vector_get(self->indices, i)) -= (last - first);
|
|
}
|
|
}
|
|
vector_erase_range(self->vertices, first, last);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
size_t vertex_buffer_push_back(vertex_buffer_t *self, const void *vertices,
|
|
const size_t vcount, const GLuint *indices,
|
|
const size_t icount)
|
|
{
|
|
return vertex_buffer_insert(self, vector_size(self->items), vertices,
|
|
vcount, indices, icount);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
size_t vertex_buffer_insert(vertex_buffer_t *self, const size_t index,
|
|
const void *vertices, const size_t vcount,
|
|
const GLuint *indices, const size_t icount)
|
|
{
|
|
size_t vstart, istart, i;
|
|
ivec4 item;
|
|
assert(self);
|
|
assert(vertices);
|
|
assert(indices);
|
|
|
|
self->state = FROZEN;
|
|
|
|
// Push back vertices
|
|
vstart = vector_size(self->vertices);
|
|
vertex_buffer_push_back_vertices(self, vertices, vcount);
|
|
|
|
// Push back indices
|
|
istart = vector_size(self->indices);
|
|
vertex_buffer_push_back_indices(self, indices, icount);
|
|
|
|
// Update indices within the vertex buffer
|
|
for (i = 0; i < icount; ++i)
|
|
{
|
|
*(GLuint *) (vector_get(self->indices, istart + i)) += vstart;
|
|
}
|
|
|
|
// Insert item
|
|
item.x = vstart;
|
|
item.y = vcount;
|
|
item.z = istart;
|
|
item.w = icount;
|
|
vector_insert(self->items, index, &item);
|
|
|
|
self->state = DIRTY;
|
|
return index;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
void vertex_buffer_erase(vertex_buffer_t *self, const size_t index)
|
|
{
|
|
ivec4 *item;
|
|
int vstart;
|
|
size_t vcount, istart, icount, i;
|
|
|
|
assert(self);
|
|
assert(index < vector_size(self->items));
|
|
|
|
item = (ivec4 *) vector_get(self->items, index);
|
|
vstart = item->vstart;
|
|
vcount = item->vcount;
|
|
istart = item->istart;
|
|
icount = item->icount;
|
|
|
|
// Update items
|
|
for (i = 0; i < vector_size(self->items); ++i)
|
|
{
|
|
ivec4 *item = (ivec4 *) vector_get(self->items, i);
|
|
if (item->vstart > vstart)
|
|
{
|
|
item->vstart -= vcount;
|
|
item->istart -= icount;
|
|
}
|
|
}
|
|
|
|
self->state = FROZEN;
|
|
vertex_buffer_erase_indices(self, istart, istart + icount);
|
|
vertex_buffer_erase_vertices(self, vstart, vstart + vcount);
|
|
vector_erase(self->items, index);
|
|
self->state = DIRTY;
|
|
}
|