--- /dev/null
+// This file renders vertex buffers, converts raw meshes
+// to GL meshes, and manages threads that do the raw-mesh
+// building (found in cave_mesher.c)
+
+
+#include "stb_voxel_render.h"
+
+#define STB_GLEXT_DECLARE "glext_list.h"
+#include "stb_gl.h"
+#include "stb_image.h"
+#include "stb_glprog.h"
+
+#include "caveview.h"
+#include "cave_parse.h"
+#include "stb.h"
+#include "sdl.h"
+#include "sdl_thread.h"
+#include <math.h>
+#include <assert.h>
+
+//#define STBVOX_CONFIG_TEX1_EDGE_CLAMP
+
+
+// currently no dynamic way to set mesh cache size or view distance
+//#define SHORTVIEW
+
+
+stbvox_mesh_maker g_mesh_maker;
+
+GLuint main_prog;
+GLint uniform_locations[64];
+
+//#define MAX_QUADS_PER_DRAW (65536 / 4) // assuming 16-bit indices, 4 verts per quad
+//#define FIXED_INDEX_BUFFER_SIZE (MAX_QUADS_PER_DRAW * 6 * 2) // 16*1024 * 12 == ~192KB
+
+// while uploading texture data, this holds our each texture
+#define TEX_SIZE 64
+uint32 texture[TEX_SIZE][TEX_SIZE];
+
+GLuint voxel_tex[2];
+
+// chunk state
+enum
+{
+ STATE_invalid,
+ STATE_needed,
+ STATE_requested,
+ STATE_abandoned,
+ STATE_valid,
+};
+
+// mesh is 32x32x255 ... this is hardcoded in that
+// a mesh covers 2x2 minecraft chunks, no #defines for it
+typedef struct
+{
+ int state;
+ int chunk_x, chunk_y;
+ int num_quads;
+ float priority;
+ int vbuf_size, fbuf_size;
+
+ float transform[3][3];
+ float bounds[2][3];
+
+ GLuint vbuf;// vbuf_tex;
+ GLuint fbuf, fbuf_tex;
+
+} chunk_mesh;
+
+void scale_texture(unsigned char *src, int x, int y, int w, int h)
+{
+ int i,j,k;
+ assert(w == 256 && h == 256);
+ for (j=0; j < TEX_SIZE; ++j) {
+ for (i=0; i < TEX_SIZE; ++i) {
+ uint32 val=0;
+ for (k=0; k < 4; ++k) {
+ val >>= 8;
+ val += src[ 4*(x+(i>>2)) + 4*w*(y+(j>>2)) + k]<<24;
+ }
+ texture[j][i] = val;
+ }
+ }
+}
+
+void build_base_texture(int n)
+{
+ int x,y;
+ uint32 color = stb_rand() | 0x808080;
+ for (y=0; y<TEX_SIZE; ++y)
+ for (x=0; x<TEX_SIZE; ++x) {
+ texture[y][x] = (color + (stb_rand()&0x1f1f1f))|0xff000000;
+ }
+}
+
+void build_overlay_texture(int n)
+{
+ int x,y;
+ uint32 color = stb_rand();
+ if (color & 16)
+ color = 0xff000000;
+ else
+ color = 0xffffffff;
+ for (y=0; y<TEX_SIZE; ++y)
+ for (x=0; x<TEX_SIZE; ++x) {
+ texture[y][x] = 0;
+ }
+
+ for (y=0; y < TEX_SIZE/8; ++y) {
+ for (x=0; x < TEX_SIZE; ++x) {
+ texture[y][x] = color;
+ texture[TEX_SIZE-1-y][x] = color;
+ texture[x][y] = color;
+ texture[x][TEX_SIZE-1-y] = color;
+ }
+ }
+}
+
+// view radius of about 1024 = 2048 columns / 32 columns-per-mesh = 2^11 / 2^5 = 64x64
+// so we need bigger than 64x64 so we can precache, which means we have to be
+// non-power-of-two, or we have to be pretty huge
+#define CACHED_MESH_NUM_X 128
+#define CACHED_MESH_NUM_Y 128
+
+
+chunk_mesh cached_chunk_mesh[CACHED_MESH_NUM_Y][CACHED_MESH_NUM_X];
+
+void free_chunk(int slot_x, int slot_y)
+{
+ chunk_mesh *cm = &cached_chunk_mesh[slot_y][slot_x];
+ if (cm->state == STATE_valid) {
+ glDeleteTextures(1, &cm->fbuf_tex);
+ glDeleteBuffersARB(1, &cm->vbuf);
+ glDeleteBuffersARB(1, &cm->fbuf);
+ cached_chunk_mesh[slot_y][slot_x].state = STATE_invalid;
+ }
+}
+
+void upload_mesh(chunk_mesh *cm, uint8 *build_buffer, uint8 *face_buffer)
+{
+ glGenBuffersARB(1, &cm->vbuf);
+ glBindBufferARB(GL_ARRAY_BUFFER_ARB, cm->vbuf);
+ glBufferDataARB(GL_ARRAY_BUFFER_ARB, cm->num_quads*4*sizeof(uint32), build_buffer, GL_STATIC_DRAW_ARB);
+ glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
+
+ glGenBuffersARB(1, &cm->fbuf);
+ glBindBufferARB(GL_TEXTURE_BUFFER_ARB, cm->fbuf);
+ glBufferDataARB(GL_TEXTURE_BUFFER_ARB, cm->num_quads*sizeof(uint32), face_buffer , GL_STATIC_DRAW_ARB);
+ glBindBufferARB(GL_TEXTURE_BUFFER_ARB, 0);
+
+ glGenTextures(1, &cm->fbuf_tex);
+ glBindTexture(GL_TEXTURE_BUFFER_ARB, cm->fbuf_tex);
+ glTexBufferARB(GL_TEXTURE_BUFFER_ARB, GL_RGBA8UI, cm->fbuf);
+ glBindTexture(GL_TEXTURE_BUFFER_ARB, 0);
+}
+
+static void upload_mesh_data(raw_mesh *rm)
+{
+ int cx = rm->cx;
+ int cy = rm->cy;
+ int slot_x = (cx >> 1) & (CACHED_MESH_NUM_X-1);
+ int slot_y = (cy >> 1) & (CACHED_MESH_NUM_Y-1);
+ chunk_mesh *cm;
+
+ free_chunk(slot_x, slot_y);
+
+ cm = &cached_chunk_mesh[slot_y][slot_x];
+ cm->num_quads = rm->num_quads;
+
+ upload_mesh(cm, rm->build_buffer, rm->face_buffer);
+ cm->vbuf_size = rm->num_quads*4*sizeof(uint32);
+ cm->fbuf_size = rm->num_quads*sizeof(uint32);
+ cm->priority = 100000;
+ cm->chunk_x = cx;
+ cm->chunk_y = cy;
+
+ memcpy(cm->bounds, rm->bounds, sizeof(cm->bounds));
+ memcpy(cm->transform, rm->transform, sizeof(cm->transform));
+
+ // write barrier here
+ cm->state = STATE_valid;
+}
+
+GLint uniform_loc[16];
+float table3[128][3];
+float table4[64][4];
+GLint tablei[2];
+
+float step=0;
+
+#ifdef SHORTVIEW
+int view_dist_in_chunks = 50;
+#else
+int view_dist_in_chunks = 80;
+#endif
+
+void setup_uniforms(float pos[3])
+{
+ int i,j;
+ step += 1.0f/60.0f;
+ for (i=0; i < STBVOX_UNIFORM_count; ++i) {
+ stbvox_uniform_info raw, *ui=&raw;
+ stbvox_get_uniform_info(&raw, i);
+ uniform_loc[i] = -1;
+
+ if (i == STBVOX_UNIFORM_texscale || i == STBVOX_UNIFORM_texgen || i == STBVOX_UNIFORM_color_table)
+ continue;
+
+ if (ui) {
+ void *data = ui->default_value;
+ uniform_loc[i] = stbgl_find_uniform(main_prog, ui->name);
+ switch (i) {
+ case STBVOX_UNIFORM_face_data:
+ tablei[0] = 2;
+ data = tablei;
+ break;
+
+ case STBVOX_UNIFORM_tex_array:
+ glActiveTextureARB(GL_TEXTURE0_ARB);
+ glBindTexture(GL_TEXTURE_2D_ARRAY_EXT, voxel_tex[0]);
+ glActiveTextureARB(GL_TEXTURE1_ARB);
+ glBindTexture(GL_TEXTURE_2D_ARRAY_EXT, voxel_tex[1]);
+ glActiveTextureARB(GL_TEXTURE0_ARB);
+ tablei[0] = 0;
+ tablei[1] = 1;
+ data = tablei;
+ break;
+
+ case STBVOX_UNIFORM_color_table:
+ data = ui->default_value;
+ ((float *)data)[63*4+3] = 2.0f; // emissive
+ break;
+
+ case STBVOX_UNIFORM_camera_pos:
+ data = table3[0];
+ table3[0][0] = pos[0];
+ table3[0][1] = pos[1];
+ table3[0][2] = pos[2];
+ table3[0][3] = stb_max(0,(float)sin(step*2)*0.125f);
+ break;
+
+ case STBVOX_UNIFORM_ambient: {
+ float bright = 1.0;
+ //float bright = 0.75;
+ float amb[3][3];
+
+ // ambient direction is sky-colored upwards
+ // "ambient" lighting is from above
+ table4[0][0] = 0.3f;
+ table4[0][1] = -0.5f;
+ table4[0][2] = 0.9f;
+
+ amb[1][0] = 0.3f; amb[1][1] = 0.3f; amb[1][2] = 0.3f; // dark-grey
+ amb[2][0] = 1.0; amb[2][1] = 1.0; amb[2][2] = 1.0; // white
+
+ // convert so (table[1]*dot+table[2]) gives
+ // above interpolation
+ // lerp((dot+1)/2, amb[1], amb[2])
+ // amb[1] + (amb[2] - amb[1]) * (dot+1)/2
+ // amb[1] + (amb[2] - amb[1]) * dot/2 + (amb[2]-amb[1])/2
+
+ for (j=0; j < 3; ++j) {
+ table4[1][j] = (amb[2][j] - amb[1][j])/2 * bright;
+ table4[2][j] = (amb[1][j] + amb[2][j])/2 * bright;
+ }
+
+ // fog color
+ table4[3][0] = 0.6f, table4[3][1] = 0.7f, table4[3][2] = 0.9f;
+ table4[3][3] = 1.0f / (view_dist_in_chunks * 16);
+ table4[3][3] *= table4[3][3];
+
+ data = table4;
+ break;
+ }
+ }
+
+ switch (ui->type) {
+ case STBVOX_UNIFORM_TYPE_sampler: stbglUniform1iv(uniform_loc[i], ui->array_length, data); break;
+ case STBVOX_UNIFORM_TYPE_vec2: stbglUniform2fv(uniform_loc[i], ui->array_length, data); break;
+ case STBVOX_UNIFORM_TYPE_vec3: stbglUniform3fv(uniform_loc[i], ui->array_length, data); break;
+ case STBVOX_UNIFORM_TYPE_vec4: stbglUniform4fv(uniform_loc[i], ui->array_length, data); break;
+ }
+ }
+ }
+}
+
+GLuint unitex[64], unibuf[64];
+void make_texture_buffer_for_uniform(int uniform, int slot)
+{
+ GLenum type;
+ stbvox_uniform_info raw, *ui=&raw;
+ GLint uloc;
+
+ stbvox_get_uniform_info(ui, uniform);
+ uloc = stbgl_find_uniform(main_prog, ui->name);
+
+ if (uniform == STBVOX_UNIFORM_color_table)
+ ((float *)ui->default_value)[63*4+3] = 2.0f; // emissive
+
+ glGenBuffersARB(1, &unibuf[uniform]);
+ glBindBufferARB(GL_ARRAY_BUFFER_ARB, unibuf[uniform]);
+ glBufferDataARB(GL_ARRAY_BUFFER_ARB, ui->array_length * ui->bytes_per_element, ui->default_value, GL_STATIC_DRAW_ARB);
+ glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
+
+ glGenTextures(1, &unitex[uniform]);
+ glBindTexture(GL_TEXTURE_BUFFER_ARB, unitex[uniform]);
+ switch (ui->type) {
+ case STBVOX_UNIFORM_TYPE_vec2: type = GL_RG32F; break;
+ case STBVOX_UNIFORM_TYPE_vec3: type = GL_RGB32F; break;
+ case STBVOX_UNIFORM_TYPE_vec4: type = GL_RGBA32F; break;
+ default: assert(0);
+ }
+ glTexBufferARB(GL_TEXTURE_BUFFER_ARB, type, unibuf[uniform]);
+ glBindTexture(GL_TEXTURE_BUFFER_ARB, 0);
+
+ glActiveTextureARB(GL_TEXTURE0 + slot);
+ glBindTexture(GL_TEXTURE_BUFFER_ARB, unitex[uniform]);
+ glActiveTextureARB(GL_TEXTURE0);
+
+ stbglUseProgram(main_prog);
+ stbglUniform1i(uloc, slot);
+}
+
+#define MAX_MESH_WORKERS 8
+#define MAX_CHUNK_LOAD_WORKERS 2
+
+int num_mesh_workers;
+int num_chunk_load_workers;
+
+typedef struct
+{
+ int state;
+ int request_cx;
+ int request_cy;
+ int padding[13];
+
+ SDL_sem * request_received;
+
+ SDL_sem * chunk_server_done_processing;
+ int chunk_action;
+ int chunk_request_x;
+ int chunk_request_y;
+ fast_chunk *chunks[4][4];
+
+ int padding2[16];
+ raw_mesh rm;
+ int padding3[16];
+
+ uint8 *build_buffer;
+ uint8 *face_buffer ;
+} mesh_worker;
+
+enum
+{
+ WSTATE_idle,
+ WSTATE_requested,
+ WSTATE_running,
+ WSTATE_mesh_ready,
+};
+
+mesh_worker mesh_data[MAX_MESH_WORKERS];
+int num_meshes_started; // stats
+
+int request_chunk(int chunk_x, int chunk_y);
+void update_meshes_from_render_thread(void);
+
+unsigned char tex2_data[64][4];
+
+void init_tex2_gradient(void)
+{
+ int i;
+ for (i=0; i < 16; ++i) {
+ tex2_data[i+ 0][0] = 64 + 12*i;
+ tex2_data[i+ 0][1] = 32;
+ tex2_data[i+ 0][2] = 64;
+
+ tex2_data[i+16][0] = 255;
+ tex2_data[i+16][1] = 32 + 8*i;
+ tex2_data[i+16][2] = 64;
+
+ tex2_data[i+32][0] = 255;
+ tex2_data[i+32][1] = 160;
+ tex2_data[i+32][2] = 64 + 12*i;
+
+ tex2_data[i+48][0] = 255;
+ tex2_data[i+48][1] = 160 + 6*i;
+ tex2_data[i+48][2] = 255;
+ }
+}
+
+void set_tex2_alpha(float fa)
+{
+ int i;
+ int a = (int) stb_lerp(fa, 0, 255);
+ if (a < 0) a = 0; else if (a > 255) a = 255;
+ glBindTexture(GL_TEXTURE_2D_ARRAY_EXT, voxel_tex[1]);
+ for (i=0; i < 64; ++i) {
+ tex2_data[i][3] = a;
+ glTexSubImage3DEXT(GL_TEXTURE_2D_ARRAY_EXT, 0, 0,0,i, 1,1,1, GL_RGBA, GL_UNSIGNED_BYTE, tex2_data[i]);
+ }
+}
+
+void render_init(void)
+{
+ int i;
+ char *binds[] = { "attr_vertex", "attr_face", NULL };
+ char *vertex;
+ char *fragment;
+ int w=0,h=0;
+
+ unsigned char *texdata = stbi_load("terrain.png", &w, &h, NULL, 4);
+
+ stbvox_init_mesh_maker(&g_mesh_maker);
+ for (i=0; i < num_mesh_workers; ++i) {
+ stbvox_init_mesh_maker(&mesh_data[i].rm.mm);
+ }
+
+ vertex = stbvox_get_vertex_shader();
+ fragment = stbvox_get_fragment_shader();
+
+ {
+ char error_buffer[1024];
+ char *main_vertex[] = { vertex, NULL };
+ char *main_fragment[] = { fragment, NULL };
+ main_prog = stbgl_create_program(main_vertex, main_fragment, binds, error_buffer, sizeof(error_buffer));
+ if (main_prog == 0) {
+ ods("Compile error for main shader: %s\n", error_buffer);
+ assert(0);
+ exit(1);
+ }
+ }
+ //init_index_buffer();
+
+ make_texture_buffer_for_uniform(STBVOX_UNIFORM_texscale , 3);
+ make_texture_buffer_for_uniform(STBVOX_UNIFORM_texgen , 4);
+ make_texture_buffer_for_uniform(STBVOX_UNIFORM_color_table , 5);
+
+ glGenTextures(2, voxel_tex);
+
+ glBindTexture(GL_TEXTURE_2D_ARRAY_EXT, voxel_tex[0]);
+ glTexImage3DEXT(GL_TEXTURE_2D_ARRAY_EXT, 0, GL_RGBA,
+ TEX_SIZE,TEX_SIZE,256,
+ 0,GL_RGBA,GL_UNSIGNED_BYTE,NULL);
+ for (i=0; i < 256; ++i) {
+ if (texdata)
+ scale_texture(texdata, (i&15)*w/16, (h/16)*(i>>4), w,h);
+ else
+ build_base_texture(i);
+ glTexSubImage3DEXT(GL_TEXTURE_2D_ARRAY_EXT, 0, 0,0,i, TEX_SIZE,TEX_SIZE,1, GL_RGBA, GL_UNSIGNED_BYTE, texture[0]);
+ }
+ glTexParameteri(GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MAX_ANISOTROPY_EXT, 16);
+ #ifdef STBVOX_CONFIG_TEX1_EDGE_CLAMP
+ glTexParameteri(GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+ glTexParameteri(GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+ #endif
+
+ glGenerateMipmapEXT(GL_TEXTURE_2D_ARRAY_EXT);
+
+ glBindTexture(GL_TEXTURE_2D_ARRAY_EXT, voxel_tex[1]);
+ glTexImage3DEXT(GL_TEXTURE_2D_ARRAY_EXT, 0, GL_RGBA,
+ 1,1,64,
+ 0,GL_RGBA,GL_UNSIGNED_BYTE,NULL);
+ init_tex2_gradient();
+ set_tex2_alpha(0.0);
+ #if 0
+ for (i=0; i < 128; ++i) {
+ //build_overlay_texture(i);
+ glTexSubImage3DEXT(GL_TEXTURE_2D_ARRAY_EXT, 0, 0,0,i, TEX_SIZE,TEX_SIZE,1, GL_RGBA, GL_UNSIGNED_BYTE, texture[0]);
+ }
+ #endif
+ glTexParameteri(GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D_ARRAY_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ glGenerateMipmapEXT(GL_TEXTURE_2D_ARRAY_EXT);
+}
+
+void world_init(void)
+{
+ int a,b,x,y;
+
+ Uint64 start_time, end_time;
+ #ifdef NDEBUG
+ int range = 32;
+ #else
+ int range = 12;
+ #endif
+
+ start_time = SDL_GetPerformanceCounter();
+
+ // iterate in 8x8 clusters of qchunks at a time to get better converted-chunk-cache reuse
+ // than a purely row-by-row ordering is (single-threaded this is a bigger win than
+ // any of the above optimizations were, since it halves zlib/mc-conversion costs)
+ for (x=-range; x <= range; x += 16)
+ for (y=-range; y <= range; y += 16)
+ for (b=y; b < y+16 && b <= range; b += 2)
+ for (a=x; a < x+16 && a <= range; a += 2)
+ while (!request_chunk(a, b)) { // if request fails, all threads are busy
+ update_meshes_from_render_thread();
+ SDL_Delay(1);
+ }
+
+ // wait until all the workers are done,
+ // (this is only needed if we want to time
+ // when the build finishes, or when we want to reset the
+ // cache size; otherwise we could just go ahead and
+ // start rendering whatever we've got)
+ for(;;) {
+ int i;
+ update_meshes_from_render_thread();
+ for (i=0; i < num_mesh_workers; ++i)
+ if (mesh_data[i].state != WSTATE_idle)
+ break;
+ if (i == num_mesh_workers)
+ break;
+ SDL_Delay(3);
+ }
+
+ end_time = SDL_GetPerformanceCounter();
+ ods("Build time: %7.2fs\n", (end_time - start_time) / (float) SDL_GetPerformanceFrequency());
+
+ // don't waste lots of storage on chunk caches once it's finished starting-up;
+ // this was only needed to be this large because we worked in large blocks
+ // to maximize sharing
+ reset_cache_size(32);
+}
+
+extern SDL_mutex * chunk_cache_mutex;
+
+int mesh_worker_handler(void *data)
+{
+ mesh_worker *mw = data;
+ mw->face_buffer = malloc(FACE_BUFFER_SIZE);
+ mw->build_buffer = malloc(BUILD_BUFFER_SIZE);
+
+ // this loop only works because the compiler can't
+ // tell that the SDL_calls don't access mw->state;
+ // really we should barrier that stuff
+ for(;;) {
+ int i,j;
+ int cx,cy;
+
+ // wait for a chunk request
+ SDL_SemWait(mw->request_received);
+
+ // analyze the chunk request
+ assert(mw->state == WSTATE_requested);
+ cx = mw->request_cx;
+ cy = mw->request_cy;
+
+ // this is inaccurate as it can block while another thread has the cache locked
+ mw->state = WSTATE_running;
+
+ // get the chunks we need (this takes a lock and caches them)
+ for (j=0; j < 4; ++j)
+ for (i=0; i < 4; ++i)
+ mw->chunks[j][i] = get_converted_fastchunk(cx-1 + i, cy-1 + j);
+
+ // build the mesh based on the chunks
+ mw->rm.build_buffer = mw->build_buffer;
+ mw->rm.face_buffer = mw->face_buffer;
+ build_chunk(cx, cy, mw->chunks, &mw->rm);
+ mw->state = WSTATE_mesh_ready;
+ // don't need to notify of this, because it gets polled
+
+ // when done, free the chunks
+
+ // for efficiency we just take the mutex once around the whole thing,
+ // though this spreads the mutex logic over two files
+ SDL_LockMutex(chunk_cache_mutex);
+ for (j=0; j < 4; ++j)
+ for (i=0; i < 4; ++i) {
+ deref_fastchunk(mw->chunks[j][i]);
+ mw->chunks[j][i] = NULL;
+ }
+ SDL_UnlockMutex(chunk_cache_mutex);
+ }
+ return 0;
+}
+
+int request_chunk(int chunk_x, int chunk_y)
+{
+ int i;
+ for (i=0; i < num_mesh_workers; ++i) {
+ mesh_worker *mw = &mesh_data[i];
+ if (mw->state == WSTATE_idle) {
+ mw->request_cx = chunk_x;
+ mw->request_cy = chunk_y;
+ mw->state = WSTATE_requested;
+ SDL_SemPost(mw->request_received);
+ ++num_meshes_started;
+ return 1;
+ }
+ }
+ return 0;
+}
+
+void prepare_threads(void)
+{
+ int i;
+ int num_proc = SDL_GetCPUCount();
+
+ if (num_proc > 6)
+ num_mesh_workers = num_proc/2;
+ else if (num_proc > 4)
+ num_mesh_workers = 4;
+ else
+ num_mesh_workers = num_proc-1;
+
+// @TODO
+// Thread usage is probably pretty terrible; need to make a
+// separate queue of needed chunks, instead of just generating
+// one request per thread per frame, and a separate queue of
+// results. (E.g. If it takes 1.5 frames to build mesh, thread
+// is idle for 0.5 frames.) To fake this for now, I've just
+// doubled the number of threads to let those serve as a 'queue',
+// but that's dumb.
+
+ num_mesh_workers *= 2; // try to get better thread usage
+
+ if (num_mesh_workers > MAX_MESH_WORKERS)
+ num_mesh_workers = MAX_MESH_WORKERS;
+
+ for (i=0; i < num_mesh_workers; ++i) {
+ mesh_worker *data = &mesh_data[i];
+ data->request_received = SDL_CreateSemaphore(0);
+ data->chunk_server_done_processing = SDL_CreateSemaphore(0);
+ SDL_CreateThread(mesh_worker_handler, "mesh worker", data);
+ }
+}
+
+
+// "better" buffer uploading
+#if 0
+ if (glBufferStorage) {
+ glDeleteBuffersARB(1, &vb->vbuf);
+ glGenBuffersARB(1, &vb->vbuf);
+
+ glBindBufferARB(GL_ARRAY_BUFFER_ARB, vb->vbuf);
+ glBufferStorage(GL_ARRAY_BUFFER_ARB, sizeof(build_buffer), build_buffer, 0);
+ glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
+ } else {
+ glBindBufferARB(GL_ARRAY_BUFFER_ARB, vb->vbuf);
+ glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(build_buffer), build_buffer, GL_STATIC_DRAW_ARB);
+ glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
+ }
+#endif
+
+
+typedef struct
+{
+ float x,y,z,w;
+} plane;
+
+static plane frustum[6];
+
+static void matd_mul(double out[4][4], double src1[4][4], double src2[4][4])
+{
+ int i,j,k;
+ for (j=0; j < 4; ++j) {
+ for (i=0; i < 4; ++i) {
+ double t=0;
+ for (k=0; k < 4; ++k)
+ t += src1[k][i] * src2[j][k];
+ out[i][j] = t;
+ }
+ }
+}
+
+// https://fgiesen.wordpress.com/2012/08/31/frustum-planes-from-the-projection-matrix/
+static void compute_frustum(void)
+{
+ int i;
+ GLdouble mv[4][4],proj[4][4], mvproj[4][4];
+ glGetDoublev(GL_MODELVIEW_MATRIX , mv[0]);
+ glGetDoublev(GL_PROJECTION_MATRIX, proj[0]);
+ matd_mul(mvproj, proj, mv);
+ for (i=0; i < 4; ++i) {
+ (&frustum[0].x)[i] = (float) (mvproj[3][i] + mvproj[0][i]);
+ (&frustum[1].x)[i] = (float) (mvproj[3][i] - mvproj[0][i]);
+ (&frustum[2].x)[i] = (float) (mvproj[3][i] + mvproj[1][i]);
+ (&frustum[3].x)[i] = (float) (mvproj[3][i] - mvproj[1][i]);
+ (&frustum[4].x)[i] = (float) (mvproj[3][i] + mvproj[2][i]);
+ (&frustum[5].x)[i] = (float) (mvproj[3][i] - mvproj[2][i]);
+ }
+}
+
+static int test_plane(plane *p, float x0, float y0, float z0, float x1, float y1, float z1)
+{
+ // return false if the box is entirely behind the plane
+ float d=0;
+ assert(x0 <= x1 && y0 <= y1 && z0 <= z1);
+ if (p->x > 0) d += x1*p->x; else d += x0*p->x;
+ if (p->y > 0) d += y1*p->y; else d += y0*p->y;
+ if (p->z > 0) d += z1*p->z; else d += z0*p->z;
+ return d + p->w >= 0;
+}
+
+static int is_box_in_frustum(float *bmin, float *bmax)
+{
+ int i;
+ for (i=0; i < 6; ++i)
+ if (!test_plane(&frustum[i], bmin[0], bmin[1], bmin[2], bmax[0], bmax[1], bmax[2]))
+ return 0;
+ return 1;
+}
+
+float compute_priority(int cx, int cy, float x, float y)
+{
+ float distx, disty, dist2;
+ distx = (cx*16+8) - x;
+ disty = (cy*16+8) - y;
+ dist2 = distx*distx + disty*disty;
+ return view_dist_in_chunks*view_dist_in_chunks * 16 * 16 - dist2;
+}
+
+int chunk_locations, chunks_considered, chunks_in_frustum;
+int quads_considered, quads_rendered;
+int chunk_storage_rendered, chunk_storage_considered, chunk_storage_total;
+int update_frustum = 1;
+
+#ifdef SHORTVIEW
+int max_chunk_storage = 450 << 20;
+int min_chunk_storage = 350 << 20;
+#else
+int max_chunk_storage = 900 << 20;
+int min_chunk_storage = 800 << 20;
+#endif
+
+float min_priority = -500; // this really wants to be in unit space, not squared space
+
+int num_meshes_uploaded;
+
+void update_meshes_from_render_thread(void)
+{
+ int i;
+ for (i=0; i < num_mesh_workers; ++i) {
+ mesh_worker *mw = &mesh_data[i];
+ if (mw->state == WSTATE_mesh_ready) {
+ upload_mesh_data(&mw->rm);
+ ++num_meshes_uploaded;
+ mw->state = WSTATE_idle;
+ }
+ }
+}
+
+extern float tex2_alpha;
+extern int global_hack;
+int num_threads_active;
+float chunk_server_activity;
+
+void render_caves(float campos[3])
+{
+ float x = campos[0], y = campos[1];
+ int qchunk_x, qchunk_y;
+ int cam_x, cam_y;
+ int i,j, rad;
+
+ compute_frustum();
+
+ chunk_locations = chunks_considered = chunks_in_frustum = 0;
+ quads_considered = quads_rendered = 0;
+ chunk_storage_total = chunk_storage_considered = chunk_storage_rendered = 0;
+
+ cam_x = (int) floor(x+0.5);
+ cam_y = (int) floor(y+0.5);
+
+ qchunk_x = (((int) floor(x)+16) >> 5) << 1;
+ qchunk_y = (((int) floor(y)+16) >> 5) << 1;
+
+ glEnable(GL_ALPHA_TEST);
+ glAlphaFunc(GL_GREATER, 0.5);
+
+ stbglUseProgram(main_prog);
+ setup_uniforms(campos); // set uniforms to default values inefficiently
+ glActiveTextureARB(GL_TEXTURE2_ARB);
+ stbglEnableVertexAttribArray(0);
+
+ {
+ float lighting[2][3] = { { campos[0],campos[1],campos[2] }, { 0.75,0.75,0.65f } };
+ float bright = 8;
+ lighting[1][0] *= bright;
+ lighting[1][1] *= bright;
+ lighting[1][2] *= bright;
+ stbglUniform3fv(stbgl_find_uniform(main_prog, "light_source"), 2, lighting[0]);
+ }
+
+ if (global_hack)
+ set_tex2_alpha(tex2_alpha);
+
+ num_meshes_uploaded = 0;
+ update_meshes_from_render_thread();
+
+ // traverse all in-range chunks and analyze them
+ for (j=-view_dist_in_chunks; j <= view_dist_in_chunks; j += 2) {
+ for (i=-view_dist_in_chunks; i <= view_dist_in_chunks; i += 2) {
+ float priority;
+ int cx = qchunk_x + i;
+ int cy = qchunk_y + j;
+
+ priority = compute_priority(cx, cy, x, y);
+ if (priority >= min_priority) {
+ int slot_x = (cx>>1) & (CACHED_MESH_NUM_X-1);
+ int slot_y = (cy>>1) & (CACHED_MESH_NUM_Y-1);
+ chunk_mesh *cm = &cached_chunk_mesh[slot_y][slot_x];
+ ++chunk_locations;
+ if (cm->state == STATE_valid && priority >= 0) {
+ // check if chunk pos actually matches
+ if (cm->chunk_x != cx || cm->chunk_y != cy) {
+ // we have a stale chunk we need to recreate
+ free_chunk(slot_x, slot_y); // it probably will have already gotten freed, but just in case
+ }
+ }
+ if (cm->state == STATE_invalid) {
+ cm->chunk_x = cx;
+ cm->chunk_y = cy;
+ cm->state = STATE_needed;
+ }
+ cm->priority = priority;
+ }
+ }
+ }
+
+ // draw front-to-back
+ for (rad = 0; rad <= view_dist_in_chunks; rad += 2) {
+ for (j=-rad; j <= rad; j += 2) {
+ // if j is +- rad, then iterate i through all values
+ // if j isn't +-rad, then i should be only -rad & rad
+ int step = 2;
+ if (abs(j) != rad)
+ step = 2*rad;
+ for (i=-rad; i <= rad; i += step) {
+ int cx = qchunk_x + i;
+ int cy = qchunk_y + j;
+ int slot_x = (cx>>1) & (CACHED_MESH_NUM_X-1);
+ int slot_y = (cy>>1) & (CACHED_MESH_NUM_Y-1);
+ chunk_mesh *cm = &cached_chunk_mesh[slot_y][slot_x];
+ if (cm->state == STATE_valid && cm->priority >= 0) {
+ ++chunks_considered;
+ quads_considered += cm->num_quads;
+ if (is_box_in_frustum(cm->bounds[0], cm->bounds[1])) {
+ ++chunks_in_frustum;
+
+ // @TODO if in range
+ stbglUniform3fv(uniform_loc[STBVOX_UNIFORM_transform], 3, cm->transform[0]);
+ glBindBufferARB(GL_ARRAY_BUFFER_ARB, cm->vbuf);
+ glVertexAttribIPointer(0, 1, GL_UNSIGNED_INT, 4, (void*) 0);
+ glBindTexture(GL_TEXTURE_BUFFER_ARB, cm->fbuf_tex);
+ glDrawArrays(GL_QUADS, 0, cm->num_quads*4);
+ quads_rendered += cm->num_quads;
+
+ chunk_storage_rendered += cm->vbuf_size + cm->fbuf_size;
+ }
+ chunk_storage_considered += cm->vbuf_size + cm->fbuf_size;
+ }
+ }
+ }
+ }
+
+ stbglDisableVertexAttribArray(0);
+ glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
+ glActiveTextureARB(GL_TEXTURE0_ARB);
+
+ stbglUseProgram(0);
+ num_meshes_started = 0;
+
+ {
+ #define MAX_QUEUE 8
+ float highest_priority[MAX_QUEUE];
+ int highest_i[MAX_QUEUE], highest_j[MAX_QUEUE];
+ float lowest_priority = view_dist_in_chunks * view_dist_in_chunks * 16 * 16.0f;
+ int lowest_i = -1, lowest_j = -1;
+
+ for (i=0; i < MAX_QUEUE; ++i) {
+ highest_priority[i] = min_priority;
+ highest_i[i] = -1;
+ highest_j[i] = -1;
+ }
+
+ for (j=0; j < CACHED_MESH_NUM_Y; ++j) {
+ for (i=0; i < CACHED_MESH_NUM_X; ++i) {
+ chunk_mesh *cm = &cached_chunk_mesh[j][i];
+ if (cm->state == STATE_valid) {
+ cm->priority = compute_priority(cm->chunk_x, cm->chunk_y, x, y);
+ chunk_storage_total += cm->vbuf_size + cm->fbuf_size;
+ if (cm->priority < lowest_priority) {
+ lowest_priority = cm->priority;
+ lowest_i = i;
+ lowest_j = j;
+ }
+ }
+ if (cm->state == STATE_needed) {
+ cm->priority = compute_priority(cm->chunk_x, cm->chunk_y, x, y);
+ if (cm->priority < min_priority)
+ cm->state = STATE_invalid;
+ else if (cm->priority > highest_priority[0]) {
+ int k;
+ highest_priority[0] = cm->priority;
+ highest_i[0] = i;
+ highest_j[0] = j;
+ // bubble this up to right place
+ for (k=0; k < MAX_QUEUE-1; ++k) {
+ if (highest_priority[k] > highest_priority[k+1]) {
+ highest_priority[k] = highest_priority[k+1];
+ highest_priority[k+1] = cm->priority;
+ highest_i[k] = highest_i[k+1];
+ highest_i[k+1] = i;
+ highest_j[k] = highest_j[k+1];
+ highest_j[k+1] = j;
+ } else {
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
+
+ // I couldn't find any straightforward logic that avoids
+ // the hysteresis problem of continually creating & freeing
+ // a block on the margin, so I just don't free a block until
+ // it's out of range, but this doesn't actually correctly
+ // handle when the cache is too small for the given range
+ if (chunk_storage_total >= min_chunk_storage && lowest_i >= 0) {
+ if (cached_chunk_mesh[lowest_j][lowest_i].priority < -1200) // -1000? 0?
+ free_chunk(lowest_i, lowest_j);
+ }
+
+ if (chunk_storage_total < max_chunk_storage && highest_i[0] >= 0) {
+ for (j=MAX_QUEUE-1; j >= 0; --j) {
+ if (highest_j[0] >= 0) {
+ chunk_mesh *cm = &cached_chunk_mesh[highest_j[j]][highest_i[j]];
+ if (request_chunk(cm->chunk_x, cm->chunk_y)) {
+ cm->state = STATE_requested;
+ } else {
+ // if we couldn't queue this one, skip the remainder
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ update_meshes_from_render_thread();
+
+ num_threads_active = 0;
+ for (i=0; i < num_mesh_workers; ++i) {
+ num_threads_active += (mesh_data[i].state == WSTATE_running);
+ }
+}
projects / henge / apc.git / blobdiff