#include <stdarg.h>

/******************************************

* PORTABLEGL_IMPLEMENTATION

******************************************/

#include <stdio.h>

#include <float.h>

// for CHAR_BIT

#include <limits.h>

// TODO different name? NO_ERROR_CHECKING? LOOK_MA_NO_HANDS?

#ifdef PGL_UNSAFE

#define PGL_SET_ERR(err)

#define PGL_ERR(check, err)

#define PGL_ERR_RET_VAL(check, err, ret)

#define PGL_LOG(err)

#else

#define PGL_LOG(err) \

do { \

if (c->dbg_output && c->dbg_callback) { \

int len = snprintf(c->dbg_msg_buf, PGL_MAX_DEBUG_MESSAGE_LENGTH, "%s in %s() at %s:%d", pgl_err_strs[err-GL_NO_ERROR], __func__, __FILE__, __LINE__); \

c->dbg_callback(GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH, len, c->dbg_msg_buf, c->dbg_userparam); \

} \

} while (0)

#define PGL_SET_ERR(err) \

do { \

if (!c->error) c->error = err; \

PGL_LOG(err); \

} while (0)

#define PGL_ERR(check, err) \

do { \

if (check) { \

if (!c->error) c->error = err; \

PGL_LOG(err); \

return; \

} \

} while (0)

#define PGL_ERR_RET_VAL(check, err, ret) \

do { \

if (check) { \

if (!c->error) c->error = err; \

PGL_LOG(err); \

return ret; \

} \

} while (0)

#endif

// I just set everything even if not everything applies to the type

// see section 3.8.15 pg 181 of spec for what it's supposed to be

// TODO better name and inline?

static void INIT_TEX(glTexture* tex, GLenum target)

{

tex->type = target;

tex->mag_filter = GL_LINEAR;

if (target != GL_TEXTURE_RECTANGLE) {

//tex->min_filter = GL_NEAREST_MIPMAP_LINEAR;

tex->min_filter = GL_NEAREST;

tex->wrap_s = GL_REPEAT;

tex->wrap_t = GL_REPEAT;

tex->wrap_r = GL_REPEAT;

} else {

tex->min_filter = GL_LINEAR;

tex->wrap_s = GL_CLAMP_TO_EDGE;

tex->wrap_t = GL_CLAMP_TO_EDGE;

tex->wrap_r = GL_CLAMP_TO_EDGE;

}

tex->data = NULL;

tex->deleted = GL_FALSE;

tex->user_owned = GL_TRUE;

tex->format = GL_RGBA;

tex->w = 0;

tex->h = 0;

tex->d = 0;

#ifdef PGL_ENABLE_CLAMP_TO_BORDER

tex->border_color = make_v4(0,0,0,0);

#endif

}

// default pass through shaders for index 0

PGLDEF void default_vs(float* vs_output, vec4* vertex_attribs, Shader_Builtins* builtins, void* uniforms)

{

PGL_UNUSED(vs_output);

PGL_UNUSED(uniforms);

builtins->gl_Position = vertex_attribs[PGL_ATTR_VERT];

}

PGLDEF void default_fs(float* fs_input, Shader_Builtins* builtins, void* uniforms)

{

PGL_UNUSED(fs_input);

PGL_UNUSED(uniforms);

vec4* fragcolor = &builtins->gl_FragColor;

//wish I could use a compound literal, stupid C++ compatibility

fragcolor->x = 1.0f;

fragcolor->y = 0.0f;

fragcolor->z = 0.0f;

fragcolor->w = 1.0f;

}

// TODO Where to put this and what to name it? move this and all static functions to gl_internal.c?

#ifndef PGL_UNSAFE

static const char* pgl_err_strs[] =

{

"GL_NO_ERROR",

"GL_INVALID_ENUM",

"GL_INVALID_VALUE",

"GL_INVALID_OPERATION",

"GL_INVALID_FRAMEBUFFER_OPERATION",

"GL_OUT_OF_MEMORY"

};

PGLDEF void dflt_dbg_callback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam)

{

PGL_UNUSED(source);

PGL_UNUSED(type);

PGL_UNUSED(id);

PGL_UNUSED(severity);

PGL_UNUSED(length);

PGL_UNUSED(userParam);

fprintf(stderr, "%s\n", message);

}

#endif

static void init_glVertex_Attrib(glVertex_Attrib* v)

{

/*

GLint size; // number of components 1-4

GLenum type; // GL_FLOAT, default

GLsizei stride; //

GLsizei offset; //

GLboolean normalized;

unsigned int buf;

GLboolean enabled;

GLuint divisor;

*/

v->buf = 0;

v->enabled = 0;

v->divisor = 0;

}

// TODO these are currently equivalent to memset(0) or = {0}...

static void init_glVertex_Array(glVertex_Array* v)

{

v->deleted = GL_FALSE;

for (int i=0; i<GL_MAX_VERTEX_ATTRIBS; ++i)

init_glVertex_Attrib(&v->vertex_attribs[i]);

}

#define GET_SHIFT(mask, shift) \

