6#include "uthash/uthash.h"
31#define ATMOSPHERE_IDX(x, y, o) ((o) + (y) * ATMOSPHERE_RES + (x))
69 return (
vec3){u.
y * v.
z - u.
z * v.
y, u.
z * v.
x - u.
x * v.
z, u.
x * v.
y - u.
y * v.
x};
76{
return x - floorf(x * (1.0f / 289.0f)) * 289.0f; }
87 (
vec4){ 1.0f, 1.0f, 1.0f, 1.0f }
107 p.
x = x.
x - floorf(x.
x);
108 p.
y = x.
y - floorf(x.
y);
109 p.
z = x.
z - floorf(x.
z);
122 p.
x = x.
x - floorf(x.
x);
123 p.
y = x.
y - floorf(x.
y);
124 p.
z = x.
z - floorf(x.
z);
125 p.
w = x.
w - floorf(x.
w);
139 vec3 a = (
vec3){floorf(p.
x), floorf(p.
y), floorf(p.
z)};
158 return o4.
y * d.
y + o4.
x * (1.0 - d.
y);
173 for (
int i = 0; i < 5; ++i) {
197 float r = fmodf(x,
size);
198 if (r < 0) r +=
size;
222 ivec3 pf = {floorf(p.
x), floorf(p.
y), floorf(p.
z)};
228 int px1 = (int)(pf.
x + 1) & pm1;
229 int py1 = (int)(pf.
y + 1) & pm1;
230 int pz1 = (int)(pf.
z + 1) & pm1;
231 ivec3 pf1 = {px1, py1, pz1};
234 float fx = p.
x - floorf(p.
x);
235 float fy = p.
y - floorf(p.
y);
236 float fz = p.
z - floorf(p.
z);
248 float c00 =
lerp(e0, e1, fx);
249 float c10 =
lerp(e2, e3, fx);
250 float c01 =
lerp(e4, e5, fx);
251 float c11 =
lerp(e6, e7, fx);
253 float c0 =
lerp(c00, c10, fy);
254 float c1 =
lerp(c01, c11, fy);
258 return out * 2.0f - 1.0f;
274 ivec3 pf = {floorf(p.
x), floorf(p.
y), floorf(p.
z)};
284 ivec3 pf1 = {px1, py1, pz1};
287 float fx = p.
x - floorf(p.
x);
288 float fy = p.
y - floorf(p.
y);
289 float fz = p.
z - floorf(p.
z);
292 float e0 =
fbm_tex[ pf.
z * SIZE * SIZE + pf.
y * SIZE + pf.
x ];
293 float e1 =
fbm_tex[ pf.
z * SIZE * SIZE + pf.
y * SIZE + pf1.
x ];
294 float e2 =
fbm_tex[ pf.
z * SIZE * SIZE + pf1.
y * SIZE + pf.
x ];
295 float e3 =
fbm_tex[ pf.
z * SIZE * SIZE + pf1.
y * SIZE + pf1.
x ];
296 float e4 =
fbm_tex[ pf1.
z * SIZE * SIZE + pf.
y * SIZE + pf.
x ];
297 float e5 =
fbm_tex[ pf1.
z * SIZE * SIZE + pf.
y * SIZE + pf1.
x ];
298 float e6 =
fbm_tex[ pf1.
z * SIZE * SIZE + pf1.
y * SIZE + pf.
x ];
299 float e7 =
fbm_tex[ pf1.
z * SIZE * SIZE + pf1.
y * SIZE + pf1.
x ];
301 float c00 =
lerp(e0, e1, fx);
302 float c10 =
lerp(e2, e3, fx);
303 float c01 =
lerp(e4, e5, fx);
304 float c11 =
lerp(e6, e7, fx);
306 float c0 =
lerp(c00, c10, fy);
307 float c1 =
lerp(c01, c11, fy);
311 return out * 2.0f - 1.0f;
331 chunk_origin.
x = floorf(chunk_origin.
x);
332 chunk_origin.
y = floorf(chunk_origin.
y);
333 chunk_origin.
z = floorf(chunk_origin.
z);
344 uvw.
x -= floorf(uvw.
x);
345 uvw.
y -= floorf(uvw.
y);
346 uvw.
z -= floorf(uvw.
z);
350 uvw.
x -= floorf(uvw.
x);
351 uvw.
y -= floorf(uvw.
y);
352 uvw.
z -= floorf(uvw.
z);
356 uvw.
x -= floorf(uvw.
x);
357 uvw.
y -= floorf(uvw.
y);
358 uvw.
z -= floorf(uvw.
z);
371 uvw.
x -= floorf(uvw.
x);
372 uvw.
y -= floorf(uvw.
y);
373 uvw.
z -= floorf(uvw.
z);
386 uvw.
x -= floorf(uvw.
x);
387 uvw.
y -= floorf(uvw.
y);
388 uvw.
z -= floorf(uvw.
z);
450 glActiveTexture(GL_TEXTURE0);
452 glActiveTexture(GL_TEXTURE1);
464 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
474 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
475 glMemoryBarrier(GL_COMMAND_BARRIER_BIT);
484 glDispatchCompute(1, 1, 1);
485 glMemoryBarrier(GL_COMMAND_BARRIER_BIT);
501 for (
int i = 0; i < 6; i++)
504 planes[i].
x > 0 ? max.
x : min.
x,
505 planes[i].
y > 0 ? max.
y : min.
y,
506 planes[i].
z > 0 ? max.
z : min.
z
509 if (
vec3_dot((
vec3){planes[i].
x, planes[i].
y, planes[i].
z}, p) + planes[i].
w < 0)
641 for (
int l = 0; l <
LODMAX; l++) {
644 if (h && l > best_lod) {
763#define MAX_ZERO_LIST 100000
848 for (
int l = 0; l <
LODMAX; l++)
855 glBufferData(GL_DRAW_INDIRECT_BUFFER,
862 for (
int l = 0; l <
LODMAX; l++)
903 Timer start, big_loop, execute;
916 GLenum
res = glClientWaitSync(
zero_fence, GL_SYNC_FLUSH_COMMANDS_BIT, 0);
926 GL_SHADER_STORAGE_BUFFER,
934 glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
938 glDispatchCompute(1, 1, 1);
939 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
948 if (new_list[c].vcnt == 0 && new_list[c].uid ==
CHUNK_DATA[l][i].
uID)
976 const float lookahead = 0.25f;
1009 vec4 light_planes[6];
1018 float frustum_weight = 100;
1020 int cam_chunk_lod = 0;
1022 ivec3 MIN_OFFSET = {
1028 ivec3 MAX_OFFSET = {
1036 pos.
x = floorf(pos.
x);
1037 pos.
y = floorf(pos.
y);
1038 pos.
z = floorf(pos.
z);
1042 ivec3 cam_center_chunk = {pos.
x, pos.
y, pos.
z};
1050 cam_chunk_lod = cam_clod;
1058 if (cam_chunk == -1 )
1061 start_pos = cam_pos;
1062 center_pos = cam_center_chunk;
1082 ivec3 chunk_pos = start_pos;
1113 if (!within_frustum)
1122 float dist_to_center =
ivec3_dist(chunk_pos, cam_pos);
1143 bool already_done =
false;
1144 int updating_lod_level = -1;
1145 int updating_lod_index = -1;
1156 if (clod ==
lod_level) { already_done =
true; }
1160 updating_lod_level = clod;
1161 updating_lod_index = h->
id;
1165 already_done =
true;
1180 if (updating_lod_level != -1)
1200 float weight = (1 - (dist_to_center / (float)(
CHUNK_WORLD_SIZE * 20)) + 1) * (within_frustum * frustum_weight + 1);
1216 float min_score = FLT_MAX;
1217 for (
int l = 0; l <
LODMAX; l++)
1259 float weight = (1 - (dist / (float)(
CHUNK_WORLD_SIZE * 20)) + 1) * (within_frustum * frustum_weight + 1);
1262 if (weight < min_score) { min_score = weight; }
1273 double big_loop_time =
end_timer(&big_loop);
1279 for (
int i = 0; i < job_count; i++)
1283 if (!
jobs[i].active ||
jobs[i].score <= min_score)
continue;
1288 if (
job_data[j].replacement_index != -1)
1300 bool out_of_space =
false;
1301 bool skip_free =
false;
1306 bool valid_child =
false;
1307 while (f == -1 && !skip_free)
1310 bool found_k =
false;
1311 for (
int k = 0; k < free_count; k++)
1338 { valid_child =
true; }
1347 job_data[j].replacement_index == -1 &&
1354 for (
int k = 0; k < free_count; k++)
1361 frees[k].score == -99
1388 if (
job_data[j].replacement_index != -1)
1391 out_of_space =
true;
1398 out_of_space =
true;
1409 if (out_of_space)
continue;
1412 job_data[j].replacement_index == -1 &&
1419 int k = (f != -1) ?
frees[f].index : -1;
1424 bool match_found =
false;
1425 if (
job_data[j].replacement_index == -1)
1449 bool new_chunk =
false;
1454 if (
job_data[j].replacement_index != -1)
1506 assert(child != -1);
1579 int current_chunk = uid;
1638 double execute_time =
end_timer(&execute);
1639 zero_fence = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
1682 uv.
x = uv.
x * 2.0f - 1.0f;
1683 uv.
y = uv.
y * 2.0f - 1.0f;
void update_camera(Camera *cam)
#define ATMOSPHERE_IDX(x, y, o)
void make_atmosphere_sphere_face(FACE face, int *vcnt, int *icnt)
Creats a sphere face to be used for atmosphere rendering.
void mesh_atmosphere_sphere()
Creates an atmosphere sphere for rendering.
AtmosphereVertex * ATMOSPHERE_VERTS
uint32_t * ATMOSPHERE_INDICES
void init_chunk_data()
Initializes and frees old ChunkData and hash tables.
bool free_parent(int lod, int i)
Frees the parent of given LOD.
void load_chunks(vec3 planet_origin, float planet_radius)
Checks all chunks based on new Camera position, building a job list and then executing them based on ...
float calc_density(vec3 p)
Copies the exact density function from the GPU to the CPU.
bool free_current_parent(int lod, int i)
Frees the given LOD (as a parent).
bool free_child(int lod, int i)
Frees the child of given LOD.
int find_current_lod(ivec3 center, ChunkHash **h)
Finds the highest LOD that we have cached from the current chunk.
void create_new_planet_mesh(int lod, ivec3 chunk_center, int chunk_id, bool is_parent)
Creates a mesh for a certain chunk.
float sample_fbm_density(vec3 p)
Samples a precomputed fbm volume.
GLuint DENSITY_SSBO[LODMAX]
ChunkData CHUNK_DATA[LODMAX][MAX_CHUNKS]
GLuint CHUNK_ZERO_COMPUTE_SHADER
ComputeShaderProgram DENSITY_COMPUTE_SHADER
GLuint DENSITY_VERTEX_SSBO[LODMAX]
GLuint CHUNK_DATA_SSBO[3]
GLuint INDIRECT_BUFFER[LODMAX][MAX_CHUNKS]
ComputeShaderProgram INDIRECT_COMPUTE_SHADER
ComputeShaderProgram MARCHING_CUBES_COMPUTE_SHADER
float sample_density(vec3 p, vec3 chunk_offset, vec3 center_offset, float voxel_size, uint padded)
float vec3_dot(vec3 a, vec3 b)
vec3 ivec3_scale(ivec3 a, float b)
vec4 vec4_add(vec4 a, vec4 b)
vec3 vec3_normalize(vec3 v)
mat4 m4_mul(mat4 a, mat4 b)
float ivec3_dist(ivec3 a, ivec3 b)
vec3 vec3_scale(vec3 a, float b)
vec3 vec3_mul(vec3 a, vec3 b)
vec4 vec4_mul(vec4 a, vec4 b)
vec2 vec2_add(vec2 a, vec2 b)
vec2 vec2_scale(vec2 a, float b)
vec4 vec4_sub(vec4 a, vec4 b)
vec3 vec3_sub(vec3 a, vec3 b)
vec3 vec3_add(vec3 a, vec3 b)
float lerp(float a, float b, float t)
vec4 vec4_scale(vec4 a, float b)
ivec3 ivec3_add(ivec3 a, ivec3 b)
bool aabb_in_frustum(ivec3 min, ivec3 max, vec4 planes[6])
AuthorityEntry * authority_map
uint32_t assign_new_uID()
int compareFrees(const void *a, const void *b)
int emitted_chunk_ids[VERTEX_COUNT_MAX]
void get_view_planes(vec4 planes[6], Camera *cam, vec3 planet_offset, float planet_radius)
Returns view planes from a camera, used for frustum culling.
bool already_emitted[LODMAX][MAX_CHUNKS]
vec3 cube_pos(FACE face, vec2 uv)
vec3 calc_normal(vec3 a, vec3 b, vec3 c)
int compareJobs(const void *a, const void *b)
float wrap(float x, float size)
vec3 vec3_wrap(vec3 a, float size)
bool replacement_mask[LODMAX][MAX_CHUNKS]
ZeroEntry * zero_hash_table
int emitted_chunk_lods[VERTEX_COUNT_MAX]
ChunkHash * find_chunk_hash(ivec3 center, int lod)
void delete_chunk_hash(ivec3 center, int lod)
int get_current_lod(ivec3 center)
void set_current_lod(ivec3 center, int lod)
void replace_chunk_hash(ivec3 center, int lod, int id)
PerlinLayer perlin_layers[MAX_LAYERS]
const int LOD_RES[LODMAX]
WarpLayer warp_layers[MAX_LAYERS]
double end_timer(Timer *t)
void start_timer(Timer *t)
const int MAX_CHUNKS_LOD[LODMAX]
#define PERLIN_TEXTURE_SIZE
FBMLayer fbm_layers[MAX_LAYERS]