yquake2/yquake2remaster
0
0
Fork 0
mirror of https://github.com/yquake2/yquake2remaster.git synced 2024-11-10 07:12:07 +00:00
Code Issues Projects Releases Packages Wiki Activity

GL3: Render each Model in one draw call (as GL_TRIANGLES w/ EBO)

Browse source 
this increases performance a lot.

Using DG_dynarr.h for dynamic arrays collecting all the vertices and
indices of a model.
This commit is contained in:
Daniel Gibson 2017-03-25 17:25:17 +01:00
parent 4bc3a68699
commit 35285a0fcd
6 changed files with 1057 additions and 10 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/client/refresh/gl3/gl3_main.c
View file

@ -32,6 +32,9 @@
#define HANDMADE_MATH_IMPLEMENTATION
#include "header/HandmadeMath.h"
#define DG_DYNARR_IMPLEMENTATION
#include "header/DG_dynarr.h"
// TODO: put this in local.h ?
#define REF_VERSION "Yamagi Quake II OpenGL3 Refresher"
@ -552,6 +555,7 @@ GL3_Shutdown(void)
ri.Cmd_RemoveCommand("gl_strings");
GL3_Mod_FreeAll();
GL3_ShutdownMeshes();
GL3_ShutdownImages();
GL3_SurfShutdown();
GL3_Draw_ShutdownLocal();

85
src/client/refresh/gl3/gl3_mesh.c
View file

@ -27,6 +27,8 @@
#include "header/local.h"
#include "header/DG_dynarr.h"
#define NUMVERTEXNORMALS 162
#define SHADEDOT_QUANT 16
@ -47,6 +49,20 @@ float *shadedots = r_avertexnormal_dots[0];
extern vec3_t lightspot;
extern qboolean have_stencil;
DA_TYPEDEF(gl3_alias_vtx_t, AliasVtxArray_t);
DA_TYPEDEF(GLushort, UShortArray_t);
// dynamic arrays to batch all the data of a model, so we can render a model in one draw call
static AliasVtxArray_t vtxBuf = {0};
static UShortArray_t idxBuf = {0};
void
GL3_ShutdownMeshes(void)
{
da_free(vtxBuf);
da_free(idxBuf);
}
static void
LerpVerts(int nverts, dtrivertx_t *v, dtrivertx_t *ov,
dtrivertx_t *verts, float *lerp, float move[3],
@ -149,10 +165,7 @@ DrawAliasFrameLerp(dmdl_t *paliashdr, float backlerp)
for (i = 0; i < 3; i++)
{
move[i] = backlerp * move[i] + frontlerp * frame->translate[i];
}
for (i = 0; i < 3; i++)
{
frontv[i] = frontlerp * frame->scale[i];
backv[i] = backlerp * oldframe->scale[i];
}
@ -163,8 +176,21 @@ DrawAliasFrameLerp(dmdl_t *paliashdr, float backlerp)
assert(sizeof(gl3_alias_vtx_t) == 9*sizeof(GLfloat));
// all the triangle fans and triangle strips of this model will be converted to
// just triangles: the vertices stay the same and are batched in vtxBuf,
// but idxBuf will contain indices to draw them all as GL_TRIANGLE
// this way there's only one draw call (and two glBufferData() calls)
// instead of (at least) dozens. *greatly* improves performance.
// so first clear out the data from last call to this function
// (the buffers are static global so we don't have malloc()/free() for each rendered model)
da_clear(vtxBuf);
da_clear(idxBuf);
while (1)
{
GLushort nextVtxIdx = da_count(vtxBuf);
/* get the vertex count and primitive type */
count = *order++;
@ -184,7 +210,7 @@ DrawAliasFrameLerp(dmdl_t *paliashdr, float backlerp)
type = GL_TRIANGLE_STRIP;
}
gl3_alias_vtx_t buf[count];
gl3_alias_vtx_t* buf = da_addn_uninit(vtxBuf, count);
if (colorOnly)
{
@ -233,12 +259,55 @@ DrawAliasFrameLerp(dmdl_t *paliashdr, float backlerp)
}
}
GL3_BindVAO(gl3state.vaoAlias);
GL3_BindVBO(gl3state.vboAlias);
// translate triangle fan/strip to just triangle indices
if(type == GL_TRIANGLE_FAN)
{
GLushort i;
for(i=1; i < count-1; ++i)
{
GLushort* add = da_addn_uninit(idxBuf, 3);
glBufferData(GL_ARRAY_BUFFER, count*sizeof(gl3_alias_vtx_t), buf, GL_STREAM_DRAW);
glDrawArrays(type, 0, count);
add[0] = nextVtxIdx;
add[1] = nextVtxIdx+i;
add[2] = nextVtxIdx+i+1;
}
}
else // triangle strip
{
GLushort i;
for(i=1; i < count-2; i+=2)
{
// add two triangles at once, because the vertex order is different
// for odd vs even triangles
GLushort* add = da_addn_uninit(idxBuf, 6);
add[0] = nextVtxIdx + i-1;
add[1] = nextVtxIdx + i;
add[2] = nextVtxIdx + i+1;
add[3] = nextVtxIdx + i;
add[4] = nextVtxIdx + i+2;
add[5] = nextVtxIdx + i+1;
}
// add remaining triangle, if any
if(i < count-1)
{
GLushort* add = da_addn_uninit(idxBuf, 3);
add[0] = nextVtxIdx + i-1;
add[1] = nextVtxIdx + i;
add[2] = nextVtxIdx + i+1;
}
}
}
GL3_BindVAO(gl3state.vaoAlias);
GL3_BindVBO(gl3state.vboAlias);
glBufferData(GL_ARRAY_BUFFER, da_count(vtxBuf)*sizeof(gl3_alias_vtx_t), vtxBuf.p, GL_STREAM_DRAW);
GL3_BindEBO(gl3state.eboAlias);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, da_count(idxBuf)*sizeof(GLushort), idxBuf.p, GL_STREAM_DRAW);
glDrawElements(GL_TRIANGLES, da_count(idxBuf), GL_UNSIGNED_SHORT, NULL);
}
static void

1
src/client/refresh/gl3/gl3_misc.c
View file