do {\

shift = 0;\

while ((mask & 1) == 0) {\

mask >>= 1;\

++shift;\

}\

} while (0)

PGLDEF GLboolean init_glContext(glContext* context, pix_t** back, GLsizei w, GLsizei h)

{

PGL_ERR_RET_VAL(!back, GL_INVALID_VALUE, GL_FALSE);

PGL_ERR_RET_VAL((w < 0 || h < 0), GL_INVALID_VALUE, GL_FALSE);

c = context;

memset(c, 0, sizeof(glContext));

if (w && h && *back != NULL) {

c->user_alloced_backbuf = GL_TRUE;

c->back_buffer.buf = (u8*)*back;

c->back_buffer.w = w;

c->back_buffer.h = h;

c->back_buffer.lastrow = c->back_buffer.buf + (h-1)*w*sizeof(pix_t);

}

c->xmin = 0;

c->ymin = 0;

c->width = w;

c->height = h;

c->color_mask = ~0;

//initialize all vectors

cvec_glVertex_Array(&c->vertex_arrays, 0, 3);

cvec_glBuffer(&c->buffers, 0, 3);

cvec_glProgram(&c->programs, 0, 3);

cvec_glTexture(&c->textures, 0, 1);

cvec_glVertex(&c->glverts, 0, 10);

// If not pre-allocating max, need to track size and edit glUseProgram and pglSetInterp

c->vs_output.output_buf = (float*)PGL_MALLOC(PGL_MAX_VERTICES * GL_MAX_VERTEX_OUTPUT_COMPONENTS * sizeof(float));

PGL_ERR_RET_VAL(!c->vs_output.output_buf, GL_OUT_OF_MEMORY, GL_FALSE);

c->clear_color = 0;

SET_V4(c->blend_color, 0, 0, 0, 0);

c->point_size = 1.0f;

c->line_width = 1.0f;

c->clear_depth = 1.0f;

c->depth_range_near = 0.0f;

c->depth_range_far = 1.0f;

make_viewport_m4(c->vp_mat, 0, 0, w, h, 1);

//set flags

//TODO match order in structure definition

c->provoking_vert = GL_LAST_VERTEX_CONVENTION;

c->cull_mode = GL_BACK;

c->cull_face = GL_FALSE;

c->front_face = GL_CCW;

c->depth_test = GL_FALSE;

c->fragdepth_or_discard = GL_FALSE;

c->depth_clamp = GL_FALSE;

c->depth_mask = GL_TRUE;

c->blend = GL_FALSE;

c->logic_ops = GL_FALSE;

c->poly_offset_pt = GL_FALSE;

c->poly_offset_line = GL_FALSE;

c->poly_offset_fill = GL_FALSE;

c->scissor_test = GL_FALSE;

#ifndef PGL_NO_STENCIL

c->clear_stencil = 0;

c->stencil_test = GL_FALSE;

c->stencil_writemask = -1; // all 1s for the masks

c->stencil_writemask_back = -1;

c->stencil_ref = 0;

c->stencil_ref_back = 0;

c->stencil_valuemask = -1;

c->stencil_valuemask_back = -1;

c->stencil_func = GL_ALWAYS;

c->stencil_func_back = GL_ALWAYS;

c->stencil_sfail = GL_KEEP;

c->stencil_dpfail = GL_KEEP;

c->stencil_dppass = GL_KEEP;

c->stencil_sfail_back = GL_KEEP;

c->stencil_dpfail_back = GL_KEEP;

c->stencil_dppass_back = GL_KEEP;

#endif

c->logic_func = GL_COPY;

c->blend_sRGB = GL_ONE;

c->blend_sA = GL_ONE;

c->blend_dRGB = GL_ZERO;

c->blend_dA = GL_ZERO;

c->blend_eqRGB = GL_FUNC_ADD;

c->blend_eqA = GL_FUNC_ADD;

c->depth_func = GL_LESS;

c->line_smooth = GL_FALSE;

c->poly_mode_front = GL_FILL;

c->poly_mode_back = GL_FILL;

c->point_spr_origin = GL_UPPER_LEFT;

c->poly_factor = 0.0f;

c->poly_units = 0.0f;

c->scissor_lx = 0;

c->scissor_ly = 0;

c->scissor_w = w;

c->scissor_h = h;

// According to refpages https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glPixelStore.xhtml

c->unpack_alignment = 4;

c->pack_alignment = 4;

c->draw_triangle_front = draw_triangle_fill;

c->draw_triangle_back = draw_triangle_fill;

c->error = GL_NO_ERROR;

#ifndef PGL_UNSAFE

c->dbg_callback = dflt_dbg_callback;

c->dbg_output = GL_TRUE;

#else

c->dbg_callback = NULL;

c->dbg_output = GL_FALSE;

#endif

// program 0 is supposed to be undefined but not invalid so I'll

// just make it default, no transform, just draws things red

glProgram tmp_prog = { default_vs, default_fs, NULL, 0, {0}, GL_FALSE, GL_FALSE };

cvec_push_glProgram(&c->programs, tmp_prog);

glUseProgram(0);

// setup default vertex_array (vao) at position 0

// we're like a compatibility profile for this but come on

// no reason not to have this imo

// https://www.opengl.org/wiki/Vertex_Specification#Vertex_Array_Object

glVertex_Array tmp_va;

init_glVertex_Array(&tmp_va);

cvec_push_glVertex_Array(&c->vertex_arrays, tmp_va);

c->cur_vertex_array = 0;

// buffer 0 is invalid

glBuffer tmp_buf = {0};

tmp_buf.user_owned = GL_TRUE;

tmp_buf.deleted = GL_FALSE;

cvec_push_glBuffer(&c->buffers, tmp_buf);

// From glBindTexture():

// "The value zero is reserved to represent the default texture for each texture target."

// "In effect, the texture targets become aliases for the textures currently bound to them, and the texture name zero refers to the default textures that were bound to them at initialization."

//

// ... which means we can't use the 0 index at all as it can obviously only

// be one type/target at a time and it would be a pain regardless

// Still we might as well initialize it since something has to be there

glTexture tmp_tex;

INIT_TEX(&tmp_tex, GL_TEXTURE_UNBOUND);

cvec_push_glTexture(&c->textures, tmp_tex);

// Initialize the actual default textures..

// TODO Should I initialize them as their actual types? no

// Should I do the non-spec white pixel thing?

for (int i=0; i<GL_NUM_TEXTURE_TYPES-GL_TEXTURE_UNBOUND-1; i++) {

INIT_TEX(&c->default_textures[i], GL_TEXTURE_UNBOUND);

}

// default texture (0) is bound to all targets initially

memset(c->bound_textures, 0, sizeof(c->bound_textures));

// invalid buffer (0) bound initially

memset(c->bound_buffers, 0, sizeof(c->bound_buffers));

// DRY, do all buffer allocs/init in here

if (w && h && !pglResizeFramebuffer(w, h)) {

#ifndef PGL_NO_DEPTH_NO_STENCIL

PGL_FREE(c->zbuf.buf);

#if defined(PGL_D16) && !defined(PGL_NO_STENCIL)

PGL_FREE(c->stencil_buf.buf);

#endif

#endif

if (!c->user_alloced_backbuf) {

PGL_FREE(c->back_buffer.buf);

}

return GL_FALSE;

}

*back = (pix_t*)c->back_buffer.buf;

return GL_TRUE;

}

PGLDEF void free_glContext(glContext* ctx)

{

int i;

#ifndef PGL_NO_DEPTH_NO_STENCIL

PGL_FREE(ctx->zbuf.buf);

# if defined(PGL_D16) && !defined(PGL_NO_STENCIL)

PGL_FREE(ctx->stencil_buf.buf);

# endif

#endif

if (!ctx->user_alloced_backbuf) {

PGL_FREE(ctx->back_buffer.buf);

}

for (i=0; i<ctx->buffers.size; ++i) {

if (!ctx->buffers.a[i].user_owned) {

PGL_FREE(ctx->buffers.a[i].data);

}

}

for (i=0; i<ctx->textures.size; ++i) {

if (!ctx->textures.a[i].user_owned) {

PGL_FREE(ctx->textures.a[i].data);

}

}

//free vectors

cvec_free_glVertex_Array(&ctx->vertex_arrays);

cvec_free_glBuffer(&ctx->buffers);

cvec_free_glProgram(&ctx->programs);

cvec_free_glTexture(&ctx->textures);

cvec_free_glVertex(&ctx->glverts);

PGL_FREE(ctx->vs_output.output_buf);

if (c == ctx) {

c = NULL;

}

}

PGLDEF void set_glContext(glContext* context)

{

c = context;

}

PGLDEF GLboolean pglResizeFramebuffer(GLsizei w, GLsizei h)