@ -66,7 +66,6 @@ GL3_SetDefaultState(void)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
STUB("need replacement for R_TexEnv(GL_REPLACE);");
if (gl_msaa_samples->value)
{

3
src/client/refresh/gl3/gl3_surf.c
View file

@ -80,6 +80,7 @@ void GL3_SurfInit(void)
glEnableVertexAttribArray(GL3_ATTRIB_COLOR);
qglVertexAttribPointer(GL3_ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, 9*sizeof(GLfloat), 5*sizeof(GLfloat));
glGenBuffers(1, &gl3state.eboAlias);
// init VAO and VBO for particle vertexdata: 9 floats
// (X,Y,Z), (point_size,distace_to_camera), (R,G,B,A)
@ -108,6 +109,8 @@ void GL3_SurfShutdown(void)
glDeleteVertexArrays(1, &gl3state.vao3D);
gl3state.vao3D = 0;
glDeleteBuffers(1, &gl3state.eboAlias);
gl3state.eboAlias = 0;
glDeleteBuffers(1, &gl3state.vboAlias);
gl3state.vboAlias = 0;
glDeleteVertexArrays(1, &gl3state.vaoAlias);

960
src/client/refresh/gl3/header/DG_dynarr.h Normal file
View file

@ -0,0 +1,960 @@
/*
* A header-only typesafe dynamic array implementation for plain C,
* kinda like C++ std::vector. This code is compatible with C++, but should
* only be used with POD (plain old data) types, as it uses memcpy() etc
* instead of copy/move construction/assignment.
* It requires a new type (created with the DA_TYPEDEF(ELEMENT_TYPE, ARRAY_TYPE_NAME)
* macro) for each kind of element you want to put in a dynamic array; however
* the "functions" to manipulate the array are actually macros and the same
* for all element types.
* The array elements are accessed via dynArr.p[i] or da_get(dynArr, i)
* - the latter checks whether i is a valid index and asserts if not.
*
* One thing to keep in mind is that, because of using macros, the arguments to
* the "functions" are usually evaluated more than once, so you should avoid
* putting things with side effect (like function-calls with side effects or i++)
* into them. Notable exceptions are the value arguments (v) of da_push()
* and da_insert(), so it's still ok to do da_push(arr, fun_with_sideffects());
* or da_insert(a, 3, x++);
*
* The function-like da_* macros are short aliases of dg_dynarr_* macros.
* If the short names clash with anything in your code or other headers
* you are using, you can, before #including this header, do
* #define DG_DYNARR_NO_SHORTNAMES
* and use the long dg_dynarr_* forms of the macros instead.
*
* Using this library in your project:
* Put this file somewhere in your project.
* In *one* of your .c/.cpp files, do
* #define DG_DYNARR_IMPLEMENTATION
* #include "DG_dynarr.h"
* to create the implementation of this library in that file.
* You can just #include "DG_dynarr.h" (without the #define) in other source
* files to use it there.
*
* See below this comment block for a usage example.
*
* You can #define your own allocators, assertion and the amount of runtime
* checking of indexes, see CONFIGURATION section in the code for more information.
*
*
* This is heavily inspired by Sean Barrett's stretchy_buffer.h
* ( see: https://github.com/nothings/stb/blob/master/stretchy_buffer.h )
* However I wanted to have a struct that holds the array pointer and the length
* and capacity, so that struct always remains at the same address while the
* array memory might be reallocated.
* I can live with arr.p[i] instead of arr[i], but I like how he managed to use
* macros to create an API that doesn't force the user to specify the stored
* type over and over again, so I stole some of his tricks :-)
*
* This has been tested with GCC 4.8 and clang 3.8 (-std=gnu89, -std=c99 and as C++;
* -std=c89 works if you convert the C++-style comments to C comments) and
* Microsoft Visual Studio 6 and 2010 (32bit) and 2013 (32bit and 64bit).
* I guess it works with all (recentish) C++ compilers and C compilers supporting
* C99 or even C89 + C++ comments (otherwise converting the comments should help).
*
* (C) 2016 Daniel Gibson
*
* LICENSE
* This software is dual-licensed to the public domain and under the following
* license: you are granted a perpetual, irrevocable license to copy, modify,
* publish, and distribute this file as you see fit.
* No warranty implied; use at your own risk.
*/
#if 0 // Usage Example:
#define DG_DYNARR_IMPLEMENTATION // this define is only needed in *one* .c/.cpp file!
#include "DG_dynarr.h"
DA_TYPEDEF(int, MyIntArrType); // creates MyIntArrType - a dynamic array for ints
void printIntArr(MyIntArrType* arr, const char* name)
{
// note that arr is a pointer here, so use *arr in the da_*() functions.
printf("%s = {", name);
if(da_count(*arr) > 0)
printf(" %d", arr->p[0]);
for(int i=1; i<da_count(*arr); ++i)
printf(", %d", arr->p[i]);
printf(" }\n");
}
void myFunction()
{
MyIntArrType a1 = {0}; // make sure to zero out the struct
// instead of = {0}; you could also call da_init(a1);
da_push(a1, 42);
assert(da_count(a1) == 1 && a1.p[0] == 42);
int* addedElements = da_addn_uninit(a1, 3);
assert(da_count(a1) == 4);
for(size_t i=0; i<3; ++i)
addedElements[i] = i+5;
printIntArr(&a1, "a1"); // "a1 = { 42, 5, 6, 7 }"
MyIntArrType a2;
da_init(a2);
da_addn(a2, a1.p, da_count(a1)); // copy all elements from a1 to a2
assert(da_count(a2) == 4);
da_insert(a2, 1, 11);
printIntArr(&a2, "a2"); // "a2 = { 42, 11, 5, 6, 7 }"
da_delete(a2, 2);
printIntArr(&a2, "a2"); // "a2 = { 42, 11, 6, 7 }"
da_deletefast(a2, 0);
printIntArr(&a2, "a2"); // "a2 = { 7, 11, 6 }"
da_push(a1, 3);
printIntArr(&a1, "a1"); // "a1 = { 42, 5, 6, 7, 3 }"
int x=da_pop(a1);
printf("x = %d\n", x); // "x = 3"
printIntArr(&a1, "a1"); // "a1 = { 42, 5, 6, 7 }"
da_free(a1); // make sure not to leak memory!
da_free(a2);
}
#endif // 0 (usage example)
#ifndef DG__DYNARR_H
#define DG__DYNARR_H
// ######### CONFIGURATION #########
// following: some #defines that you can tweak to your liking
// you can reduce some overhead by defining DG_DYNARR_INDEX_CHECK_LEVEL to 2, 1 or 0
#ifndef DG_DYNARR_INDEX_CHECK_LEVEL
// 0: (almost) no index checking
// 1: macros "returning" something return a.p[0] or NULL if the index was invalid
// 2: assertions in all macros taking indexes that make sure they're valid
// 3: 1 and 2
#define DG_DYNARR_INDEX_CHECK_LEVEL 3
#endif // DG_DYNARR_INDEX_CHECK_LEVEL
// you can #define your own DG_DYNARR_ASSERT(condition, msgstring)
// that will be used for all assertions in this code.
#ifndef DG_DYNARR_ASSERT
#include <assert.h>
#define DG_DYNARR_ASSERT(cond, msg) assert((cond) && msg)
#endif
// you can #define DG_DYNARR_OUT_OF_MEMORY to some code that will be executed
// if allocating memory fails
// it's needed only before the #define DG_DYNARR_IMPLEMENTATION #include of
// this header, so the following is here only for reference and commented out
/*
#ifndef DG_DYNARR_OUT_OF_MEMORY
#define DG_DYNARR_OUT_OF_MEMORY DG_DYNARR_ASSERT(0, "Out of Memory!");
#endif
*/
// By default, C's malloc(), realloc() and free() is used to allocate/free heap memory
// (see beginning of "#ifdef DG_DYNARR_IMPLEMENTATION" block below).
// You can #define DG_DYNARR_MALLOC, DG_DYNARR_REALLOC and DG_DYNARR_FREE yourself
// to provide alternative implementations like Win32 Heap(Re)Alloc/HeapFree
// it's needed only before the #define DG_DYNARR_IMPLEMENTATION #include of
// this header, so the following is here only for reference and commented out
/*
#define DG_DYNARR_MALLOC(elemSize, numElems) malloc(elemSize*numElems)
// oldNumElems is not used for C's realloc, but maybe you need it for
// your allocator to copy the old elements over
#define DG_DYNARR_REALLOC(ptr, elemSize, oldNumElems, newCapacity) \
realloc(ptr, elemSize*newCapacity);
#define DG_DYNARR_FREE(ptr) free(ptr)
*/
// if you want to prepend something to the non inline (DG_DYNARR_INLINE) functions,
// like "__declspec(dllexport)" or whatever, #define DG_DYNARR_DEF
#ifndef DG_DYNARR_DEF
// by defaults it's empty.
#define DG_DYNARR_DEF
#endif
// some functions are inline, in case your compiler doesn't like "static inline"
// but wants "__inline__" or something instead, #define DG_DYNARR_INLINE accordingly.
#ifndef DG_DYNARR_INLINE
// for pre-C99 compilers you might have to use something compiler-specific (or maybe only "static")
#ifdef _MSC_VER
#define DG_DYNARR_INLINE static __inline
#else
#define DG_DYNARR_INLINE static inline
#endif
#endif
// ############### Short da_* aliases for the long names ###############
#ifndef DG_DYNARR_NO_SHORTNAMES
// this macro is used to create an array type (struct) for elements of TYPE
// use like DA_TYPEDEF(int, MyIntArrType); MyIntArrType ia = {0}; da_push(ia, 42); ...
#define DA_TYPEDEF(TYPE, NewArrayTypeName) \
DG_DYNARR_TYPEDEF(TYPE, NewArrayTypeName)
// makes sure the array is initialized and can be used.
// either do YourArray arr = {0}; or YourArray arr; da_init(arr);
#define da_init(a) \
dg_dynarr_init(a)
/*
* This allows you to provide an external buffer that'll be used as long as it's big enough
* once you add more elements than buf can hold, fresh memory will be allocated on the heap
* Use like:
* DA_TYPEDEF(double, MyDoubleArrType);
* MyDoubleArrType arr;
* double buf[8];
* dg_dynarr_init_external(arr, buf, 8);
* dg_dynarr_push(arr, 1.23);
* ...
*/
#define da_init_external(a, buf, buf_cap) \
dg_dynarr_init_external(a, buf, buf_cap)
// use this to free the memory allocated by dg_dynarr once you don't need the array anymore
// Note: it is safe to add new elements to the array after da_free()
// it will allocate new memory, just like it would directly after da_init()
#define da_free(a) \
dg_dynarr_free(a)
// add an element to the array (appended at the end)
#define da_push(a, v) \
dg_dynarr_push(a, v)
// add an element to the array (appended at the end)
// does the same as push, just for consistency with addn (like insert and insertn)
#define da_add(a, v) \
dg_dynarr_add(a, v)
// append n elements to a and initialize them from array vals, doesn't return anything
// ! vals (and all other args) are evaluated multiple times !
#define da_addn(a, vals, n) \
dg_dynarr_addn(a, vals, n)
// add n elements to the end of the array and zeroes them with memset()
// returns pointer to first added element, NULL if out of memory (array is empty then)
#define da_addn_zeroed(a, n) \
dg_dynarr_addn_zeroed(a, n)
// add n elements to the end of the array, will remain uninitialized
// returns pointer to first added element, NULL if out of memory (array is empty then)
#define da_addn_uninit(a, n) \
dg_dynarr_addn_uninit(a, n)
// insert a single value v at index idx
#define da_insert(a, idx, v) \
dg_dynarr_insert(a, idx, v)
// insert n elements into a at idx, initialize them from array vals
// doesn't return anything
// ! vals (and all other args) is evaluated multiple times !
#define da_insertn(a, idx, vals, n) \
dg_dynarr_insertn(a, idx, vals, n)
// insert n elements into a at idx and zeroe them with memset()
// returns pointer to first inserted element or NULL if out of memory
#define da_insertn_zeroed(a, idx, n) \
dg_dynarr_insertn_zeroed(a, idx, n)
// insert n uninitialized elements into a at idx;
// returns pointer to first inserted element or NULL if out of memory
#define da_insertn_uninit(a, idx, n) \
dg_dynarr_insertn_uninit(a, idx, n)
// set a single value v at index idx - like "a.p[idx] = v;" but with checks (unless disabled)
#define da_set(a, idx, v) \
dg_dynarr_set(a, idx, v)
// overwrite n elements of a, starting at idx, with values from array vals
// doesn't return anything
// ! vals (and all other args) is evaluated multiple times !
#define da_setn(a, idx, vals, n) \
dg_dynarr_setn(a, idx, vals, n)
// delete the element at idx, moving all following elements (=> keeps order)
#define da_delete(a, idx) \
dg_dynarr_delete(a, idx)
// delete n elements starting at idx, moving all following elements (=> keeps order)
#define da_deleten(a, idx, n) \
dg_dynarr_deleten(a, idx, n)
// delete the element at idx, move the last element there (=> doesn't keep order)
#define da_deletefast(a, idx) \
dg_dynarr_deletefast(a, idx)
// delete n elements starting at idx, move the last n elements there (=> doesn't keep order)
#define da_deletenfast(a, idx, n) \
dg_dynarr_deletenfast(a, idx, n)
// removes all elements from the array, but does not free the buffer
// (if you want to free the buffer too, just use da_free())
#define da_clear(a) \
dg_dynarr_clear(a)
// sets the logical number of elements in the array
// if cnt > dg_dynarr_count(a), the logical count will be increased accordingly
// and the new elements will be uninitialized
#define da_setcount(a, cnt) \
dg_dynarr_setcount(a, cnt)
// make sure the array can store cap elements without reallocating
// logical count remains unchanged
#define da_reserve(a, cap) \
dg_dynarr_reserve(a, cap)
// this makes sure a only uses as much memory as for its elements
// => maybe useful if a used to contain a huge amount of elements,
// but you deleted most of them and want to free some memory
// Note however that this implies an allocation and copying the remaining
// elements, so only do this if it frees enough memory to be worthwhile!
#define da_shrink_to_fit(a) \
dg_dynarr_shrink_to_fit(a)
// removes and returns the last element of the array
#define da_pop(a) \
dg_dynarr_pop(a)
// returns the last element of the array
#define da_last(a) \
dg_dynarr_last(a)
// returns the pointer *to* the last element of the array
// (in contrast to dg_dynarr_end() which returns a pointer *after* the last element)
// returns NULL if array is empty
#define da_lastptr(a) \
dg_dynarr_lastptr(a)
// get element at index idx (like a.p[idx]), but with checks
// (unless you disabled them with #define DG_DYNARR_INDEX_CHECK_LEVEL 0)
#define da_get(a, idx) \
dg_dynarr_get(a,idx)
// get pointer to element at index idx (like &a.p[idx]), but with checks
// and it returns NULL if idx is invalid
#define da_getptr(a, idx) \
dg_dynarr_getptr(a, idx)
// returns a pointer to the first element of the array
// (together with dg_dynarr_end() you can do C++-style iterating)
#define da_begin(a) \
dg_dynarr_begin(a)
// returns a pointer to the past-the-end element of the array
// Allows C++-style iterating, in case you're into that kind of thing:
// for(T *it=da_begin(a), *end=da_end(a); it!=end; ++it) foo(*it);
// (see da_lastptr() to get a pointer *to* the last element)
#define da_end(a) \
dg_dynarr_end(a)
// returns (logical) number of elements currently in the array
#define da_count(a) \
dg_dynarr_count(a)
// get the current reserved capacity of the array
#define da_capacity(a) \
dg_dynarr_capacity(a)
// returns 1 if the array is empty, else 0
#define da_empty(a) \
dg_dynarr_empty(a)
// returns 1 if the last (re)allocation when inserting failed (Out Of Memory)
// or if the array has never allocated any memory yet, else 0
// deleting the contents when growing fails instead of keeping old may seem
// a bit uncool, but it's simple and OOM should rarely happen on modern systems
// anyway - after all you need to deplete both RAM and swap/pagefile.sys
#define da_oom(a) \
dg_dynarr_oom(a)
// sort a using the given qsort()-comparator cmp
// (just a slim wrapper around qsort())
#define da_sort(a, cmp) \
dg_dynarr_sort(a, cmp)
#endif // DG_DYNARR_NO_SHORTNAMES
// ######### Implementation of the actual macros (using the long names) ##########
// use like DG_DYNARR_TYPEDEF(int, MyIntArrType); MyIntArrType ia = {0}; dg_dynarr_push(ia, 42); ...
#define DG_DYNARR_TYPEDEF(TYPE, NewArrayTypeName) \
typedef struct { TYPE* p; dg__dynarr_md md; } NewArrayTypeName;
// makes sure the array is initialized and can be used.
// either do YourArray arr = {0}; or YourArray arr; dg_dynarr_init(arr);
#define dg_dynarr_init(a) \
dg__dynarr_init((void**)&(a).p, &(a).md, NULL, 0)
// this allows you to provide an external buffer that'll be used as long as it's big enough
// once you add more elements than buf can hold, fresh memory will be allocated on the heap
#define dg_dynarr_init_external(a, buf, buf_cap) \
dg__dynarr_init((void**)&(a).p, &(a).md, (buf), (buf_cap))
// use this to free the memory allocated by dg_dynarr
// Note: it is safe to add new elements to the array after dg_dynarr_free()
// it will allocate new memory, just like it would directly after dg_dynarr_init()
#define dg_dynarr_free(a) \
dg__dynarr_free((void**)&(a).p, &(a).md)
// add an element to the array (appended at the end)
#define dg_dynarr_push(a, v) \
(dg__dynarr_maybegrowadd(dg__dynarr_unp(a), 1) ? (((a).p[(a).md.cnt++] = (v)),0) : 0)
// add an element to the array (appended at the end)
// does the same as push, just for consistency with addn (like insert and insertn)
#define dg_dynarr_add(a, v) \
dg_dynarr_push((a), (v))
// append n elements to a and initialize them from array vals, doesn't return anything
// ! vals (and all other args) are evaluated multiple times !
#define dg_dynarr_addn(a, vals, n) do { \
DG_DYNARR_ASSERT((vals)!=NULL, "Don't pass NULL als vals to dg_dynarr_addn!"); \
if((vals)!=NULL && dg__dynarr_add(dg__dynarr_unp(a), n, 0)) { \
size_t i_=(a).md.cnt-(n), v_=0; \
while(i_<(a).md.cnt) (a).p[i_++]=(vals)[v_++]; \
} } DG__DYNARR_WHILE0
// add n elements to the end of the array and zeroe them with memset()
// returns pointer to first added element, NULL if out of memory (array is empty then)
#define dg_dynarr_addn_zeroed(a, n) \
(dg__dynarr_add(dg__dynarr_unp(a), (n), 1) ? &(a).p[(a).md.cnt-(size_t)(n)] : NULL)
// add n elements to the end of the array, which are uninitialized
// returns pointer to first added element, NULL if out of memory (array is empty then)
#define dg_dynarr_addn_uninit(a, n) \
(dg__dynarr_add(dg__dynarr_unp(a), (n), 0) ? &(a).p[(a).md.cnt-(size_t)(n)] : NULL)
// insert a single value v at index idx
#define dg_dynarr_insert(a, idx, v) \
(dg__dynarr_checkidxle((a),(idx)), \
dg__dynarr_insert(dg__dynarr_unp(a), (idx), 1, 0), \
(a).p[dg__dynarr_idx((a).md, (idx))] = (v))
// insert n elements into a at idx, initialize them from array vals
// doesn't return anything
// ! vals (and all other args) is evaluated multiple times !
#define dg_dynarr_insertn(a, idx, vals, n) do { \
DG_DYNARR_ASSERT((vals)!=NULL, "Don't pass NULL as vals to dg_dynarr_insertn!"); \
dg__dynarr_checkidxle((a),(idx)); \
if((vals)!=NULL && dg__dynarr_insert(dg__dynarr_unp(a), (idx), (n), 0)){ \
size_t i_=(idx), v_=0, e_=(idx)+(n); \
while(i_ < e_) (a).p[i_++] = (vals)[v_++]; \
}} DG__DYNARR_WHILE0
// insert n elements into a at idx and zeroe them with memset()
// returns pointer to first inserted element or NULL if out of memory
#define dg_dynarr_insertn_zeroed(a, idx, n) \
(dg__dynarr_checkidxle((a),(idx)), \
dg__dynarr_insert(dg__dynarr_unp(a), (idx), (n), 1) \
? &(a).p[dg__dynarr_idx((a).md, (idx))] : NULL)
// insert n uninitialized elements into a at idx;
// returns pointer to first inserted element or NULL if out of memory
#define dg_dynarr_insertn_uninit(a, idx, n) \
(dg__dynarr_checkidxle((a),(idx)), \
dg__dynarr_insert(dg__dynarr_unp(a), idx, n, 0) \
? &(a).p[dg__dynarr_idx((a).md, (idx))] : NULL)
// set a single value v at index idx - like "a.p[idx] = v;" but with checks (unless disabled)
#define dg_dynarr_set(a, idx, v) \
(dg__dynarr_checkidx((a),(idx)), \
(a).p[dg__dynarr_idx((a).md, (idx))] = (v))
// overwrite n elements of a, starting at idx, with values from array vals
// doesn't return anything
// ! vals (and all other args) is evaluated multiple times !
#define dg_dynarr_setn(a, idx, vals, n) do { \
DG_DYNARR_ASSERT((vals)!=NULL, "Don't pass NULL as vals to dg_dynarr_setn!"); \
size_t idx_=(idx); size_t end_=idx_+(size_t)n; \
dg__dynarr_checkidx((a),idx_); dg__dynarr_checkidx((a),end_-1); \
if((vals)!=NULL && idx_ < (a).md.cnt && end_ <= (a).md.cnt) { \
size_t v_=0; \
while(idx_ < end_) (a).p[idx_++] = (vals)[v_++]; \
}} DG__DYNARR_WHILE0
// delete the element at idx, moving all following elements (=> keeps order)
#define dg_dynarr_delete(a, idx) \
(dg__dynarr_checkidx((a),(idx)), dg__dynarr_delete(dg__dynarr_unp(a), (idx), 1))
// delete n elements starting at idx, moving all following elements (=> keeps order)
#define dg_dynarr_deleten(a, idx, n) \
(dg__dynarr_checkidx((a),(idx)), dg__dynarr_delete(dg__dynarr_unp(a), (idx), (n)))
// TODO: check whether idx+n < count?
// delete the element at idx, move the last element there (=> doesn't keep order)
#define dg_dynarr_deletefast(a, idx) \
(dg__dynarr_checkidx((a),(idx)), dg__dynarr_deletefast(dg__dynarr_unp(a), (idx), 1))
// delete n elements starting at idx, move the last n elements there (=> doesn't keep order)
#define dg_dynarr_deletenfast(a, idx, n) \
(dg__dynarr_checkidx((a),(idx)), dg__dynarr_deletefast(dg__dynarr_unp(a), idx, n))
// TODO: check whether idx+n < count?
// removes all elements from the array, but does not free the buffer
// (if you want to free the buffer too, just use dg_dynarr_free())
#define dg_dynarr_clear(a) \
((a).md.cnt=0)
// sets the logical number of elements in the array
// if cnt > dg_dynarr_count(a), the logical count will be increased accordingly
// and the new elements will be uninitialized
#define dg_dynarr_setcount(a, n) \
(dg__dynarr_maybegrow(dg__dynarr_unp(a), (n)) ? ((a).md.cnt = (n)) : 0)
// make sure the array can store cap elements without reallocating
// logical count remains unchanged
#define dg_dynarr_reserve(a, cap) \
dg__dynarr_maybegrow(dg__dynarr_unp(a), (cap))
// this makes sure a only uses as much memory as for its elements
// => maybe useful if a used to contain a huge amount of elements,
// but you deleted most of them and want to free some memory
// Note however that this implies an allocation and copying the remaining
// elements, so only do this if it frees enough memory to be worthwhile!
#define dg_dynarr_shrink_to_fit(a) \
dg__dynarr_shrink_to_fit(dg__dynarr_unp(a))
#if (DG_DYNARR_INDEX_CHECK_LEVEL == 1) || (DG_DYNARR_INDEX_CHECK_LEVEL == 3)
// removes and returns the last element of the array
#define dg_dynarr_pop(a) \
(dg__dynarr_check_notempty((a), "Don't pop an empty array!"), \
(a).p[((a).md.cnt > 0) ? (--(a).md.cnt) : 0])
// returns the last element of the array
#define dg_dynarr_last(a) \
(dg__dynarr_check_notempty((a), "Don't call da_last() on an empty array!"), \
(a).p[((a).md.cnt > 0) ? ((a).md.cnt-1) : 0])
#elif (DG_DYNARR_INDEX_CHECK_LEVEL == 0) || (DG_DYNARR_INDEX_CHECK_LEVEL == 2)
// removes and returns the last element of the array
#define dg_dynarr_pop(a) \
(dg__dynarr_check_notempty((a), "Don't pop an empty array!"), \
(a).p[--(a).md.cnt])
// returns the last element of the array
#define dg_dynarr_last(a) \
(dg__dynarr_check_notempty((a), "Don't call da_last() on an empty array!"), \
(a).p[(a).md.cnt-1])
#else // invalid DG_DYNARR_INDEX_CHECK_LEVEL
#error Invalid index check level DG_DYNARR_INDEX_CHECK_LEVEL (must be 0-3) !
#endif // DG_DYNARR_INDEX_CHECK_LEVEL
// returns the pointer *to* the last element of the array
// (in contrast to dg_dynarr_end() which returns a pointer *after* the last element)
// returns NULL if array is empty
#define dg_dynarr_lastptr(a) \
(((a).md.cnt > 0) ? ((a).p + (a).md.cnt - 1) : NULL)
// get element at index idx (like a.p[idx]), but with checks
// (unless you disabled them with #define DG_DYNARR_INDEX_CHECK_LEVEL 0)
#define dg_dynarr_get(a, idx) \
(dg__dynarr_checkidx((a),(idx)), (a).p[dg__dynarr_idx((a).md, (idx))])
// get pointer to element at index idx (like &a.p[idx]), but with checks
// (unless you disabled them with #define DG_DYNARR_INDEX_CHECK_LEVEL 0)
// if index-checks are disabled, it returns NULL on invalid index (else it asserts() before returning)
#define dg_dynarr_getptr(a, idx) \
(dg__dynarr_checkidx((a),(idx)), \
((size_t)(idx) < (a).md.cnt) ? ((a).p+(size_t)(idx)) : NULL)
// returns a pointer to the first element of the array
// (together with dg_dynarr_end() you can do C++-style iterating)
#define dg_dynarr_begin(a) \
((a).p)
// returns a pointer to the past-the-end element of the array
// Allows C++-style iterating, in case you're into that kind of thing:
// for(T *it=dg_dynarr_begin(a), *end=dg_dynarr_end(a); it!=end; ++it) foo(*it);
// (see dg_dynarr_lastptr() to get a pointer *to* the last element)
#define dg_dynarr_end(a) \
((a).p + (a).md.cnt)
// returns (logical) number of elements currently in the array
#define dg_dynarr_count(a) \
((a).md.cnt)
// get the current reserved capacity of the array
#define dg_dynarr_capacity(a) \
((a).md.cap & DG__DYNARR_SIZE_T_ALL_BUT_MSB)
// returns 1 if the array is empty, else 0
#define dg_dynarr_empty(a) \
((a).md.cnt == 0)
// returns 1 if the last (re)allocation when inserting failed (Out Of Memory)
// or if the array has never allocated any memory yet, else 0
// deleting the contents when growing fails instead of keeping old may seem
// a bit uncool, but it's simple and OOM should rarely happen on modern systems
// anyway - after all you need to deplete both RAM and swap/pagefile.sys
// or deplete the address space, which /might/ happen with 32bit applications
// but probably not with 64bit (at least in the foreseeable future)
#define dg_dynarr_oom(a) \
((a).md.cap == 0)
// sort a using the given qsort()-comparator cmp
// (just a slim wrapper around qsort())
#define dg_dynarr_sort(a, cmp) \
qsort((a).p, (a).md.cnt, sizeof((a).p[0]), (cmp))
// ######### Implementation-Details that are not part of the API ##########
#include <stdlib.h> // size_t, malloc(), free(), realloc()
#include <string.h> // memset(), memcpy(), memmove()
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
size_t cnt; // logical number of elements
size_t cap; // cap & DG__DYNARR_SIZE_T_ALL_BUT_MSB is actual capacity (in elements, *not* bytes!)
// if(cap & DG__DYNARR_SIZE_T_MSB) the current memory is not allocated by dg_dynarr,
// but was set with dg_dynarr_init_external()
// that's handy to give an array a base-element storage on the stack, for example
// TODO: alternatively, we could introduce a flag field to this struct and use that,
// so we don't have to calculate & everytime cap is needed
} dg__dynarr_md;
// I used to have the following in an enum, but MSVC assumes enums are always 32bit ints
static const size_t DG__DYNARR_SIZE_T_MSB = ((size_t)1) << (sizeof(size_t)*8 - 1);
static const size_t DG__DYNARR_SIZE_T_ALL_BUT_MSB = (((size_t)1) << (sizeof(size_t)*8 - 1))-1;
// "unpack" the elements of an array struct for use with helper functions
// (to void** arr, dg__dynarr_md* md, size_t itemsize)
#define dg__dynarr_unp(a) \
(void**)&(a).p, &(a).md, sizeof((a).p[0])
// MSVC warns about "conditional expression is constant" when using the
// do { ... } while(0) idiom in macros..
#ifdef _MSC_VER
#if _MSC_VER >= 1400 // MSVC 2005 and newer
// people claim MSVC 2005 and newer support __pragma, even though it's only documented
// for 2008+ (https://msdn.microsoft.com/en-us/library/d9x1s805%28v=vs.90%29.aspx)
// the following workaround is based on
// http://cnicholson.net/2009/03/stupid-c-tricks-dowhile0-and-c4127/
#define DG__DYNARR_WHILE0 \
__pragma(warning(push)) \
__pragma(warning(disable:4127)) \
while(0) \
__pragma(warning(pop))
#else // older MSVC versions don't support __pragma - I heard this helps for them
#define DG__DYNARR_WHILE0 while(0,0)
#endif
#else // other compilers
#define DG__DYNARR_WHILE0 while(0)
#endif // _MSC_VER
#if (DG_DYNARR_INDEX_CHECK_LEVEL == 2) || (DG_DYNARR_INDEX_CHECK_LEVEL == 3)
#define dg__dynarr_checkidx(a,i) \
DG_DYNARR_ASSERT((size_t)i < a.md.cnt, "index out of bounds!")
// special case for insert operations: == cnt is also ok, insert will append then
#define dg__dynarr_checkidxle(a,i) \
DG_DYNARR_ASSERT((size_t)i <= a.md.cnt, "index out of bounds!")
#define dg__dynarr_check_notempty(a, msg) \
DG_DYNARR_ASSERT(a.md.cnt > 0, msg)
#elif (DG_DYNARR_INDEX_CHECK_LEVEL == 0) || (DG_DYNARR_INDEX_CHECK_LEVEL == 1)
// no assertions that check if index is valid
#define dg__dynarr_checkidx(a,i) (void)0
#define dg__dynarr_checkidxle(a,i) (void)0
#define dg__dynarr_check_notempty(a, msg) (void)0
#else // invalid DG_DYNARR_INDEX_CHECK_LEVEL
#error Invalid index check level DG_DYNARR_INDEX_CHECK_LEVEL (must be 0-3) !
#endif // DG_DYNARR_INDEX_CHECK_LEVEL
#if (DG_DYNARR_INDEX_CHECK_LEVEL == 1) || (DG_DYNARR_INDEX_CHECK_LEVEL == 3)
// the given index, if valid, else 0
#define dg__dynarr_idx(md,i) \
(((size_t)(i) < md.cnt) ? (size_t)(i) : 0)
#elif (DG_DYNARR_INDEX_CHECK_LEVEL == 0) || (DG_DYNARR_INDEX_CHECK_LEVEL == 2)
// don't check and default to 0 if invalid, but just use the given value
#define dg__dynarr_idx(md,i) (size_t)(i)
#else // invalid DG_DYNARR_INDEX_CHECK_LEVEL
#error Invalid index check level DG_DYNARR_INDEX_CHECK_LEVEL (must be 0-3) !
#endif // DG_DYNARR_INDEX_CHECK_LEVEL
// the functions allocating/freeing memory are not implemented inline, but
// in the #ifdef DG_DYNARR_IMPLEMENTATION section
// one reason is that dg__dynarr_grow has the most code in it, the other is
// that windows has weird per-dll heaps so free() or realloc() should be
// called from code in the same dll that allocated the memory - these kind
// of wrapper functions that end up compiled into the exe or *one* dll
// (instead of inline functions compiled into everything) should ensure that.
DG_DYNARR_DEF void
dg__dynarr_free(void** p, dg__dynarr_md* md);
DG_DYNARR_DEF void
dg__dynarr_shrink_to_fit(void** arr, dg__dynarr_md* md, size_t itemsize);
// grow array to have enough space for at least min_needed elements
// if it fails (OOM), the array will be deleted, a.p will be NULL, a.md.cap and a.md.cnt will be 0
// and the functions returns 0; else (on success) it returns 1
DG_DYNARR_DEF int
dg__dynarr_grow(void** arr, dg__dynarr_md* md, size_t itemsize, size_t min_needed);
// the following functions are implemented inline, because they're quite short
// and mosty implemented in functions so the macros don't get too ugly
DG_DYNARR_INLINE void
dg__dynarr_init(void** p, dg__dynarr_md* md, void* buf, size_t buf_cap)
{
*p = buf;
md->cnt = 0;
if(buf == NULL) md->cap = 0;
else md->cap = (DG__DYNARR_SIZE_T_MSB | buf_cap);
}
DG_DYNARR_INLINE int
dg__dynarr_maybegrow(void** arr, dg__dynarr_md* md, size_t itemsize, size_t min_needed)
{
if((md->cap & DG__DYNARR_SIZE_T_ALL_BUT_MSB) >= min_needed) return 1;
else return dg__dynarr_grow(arr, md, itemsize, min_needed);
}
DG_DYNARR_INLINE int
dg__dynarr_maybegrowadd(void** arr, dg__dynarr_md* md, size_t itemsize, size_t num_add)
{
size_t min_needed = md->cnt+num_add;
if((md->cap & DG__DYNARR_SIZE_T_ALL_BUT_MSB) >= min_needed) return 1;
else return dg__dynarr_grow(arr, md, itemsize, min_needed);
}
DG_DYNARR_INLINE int
dg__dynarr_insert(void** arr, dg__dynarr_md* md, size_t itemsize, size_t idx, size_t n, int init0)
{
// allow idx == md->cnt to append
size_t oldCount = md->cnt;
size_t newCount = oldCount+n;
if(idx <= oldCount && dg__dynarr_maybegrow(arr, md, itemsize, newCount))
{
unsigned char* p = (unsigned char*)*arr; // *arr might have changed in dg__dynarr_grow()!
// move all existing items after a[idx] to a[idx+n]
if(idx < oldCount) memmove(p+(idx+n)*itemsize, p+idx*itemsize, itemsize*(oldCount - idx));
// if the memory is supposed to be zeroed, do that
if(init0) memset(p+idx*itemsize, 0, n*itemsize);
md->cnt = newCount;
return 1;
}
return 0;
}
DG_DYNARR_INLINE int
dg__dynarr_add(void** arr, dg__dynarr_md* md, size_t itemsize, size_t n, int init0)
{
size_t cnt = md->cnt;
if(dg__dynarr_maybegrow(arr, md, itemsize, cnt+n))
{
unsigned char* p = (unsigned char*)*arr; // *arr might have changed in dg__dynarr_grow()!
// if the memory is supposed to be zeroed, do that
if(init0) memset(p+cnt*itemsize, 0, n*itemsize);
md->cnt += n;
return 1;
}
return 0;
}
DG_DYNARR_INLINE void
dg__dynarr_delete(void** arr, dg__dynarr_md* md, size_t itemsize, size_t idx, size_t n)
{
size_t cnt = md->cnt;
if(idx < cnt)
{
if(idx+n >= cnt) md->cnt = idx; // removing last element(s) => just reduce count
else
{
unsigned char* p = (unsigned char*)*arr;
// move all items following a[idx+n] to a[idx]
memmove(p+itemsize*idx, p+itemsize*(idx+n), itemsize*(cnt - (idx+n)));
md->cnt -= n;
}
}
}
DG_DYNARR_INLINE void
dg__dynarr_deletefast(void** arr, dg__dynarr_md* md, size_t itemsize, size_t idx, size_t n)
{
size_t cnt = md->cnt;
if(idx < cnt)
{
if(idx+n >= cnt) md->cnt = idx; // removing last element(s) => just reduce count
else
{
unsigned char* p = (unsigned char*)*arr;
// copy the last n items to a[idx] - but handle the case that
// the array has less than n elements left after the deleted elements
size_t numItemsAfterDeleted = cnt - (idx+n);
size_t m = (n < numItemsAfterDeleted) ? n : numItemsAfterDeleted;
memcpy(p+itemsize*idx, p+itemsize*(cnt - m), itemsize*m);
md->cnt -= n;
}
}
}
#ifdef __cplusplus
} // extern "C"
#endif
#endif // DG__DYNARR_H
// ############## Implementation of non-inline functions ##############
#ifdef DG_DYNARR_IMPLEMENTATION
// by default, C's malloc(), realloc() and free() is used to allocate/free heap memory.
// you can #define DG_DYNARR_MALLOC, DG_DYNARR_REALLOC and DG_DYNARR_FREE
// to provide alternative implementations like Win32 Heap(Re)Alloc/HeapFree
//
#ifndef DG_DYNARR_MALLOC
#define DG_DYNARR_MALLOC(elemSize, numElems) malloc(elemSize*numElems)
// oldNumElems is not used here, but maybe you need it for your allocator
// to copy the old elements over
#define DG_DYNARR_REALLOC(ptr, elemSize, oldNumElems, newCapacity) \
realloc(ptr, elemSize*newCapacity);
#define DG_DYNARR_FREE(ptr) free(ptr)
#endif
// you can #define DG_DYNARR_OUT_OF_MEMORY to some code that will be executed
// if allocating memory fails
#ifndef DG_DYNARR_OUT_OF_MEMORY
#define DG_DYNARR_OUT_OF_MEMORY DG_DYNARR_ASSERT(0, "Out of Memory!");
#endif
#ifdef __cplusplus
extern "C" {
#endif
DG_DYNARR_DEF void
dg__dynarr_free(void** p, dg__dynarr_md* md)
{
// only free memory if it doesn't point to external memory
if(!(md->cap & DG__DYNARR_SIZE_T_MSB))
{
DG_DYNARR_FREE(*p);
*p = NULL;
md->cap = 0;
}
md->cnt = 0;
}
DG_DYNARR_DEF int
dg__dynarr_grow(void** arr, dg__dynarr_md* md, size_t itemsize, size_t min_needed)
{
size_t cap = md->cap & DG__DYNARR_SIZE_T_ALL_BUT_MSB;
DG_DYNARR_ASSERT(min_needed > cap, "dg__dynarr_grow() should only be called if storage actually needs to grow!");
if(min_needed < DG__DYNARR_SIZE_T_MSB)
{
size_t newcap = (cap > 4) ? (2*cap) : 8; // allocate for at least 8 elements
// make sure not to set DG__DYNARR_SIZE_T_MSB (unlikely anyway)
if(newcap >= DG__DYNARR_SIZE_T_MSB) newcap = DG__DYNARR_SIZE_T_MSB-1;
if(min_needed > newcap) newcap = min_needed;
// the memory was allocated externally, don't free it, just copy contents
if(md->cap & DG__DYNARR_SIZE_T_MSB)
{
void* p = DG_DYNARR_MALLOC(itemsize, newcap);
if(p != NULL) memcpy(p, *arr, itemsize*md->cnt);
*arr = p;
}
else
{
void* p = DG_DYNARR_REALLOC(*arr, itemsize, md->cnt, newcap);
if(p == NULL) DG_DYNARR_FREE(*arr); // realloc failed, at least don't leak memory
*arr = p;
}
// TODO: handle OOM by setting highest bit of count and keeping old data?
if(*arr) md->cap = newcap;
else
{
md->cap = 0;
md->cnt = 0;
DG_DYNARR_OUT_OF_MEMORY ;
return 0;
}
return 1;
}
DG_DYNARR_ASSERT(min_needed < DG__DYNARR_SIZE_T_MSB, "Arrays must stay below SIZE_T_MAX/2 elements!");
return 0;
}
DG_DYNARR_DEF void
dg__dynarr_shrink_to_fit(void** arr, dg__dynarr_md* md, size_t itemsize)
{
// only do this if we allocated the memory ourselves
if(!(md->cap & DG__DYNARR_SIZE_T_MSB))
{
size_t cnt = md->cnt;
if(cnt == 0) dg__dynarr_free(arr, md);
else if((md->cap & DG__DYNARR_SIZE_T_ALL_BUT_MSB) > cnt)
{
void* p = DG_DYNARR_MALLOC(itemsize, cnt);
if(p != NULL)
{
memcpy(p, *arr, cnt*itemsize);
md->cap = cnt;
DG_DYNARR_FREE(*arr);
*arr = p;
}
}
}
}
#ifdef __cplusplus
} // extern "C"
#endif
#endif // DG_DYNARR_IMPLEMENTATION