{

PGL_ERR_RET_VAL((w < 0 || h < 0), GL_INVALID_VALUE, GL_FALSE);

// TODO C standard doesn't guarantee that passing the same size to

// realloc is a no-op and will return the same pointer

// NOTE checking zbuf because of the separation between pglSetBackBuffer()

// and pglResizeFramebuffer(). If the former is called before the latter

// backbuf dimensions would compare the same to the new size even when

// we still need to update stencil and zbuf

if (w == c->zbuf.w && h == c->zbuf.h) {

return GL_TRUE; // no resize necessary = success to me

}

u8* tmp;

if (!c->user_alloced_backbuf) {

tmp = (u8*)PGL_REALLOC(c->back_buffer.buf, w*h * sizeof(pix_t));

PGL_ERR_RET_VAL(!tmp, GL_OUT_OF_MEMORY, GL_FALSE);

c->back_buffer.buf = tmp;

c->back_buffer.w = w;

c->back_buffer.h = h;

c->back_buffer.lastrow = c->back_buffer.buf + (h-1)*w*sizeof(pix_t);

}

#ifdef PGL_D24S8

tmp = (u8*)PGL_REALLOC(c->zbuf.buf, w*h * sizeof(u32));

PGL_ERR_RET_VAL(!tmp, GL_OUT_OF_MEMORY, GL_FALSE);

c->zbuf.buf = tmp;

c->zbuf.w = w;

c->zbuf.h = h;

c->zbuf.lastrow = c->zbuf.buf + (h-1)*w*sizeof(u32);

// not checking for NO_STENCIL here because it makes no sense not to

// have it if you're already using the space

c->stencil_buf.buf = tmp;

c->stencil_buf.w = w;

c->stencil_buf.h = h;

c->stencil_buf.lastrow = c->stencil_buf.buf + (h-1)*w*sizeof(u32);

#elif defined(PGL_D16)

tmp = (u8*)PGL_REALLOC(c->zbuf.buf, w*h * sizeof(u16));

PGL_ERR_RET_VAL(!tmp, GL_OUT_OF_MEMORY, GL_FALSE);

c->zbuf.buf = tmp;

c->zbuf.w = w;

c->zbuf.h = h;

c->zbuf.lastrow = c->zbuf.buf + (h-1)*w*sizeof(u16);

#ifndef PGL_NO_STENCIL

tmp = (u8*)PGL_REALLOC(c->stencil_buf.buf, w*h);

PGL_ERR_RET_VAL(!tmp, GL_OUT_OF_MEMORY, GL_FALSE);

c->stencil_buf.buf = tmp;

c->stencil_buf.w = w;

c->stencil_buf.h = h;

c->stencil_buf.lastrow = c->stencil_buf.buf + (h-1)*w;

#endif

#endif

if (c->scissor_test) {

int ux = c->scissor_lx+c->scissor_w;

int uy = c->scissor_ly+c->scissor_h;

c->lx = MAX(c->scissor_lx, 0);

c->ly = MAX(c->scissor_ly, 0);

c->ux = MIN(ux, w);

c->uy = MIN(uy, h);

} else {

c->lx = 0;

c->ly = 0;

c->ux = w;

c->uy = h;

}

return GL_TRUE;

}

PGLDEF GLubyte* glGetString(GLenum name)

{

static GLubyte vendor[] = "Robert Winkler (robertwinkler.com)";

static GLubyte renderer[] = "PortableGL 0.101.0";

static GLubyte version[] = "0.101.0";

static GLubyte shading_language[] = "C/C++";

switch (name) {

case GL_VENDOR: return vendor;

case GL_RENDERER: return renderer;

case GL_VERSION: return version;

case GL_SHADING_LANGUAGE_VERSION: return shading_language;

default:

PGL_SET_ERR(GL_INVALID_ENUM);

return NULL;

}

}

PGLDEF GLenum glGetError(void)

{

GLenum err = c->error;

c->error = GL_NO_ERROR;

return err;

}

PGLDEF void glGenVertexArrays(GLsizei n, GLuint* arrays)

{

PGL_ERR(n < 0, GL_INVALID_VALUE);

glVertex_Array tmp = {0};

//init_glVertex_Array(&tmp);

tmp.deleted = GL_FALSE;

//fill up empty slots first

--n;

for (int i=1; i<c->vertex_arrays.size && n>=0; ++i) {

if (c->vertex_arrays.a[i].deleted) {

c->vertex_arrays.a[i] = tmp;

arrays[n--] = i;

}

}

for (; n>=0; --n) {

cvec_push_glVertex_Array(&c->vertex_arrays, tmp);

arrays[n] = c->vertex_arrays.size-1;

}

}

PGLDEF void glDeleteVertexArrays(GLsizei n, const GLuint* arrays)

{

PGL_ERR(n < 0, GL_INVALID_VALUE);

for (int i=0; i<n; ++i) {

if (!arrays[i] || arrays[i] >= c->vertex_arrays.size)

continue;

// NOTE/TODO: This is non-standard behavior even in a compatibility profile but it

// is similar to (from the user's perspective) how GL handles DeleteProgram called on

// the active program. So instead of getting a blank screen immediately, you just

// free up the name moving the current vao to the default 0. Of course if you're switching

// between VAOs and bind to the old name, you will get a GL error even if it still works

// (because VAOS are POD and I don't overwrite it)... so maybe I should just have an

// error here

if (arrays[i] == c->cur_vertex_array) {

memcpy(&c->vertex_arrays.a[0], &c->vertex_arrays.a[arrays[i]], sizeof(glVertex_Array));

c->cur_vertex_array = 0;

}

c->vertex_arrays.a[arrays[i]].deleted = GL_TRUE;

}

}

PGLDEF void glGenBuffers(GLsizei n, GLuint* buffers)

{

PGL_ERR(n < 0, GL_INVALID_VALUE);

//fill up empty slots first

int j = 0;

for (int i=1; i<c->buffers.size && j<n; ++i) {

if (c->buffers.a[i].deleted) {

c->buffers.a[i].deleted = GL_FALSE;

buffers[j++] = i;

}

}

if (j != n) {

int s = c->buffers.size;

cvec_extend_glBuffer(&c->buffers, n-j);

for (int i=s; j<n; i++) {

c->buffers.a[i].data = NULL;

c->buffers.a[i].deleted = GL_FALSE;

c->buffers.a[i].user_owned = GL_FALSE;

buffers[j++] = i;

}

}

}

PGLDEF void glDeleteBuffers(GLsizei n, const GLuint* buffers)

{

PGL_ERR(n < 0, GL_INVALID_VALUE);

GLenum type;

for (int i=0; i<n; ++i) {

if (!buffers[i] || buffers[i] >= c->buffers.size)

continue;

// NOTE(rswinkle): type is stored as correct index not the raw enum value so no need to

// subtract here see glBindBuffer

type = c->buffers.a[buffers[i]].type;

if (buffers[i] == c->bound_buffers[type])

c->bound_buffers[type] = 0;

if (!c->buffers.a[buffers[i]].user_owned) {

PGL_FREE(c->buffers.a[buffers[i]].data);

}

c->buffers.a[buffers[i]].data = NULL;

c->buffers.a[buffers[i]].deleted = GL_TRUE;

c->buffers.a[buffers[i]].user_owned = GL_FALSE;

}

}

PGLDEF void glGenTextures(GLsizei n, GLuint* textures)

{

PGL_ERR(n < 0, GL_INVALID_VALUE);

int j = 0;

for (int i=1; i<c->textures.size && j<n; ++i) {

if (c->textures.a[i].deleted) {

c->textures.a[i].deleted = GL_FALSE;

c->textures.a[i].type = GL_TEXTURE_UNBOUND;

textures[j++] = i;

}

}

if (j != n) {

int s = c->textures.size;

cvec_extend_glTexture(&c->textures, n-j);

for (int i=s; j<n; i++) {

c->textures.a[i].deleted = GL_FALSE;

c->textures.a[i].type = GL_TEXTURE_UNBOUND;

c->textures.a[i].user_owned = GL_FALSE;

c->textures.a[i].data = NULL;

textures[j++] = i;

}

}

}

PGLDEF void glCreateTextures(GLenum target, GLsizei n, GLuint* textures)

{

PGL_ERR((target < GL_TEXTURE_1D || target >= GL_NUM_TEXTURE_TYPES), GL_INVALID_ENUM);

PGL_ERR(n < 0, GL_INVALID_VALUE);

target -= GL_TEXTURE_UNBOUND + 1;

int j = 0;

for (int i=1; i<c->textures.size && j<n; ++i) {

if (c->textures.a[i].deleted) {

INIT_TEX(&c->textures.a[i], target);

textures[j++] = i;

}

}

if (j != n) {

int s = c->textures.size;

cvec_extend_glTexture(&c->textures, n-j);

for (int i=s; j<n; i++) {

INIT_TEX(&c->textures.a[i], target);

textures[j++] = i;

}

}

}

PGLDEF void glDeleteTextures(GLsizei n, const GLuint* textures)

{

PGL_ERR(n < 0, GL_INVALID_VALUE);

GLenum type;

for (int i=0; i<n; ++i) {

if (!textures[i] || textures[i] >= c->textures.size)

continue;

// NOTE(rswinkle): type is stored as correct index not the raw enum value

// so no need to subtract here see glBindTexture

type = c->textures.a[textures[i]].type;

if (textures[i] == c->bound_textures[type])

c->bound_textures[type] = 0;

if (!c->textures.a[textures[i]].user_owned) {

PGL_FREE(c->textures.a[textures[i]].data);

}

c->textures.a[textures[i]].type = GL_TEXTURE_UNBOUND;

c->textures.a[textures[i]].data = NULL;

c->textures.a[textures[i]].deleted = GL_TRUE;

c->textures.a[textures[i]].user_owned = GL_FALSE;

}

}

PGLDEF void glBindVertexArray(GLuint array)

{

PGL_ERR((array >= c->vertex_arrays.size || c->vertex_arrays.a[array].deleted), GL_INVALID_OPERATION);

c->cur_vertex_array = array;

c->bound_buffers[GL_ELEMENT_ARRAY_BUFFER-GL_ARRAY_BUFFER] = c->vertex_arrays.a[array].element_buffer;

}

PGLDEF void glBindBuffer(GLenum target, GLuint buffer)

{

PGL_ERR(target != GL_ARRAY_BUFFER && target != GL_ELEMENT_ARRAY_BUFFER, GL_INVALID_ENUM);

PGL_ERR((buffer >= c->buffers.size || c->buffers.a[buffer].deleted), GL_INVALID_OPERATION);

target -= GL_ARRAY_BUFFER;

c->bound_buffers[target] = buffer;

// Note type isn't set till binding and we're not storing the raw

// enum but the enum - GL_ARRAY_BUFFER so it's an index into c->bound_buffers

// TODO need to see what's supposed to happen if you try to bind

// a buffer to multiple targets

c->buffers.a[buffer].type = target;

if (target == GL_ELEMENT_ARRAY_BUFFER - GL_ARRAY_BUFFER) {

c->vertex_arrays.a[c->cur_vertex_array].element_buffer = buffer;

}

}