14
src/client/refresh/gl3/header/local.h
View file

@ -181,6 +181,7 @@ typedef struct
GLuint currentVAO;
GLuint currentVBO;
GLuint currentEBO;
GLuint currentShaderProgram;
GLuint currentUBO;
@ -205,7 +206,7 @@ typedef struct
gl3ShaderInfo_t siParticle; // for particles. surprising, right?
GLuint vao3D, vbo3D; // for brushes etc, using 7 floats as vertex input (x,y,z, s,t, lms,lmt)
GLuint vaoAlias, vboAlias; // for models, using 9 floats as (x,y,z, s,t, r,g,b,a)
GLuint vaoAlias, vboAlias, eboAlias; // for models, using 9 floats as (x,y,z, s,t, r,g,b,a)
GLuint vaoParticle, vboParticle; // for particles, using 9 floats (x,y,z, size,distance, r,g,b,a)
// UBOs and their data
@ -338,6 +339,16 @@ GL3_BindVBO(GLuint vbo)
}
}
static inline void
GL3_BindEBO(GLuint ebo)
{
if(ebo != gl3state.currentEBO)
{
gl3state.currentEBO = ebo;
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
}
}
extern qboolean GL3_CullBox(vec3_t mins, vec3_t maxs);
extern void GL3_RotateForEntity(entity_t *e);
@ -446,6 +457,7 @@ extern void GL3_MarkLeaves(void);
// gl3_mesh.c
extern void GL3_DrawAliasModel(entity_t *e);
extern void GL3_ShutdownMeshes(void);
// gl3_shaders.c