// TODO reuse code, call glNamedBufferData() internally, remove duplicated error checks?

PGLDEF void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)

{

//TODO check for usage later

PGL_UNUSED(usage);

PGL_ERR((target != GL_ARRAY_BUFFER && target != GL_ELEMENT_ARRAY_BUFFER), GL_INVALID_ENUM);

PGL_ERR(size < 0, GL_INVALID_VALUE);

target -= GL_ARRAY_BUFFER;

PGL_ERR(!c->bound_buffers[target], GL_INVALID_OPERATION);

// the spec says any pre-existing data store is deleted but there's no reason to

// c->buffers.a[c->bound_buffers[target]].data is always NULL or valid

u8* tmp = (u8*)PGL_REALLOC(c->buffers.a[c->bound_buffers[target]].data, size);

PGL_ERR(!tmp, GL_OUT_OF_MEMORY);

c->buffers.a[c->bound_buffers[target]].data = tmp;

if (data) {

memcpy(c->buffers.a[c->bound_buffers[target]].data, data, size);

}

c->buffers.a[c->bound_buffers[target]].user_owned = GL_FALSE;

c->buffers.a[c->bound_buffers[target]].size = size;

}

PGLDEF void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)

{

PGL_ERR(target != GL_ARRAY_BUFFER && target != GL_ELEMENT_ARRAY_BUFFER, GL_INVALID_ENUM);

PGL_ERR((offset < 0 || size < 0), GL_INVALID_VALUE);

target -= GL_ARRAY_BUFFER;

PGL_ERR(!c->bound_buffers[target], GL_INVALID_OPERATION);

PGL_ERR((offset + size > c->buffers.a[c->bound_buffers[target]].size), GL_INVALID_VALUE);

memcpy(&c->buffers.a[c->bound_buffers[target]].data[offset], data, size);

}

PGLDEF void glNamedBufferData(GLuint buffer, GLsizeiptr size, const GLvoid* data, GLenum usage)

{

//check for usage later

PGL_UNUSED(usage);

PGL_ERR((!buffer || buffer >= c->buffers.size || c->buffers.a[buffer].deleted), GL_INVALID_OPERATION);

PGL_ERR(size < 0, GL_INVALID_VALUE);

//always NULL or valid

PGL_FREE(c->buffers.a[buffer].data);

c->buffers.a[buffer].data = (u8*)PGL_MALLOC(size);

PGL_ERR(!c->buffers.a[buffer].data, GL_OUT_OF_MEMORY);

if (data) {

memcpy(c->buffers.a[buffer].data, data, size);

}

c->buffers.a[buffer].user_owned = GL_FALSE;

c->buffers.a[buffer].size = size;

}

PGLDEF void glNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr size, const GLvoid* data)

{

PGL_ERR((!buffer || buffer >= c->buffers.size || c->buffers.a[buffer].deleted), GL_INVALID_OPERATION);

PGL_ERR((offset < 0 || size < 0), GL_INVALID_VALUE);

PGL_ERR((offset + size > c->buffers.a[buffer].size), GL_INVALID_VALUE);

memcpy(&c->buffers.a[buffer].data[offset], data, size);

}

// TODO see page 136-7 of spec

PGLDEF void glBindTexture(GLenum target, GLuint texture)

{

PGL_ERR((target < GL_TEXTURE_1D || target >= GL_NUM_TEXTURE_TYPES), GL_INVALID_ENUM);

target -= GL_TEXTURE_UNBOUND + 1;

PGL_ERR((texture >= c->textures.size || c->textures.a[texture].deleted), GL_INVALID_VALUE);

if (texture) {

GLenum type = c->textures.a[texture].type;

PGL_ERR((type != GL_TEXTURE_UNBOUND && type != target), GL_INVALID_OPERATION);

if (type == GL_TEXTURE_UNBOUND) {

INIT_TEX(&c->textures.a[texture], target);

}

}

c->bound_textures[target] = texture;

}

static void set_texparami(glTexture* tex, GLenum pname, GLint param)

{

/*

PGL_ERR((pname != GL_TEXTURE_MIN_FILTER && pname != GL_TEXTURE_MAG_FILTER &&

pname != GL_TEXTURE_WRAP_S && pname != GL_TEXTURE_WRAP_T &&

pname != GL_TEXTURE_WRAP_R), GL_INVALID_ENUM);

*/

// NOTE, currently in the texture access functions

// if it's not NEAREST, it assumes LINEAR so I could

// just say that's good rather than these switch statements

//

// TODO compress this code

if (pname == GL_TEXTURE_MIN_FILTER) {

// TODO technically GL_TEXTURE_RECTANGLE can only have NEAREST OR LINEAR, no mipmapping

// but since we don't actually do mipmaping or use min filter at all...

switch (param) {

case GL_NEAREST:

case GL_NEAREST_MIPMAP_NEAREST:

case GL_NEAREST_MIPMAP_LINEAR:

param = GL_NEAREST;

break;

case GL_LINEAR:

case GL_LINEAR_MIPMAP_NEAREST:

case GL_LINEAR_MIPMAP_LINEAR:

param = GL_LINEAR;

break;

default:

PGL_SET_ERR(GL_INVALID_ENUM);

return;

}

tex->min_filter = param;

} else if (pname == GL_TEXTURE_MAG_FILTER) {

switch (param) {

case GL_NEAREST:

case GL_NEAREST_MIPMAP_NEAREST:

case GL_NEAREST_MIPMAP_LINEAR:

param = GL_NEAREST;

break;

case GL_LINEAR:

case GL_LINEAR_MIPMAP_NEAREST:

case GL_LINEAR_MIPMAP_LINEAR:

param = GL_LINEAR;

break;

default:

PGL_SET_ERR(GL_INVALID_ENUM);

return;

}

tex->min_filter = param;

tex->mag_filter = param;

} else if (pname == GL_TEXTURE_WRAP_S) {

PGL_ERR((param != GL_REPEAT && param != GL_CLAMP_TO_EDGE && param != GL_CLAMP_TO_BORDER && param != GL_MIRRORED_REPEAT), GL_INVALID_ENUM);

// TODO This is in the standard but I don't really see the point, it costs nothing to support it,

// maybe I'll make a PGL_WARN() macro or something

//PGL_ERR((tex->type == GL_TEXTURE_RECTANGLE && param != GL_CLAMP_TO_EDGE && param != GL_CLAMP_TO_BORDER), GL_INVALID_ENUM);

tex->wrap_s = param;

} else if (pname == GL_TEXTURE_WRAP_T) {

PGL_ERR((param != GL_REPEAT && param != GL_CLAMP_TO_EDGE && param != GL_CLAMP_TO_BORDER && param != GL_MIRRORED_REPEAT), GL_INVALID_ENUM);

//PGL_ERR((tex->type == GL_TEXTURE_RECTANGLE && param != GL_CLAMP_TO_EDGE && param != GL_CLAMP_TO_BORDER), GL_INVALID_ENUM);

tex->wrap_t = param;

} else if (pname == GL_TEXTURE_WRAP_R) {

PGL_ERR((param != GL_REPEAT && param != GL_CLAMP_TO_EDGE && param != GL_CLAMP_TO_BORDER && param != GL_MIRRORED_REPEAT), GL_INVALID_ENUM);

tex->wrap_r = param;

} else {

PGL_SET_ERR(GL_INVALID_ENUM);

}

}

// TODO handle ParameterI*() functions correctly

static void get_texparami(glTexture* tex, GLenum pname, GLenum type, GLvoid* params)

{

GLenum val;

switch (pname) {

case GL_TEXTURE_MIN_FILTER: val = tex->min_filter; break;

case GL_TEXTURE_MAG_FILTER: val = tex->mag_filter; break;

case GL_TEXTURE_WRAP_S:

PGL_ERR((pname != GL_REPEAT && pname != GL_CLAMP_TO_EDGE && pname != GL_CLAMP_TO_BORDER && pname != GL_MIRRORED_REPEAT), GL_INVALID_ENUM);

val = tex->wrap_s;

break;

case GL_TEXTURE_WRAP_T:

PGL_ERR((pname != GL_REPEAT && pname != GL_CLAMP_TO_EDGE && pname != GL_CLAMP_TO_BORDER && pname != GL_MIRRORED_REPEAT), GL_INVALID_ENUM);

val = tex->wrap_t;

break;

case GL_TEXTURE_WRAP_R:

PGL_ERR((pname != GL_REPEAT && pname != GL_CLAMP_TO_EDGE && pname != GL_CLAMP_TO_BORDER && pname != GL_MIRRORED_REPEAT), GL_INVALID_ENUM);

val = tex->wrap_r;

break;

default:

PGL_SET_ERR(GL_INVALID_ENUM);

return;

}

if (type == GL_INT) {

*(GLint*)params = val;

} else {

*(GLuint*)params = val;

}

}

PGLDEF void glTexParameteri(GLenum target, GLenum pname, GLint param)

{

PGL_ERR((target != GL_TEXTURE_1D && target != GL_TEXTURE_2D && target != GL_TEXTURE_3D && target != GL_TEXTURE_2D_ARRAY && target != GL_TEXTURE_RECTANGLE && target != GL_TEXTURE_CUBE_MAP), GL_INVALID_ENUM);

//shift to range 0 - NUM_TEXTURES-1 to access bound_textures array

target -= GL_TEXTURE_UNBOUND + 1;

glTexture* tex = NULL;

if (c->bound_textures[target]) {

tex = &c->textures.a[c->bound_textures[target]];

} else {

tex = &c->default_textures[target];

}

set_texparami(tex, pname, param);

}

PGLDEF void glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)

{

#ifdef PGL_ENABLE_CLAMP_TO_BORDER

PGL_ERR((target != GL_TEXTURE_1D && target != GL_TEXTURE_2D && target != GL_TEXTURE_3D && target != GL_TEXTURE_2D_ARRAY && target != GL_TEXTURE_RECTANGLE && target != GL_TEXTURE_CUBE_MAP), GL_INVALID_ENUM);

PGL_ERR((pname != GL_TEXTURE_BORDER_COLOR), GL_INVALID_ENUM);

target -= GL_TEXTURE_UNBOUND + 1;

glTexture* tex = NULL;

if (c->bound_textures[target]) {

tex = &c->textures.a[c->bound_textures[target]];

} else {

tex = &c->default_textures[target];

}

memcpy(&tex->border_color, params, sizeof(GLfloat)*4);

#endif

}

PGLDEF void glTexParameteriv(GLenum target, GLenum pname, const GLint* params)

{

#ifdef PGL_ENABLE_CLAMP_TO_BORDER

PGL_ERR((target != GL_TEXTURE_1D && target != GL_TEXTURE_2D && target != GL_TEXTURE_3D && target != GL_TEXTURE_2D_ARRAY && target != GL_TEXTURE_RECTANGLE && target != GL_TEXTURE_CUBE_MAP), GL_INVALID_ENUM);

PGL_ERR((pname != GL_TEXTURE_BORDER_COLOR), GL_INVALID_ENUM);

target -= GL_TEXTURE_UNBOUND + 1;

glTexture* tex = NULL;

if (c->bound_textures[target]) {

tex = &c->textures.a[c->bound_textures[target]];

} else {

tex = &c->default_textures[target];

}

tex->border_color.x = (2*params[0] + 1)/(UINT32_MAX - 1.0f);

tex->border_color.y = (2*params[1] + 1)/(UINT32_MAX - 1.0f);

tex->border_color.z = (2*params[2] + 1)/(UINT32_MAX - 1.0f);

tex->border_color.w = (2*params[3] + 1)/(UINT32_MAX - 1.0f);

#endif

}

// NOTE: I added the !texture checks to the glTextureParameter*() functions

// even though it's not in the spec because there's no way to know which

// default texture (0) target you're referring to

PGLDEF void glTextureParameteri(GLuint texture, GLenum pname, GLint param)

{

PGL_ERR((!texture || texture >= c->textures.size || c->textures.a[texture].deleted), GL_INVALID_OPERATION);

set_texparami(&c->textures.a[texture], pname, param);

}

PGLDEF void glTextureParameterfv(GLuint texture, GLenum pname, const GLfloat* params)

{

#ifdef PGL_ENABLE_CLAMP_TO_BORDER

PGL_ERR((!texture || texture >= c->textures.size || c->textures.a[texture].deleted), GL_INVALID_OPERATION);

memcpy(&c->textures.a[texture].border_color, params, sizeof(GLfloat)*4);

#endif

}

PGLDEF void glTextureParameteriv(GLuint texture, GLenum pname, const GLint* params)

{

#ifdef PGL_ENABLE_CLAMP_TO_BORDER

PGL_ERR((!texture || texture >= c->textures.size || c->textures.a[texture].deleted), GL_INVALID_OPERATION);

glTexture* tex = &c->textures.a[texture];

tex->border_color.x = (2*params[0] + 1)/(UINT32_MAX - 1.0f);

tex->border_color.y = (2*params[1] + 1)/(UINT32_MAX - 1.0f);

tex->border_color.z = (2*params[2] + 1)/(UINT32_MAX - 1.0f);

tex->border_color.w = (2*params[3] + 1)/(UINT32_MAX - 1.0f);

#endif

}

PGLDEF void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)

{

#ifdef PGL_ENABLE_CLAMP_TO_BORDER

PGL_ERR((target != GL_TEXTURE_1D && target != GL_TEXTURE_2D && target != GL_TEXTURE_3D && target != GL_TEXTURE_2D_ARRAY && target != GL_TEXTURE_RECTANGLE && target != GL_TEXTURE_CUBE_MAP), GL_INVALID_ENUM);

PGL_ERR((pname != GL_TEXTURE_BORDER_COLOR), GL_INVALID_ENUM);

target -= GL_TEXTURE_UNBOUND + 1;

glTexture* tex = NULL;

if (c->bound_textures[target]) {

tex = &c->textures.a[c->bound_textures[target]];

} else {

tex = &c->default_textures[target];

}

memcpy(params, &tex->border_color, sizeof(GLfloat)*4);

#endif

}

PGLDEF void glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)

{

PGL_ERR((target != GL_TEXTURE_1D && target != GL_TEXTURE_2D && target != GL_TEXTURE_3D && target != GL_TEXTURE_2D_ARRAY && target != GL_TEXTURE_RECTANGLE && target != GL_TEXTURE_CUBE_MAP), GL_INVALID_ENUM);

target -= GL_TEXTURE_UNBOUND + 1;

glTexture* tex = NULL;

if (c->bound_textures[target]) {

tex = &c->textures.a[c->bound_textures[target]];

} else {

tex = &c->default_textures[target];

}

get_texparami(tex, pname, GL_INT, (GLvoid*)params);