Space Sim
Loading...
Searching...
No Matches
init.c
Go to the documentation of this file.
1#include <SDL2/SDL.h>
2#include <GL/glew.h>
3#include <SDL2/SDL_events.h>
4#include <SDL2/SDL_mouse.h>
5#include <SDL2/SDL_video.h>
6#include "utilities/mathf.h"
7#include <math.h>
8#include <stdbool.h>
9#include "core/init.h"
10#include "core/types.h"
11#include "mesh/mesh.h"
12#include "core/shaders.h"
13#include "mesh/marching_cubes.h"
14#include "stb/stb_image.h"
15#include "nuklear/nuklear.h"
16#include "nuklear/nuklear_sdl_gl3.h"
17
18GLuint
20 (
21 const char * path,
22 GLenum iformat,
23 GLenum format,
24 GLenum type
25 )
26
27{
28
29 int w, h, channels;
30
31 unsigned char *data = stbi_load(path, &w, &h, &channels, 0);
32
33 if (!data) {
34 printf("Failed to load image: %s\\n", path);
35 return 0;
36 }
37
38 GLuint textureID;
39 glGenTextures(1, &textureID);
40 glBindTexture(GL_TEXTURE_2D, textureID);
41
42 glTexImage2D(GL_TEXTURE_2D, 0, iformat, w, h, 0, format, type, data);
43
44 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
45 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
46 glGenerateMipmap(GL_TEXTURE_2D);
47
48 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
49 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
50
51 stbi_image_free(data);
52 return textureID;
53
54}
55
56GLuint
58 ( const char * path )
59
60{
61 const char * a[6] =
62 {
63 "/px.png", "/nx.png", "/py.png", "/ny.png", "/pz.png", "/nz.png"
64 };
65
66 GLuint cubemap;
67 glGenTextures(1, &cubemap);
68 glBindTexture(GL_TEXTURE_CUBE_MAP, cubemap);
69 for (int i = 0; i < 6; i++)
70 {
71
72 char c[428];
73 strcpy(c, path);
74 strcat(c, a[i]);
75
76 int w, h, channels;
77
78 unsigned char *data = stbi_load(c, &w, &h, &channels, 0);
79
80 if (!data) {
81 printf("Failed to load image: %s\\n", path);
82 return 0;
83 }
84
85
86 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
87
88
89
90 }
91
92 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
93 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
94 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_REPEAT);
95 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_REPEAT);
96 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_REPEAT);
97
98 return cubemap;
99
100}
101
102// Distribution for particle mass
103float power_law(float min_m, float max_m, float alpha) {
104
105 float r = (float)rand() / RAND_MAX;
106 float a = 1.0f - alpha;
107
108 return pow(r * (pow(max_m, a) - pow(min_m, a)) + pow(min_m, a), 1.0f / a);
109}
110
111// Complete mass after random distribution
112float MASS = 0.0f;
113void
115 ()
116
117{
118
119 memset(&PD, 0, sizeof(ParticleData));
120
121 vec3 axis = (vec3){0, 0, 1};
122 for (int i = 0; i < BODY_COUNT; i++) {
123
124 float u = (float)rand() / RAND_MAX;
125 float v = (float)rand() / RAND_MAX;
126
127 float theta = 2.0f * M_PI * u;
128 float z = 2.0f * v - 1.0f;
129
130 float r = sqrt(1.0f - z * z);
131 float radius = cbrtf((float)rand() / RAND_MAX) * GLOBALS.radius;
132
133 vec3 p;
134 p.x = r * cosf(theta) * radius;
135 p.y = r * sinf(theta) * radius;
136 p.z = z * radius;
137
138 if (i == 0) {
139
140 PD.p[i].p_m = (vec4){0, 0, 0, GLOBALS.max_mass};
141 PD.p[i].vel = (vec4){0, 0, 0, 0};
142 PD.p[i].acc = (vec4){0, 0, 0, 0};
143
144 } else {
145
147
148
149 vec3 tan = vec3_cross( axis, (vec3){PD.p[i].p_m.x, PD.p[i].p_m.y, PD.p[i].p_m.z});
150
151 vec3 v2 = vec3_scale(vec3_normalize(tan), 0.5f);
152 PD.p[i].vel = (vec4){v2.x, v2.y, v2.z, 0};
153 PD.p[i].acc = (vec4){0, 0, 0, 0};
154
155 }
156
157 PD.p[i].mat =
158 (vec4){(float)rand() / RAND_MAX, (float)rand() / RAND_MAX,
159 (float)rand() / RAND_MAX, (float)rand() / RAND_MAX};
160 }
161 for (int i = 0; i < BODY_COUNT; i++) {
162 MASS += PD.p[i].p_m.w;
163 }
164
165 glBindBuffer(GL_SHADER_STORAGE_BUFFER, PARTICLE_SSBO);
166 glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(ParticleData), &PD);
167 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, PARTICLE_SSBO);
168
169}
170struct nk_context * NK_CTX = NULL;
171bool NUKLEAR_HOVERED = false;
172
174float * phi = NULL;
175// Generates a random number with a random distribution for water FFT constants.
176float
178
179{
180
181 float u1 = ((float)rand() + 1.0f) / (RAND_MAX + 1.0f);
182 float u2 = ((float)rand() + 1.0f) / (RAND_MAX + 1.0f);
183 return sqrtf(-2.0f * logf(u1)) * cosf(2.0f * M_PI * u2);
184
185}
186
188
189// Initializes the water grid with hardcoded constants.
190// TODO make this changeable in real time.
195void
197 (
198 int N,
199 int L,
200 float A
201 )
202
203{
204
205 float PI_2 = M_PI * 2;
206 vec2 w = {-5.0f, 12.0f};
207 float w_magnitude = sqrtf(w.x * w.x + w.y * w.y);
208 vec2 w_dir = {w.x / w_magnitude, w.y / w_magnitude};
209
210 water_fft_arr = malloc(sizeof(vec4) * N * N);
211 memset(WATER_DATA.water_data, 0, sizeof(vec4) * N * N);
212 phi = malloc(sizeof(float) * N * N);
213
214 int count = 0;
215 for (int n = 0; n < N; n++)
216 {
217 for (int m = 0; m < N; m++)
218 {
219 float kx = (n <= N/2) ? n : n - N;
220 float kz = (m <= N/2) ? m : m - N;
221
222 kx *= (2.0f * M_PI / L);
223 kz *= (2.0f * M_PI / L);
224 float k_magnitude = sqrtf(kx * kx + kz * kz);
225 int idx = n * N + m;
226 if (k_magnitude < 1e-6f)
227 {
228 water_fft_arr[idx] = (vec4){0,0,0,0};
229 count++;
230 continue;
231 }
232 vec2 dir = {kx, kz};
233 dir.x /= k_magnitude;
234 dir.y /= k_magnitude;
235
236 float k4 = pow(k_magnitude, 4.0f);
237
238 float kw_dot = vec2_dot(dir, w_dir);
239 kw_dot = pow(kw_dot, 2.0f);
240 float damping = exp(-k_magnitude * k_magnitude * L * L * 0.001f);
241 float p = A * (exp(-1/((k_magnitude * L) * (k_magnitude * L))) / k4) * kw_dot /* * damping */;
242
243 WATER_DATA.water_data[idx].x = 1 / sqrtf(2.0f) * rand_normal() * sqrtf(p);
244 WATER_DATA.water_data[idx].y = 1 / sqrtf(2.0f) * rand_normal() * sqrtf(p);
247 count++;
248 }
249
250 }
251
252}
253
254
255float
257 (
258 vec2 pos,
259 vec2 w,
260 float len2
261 )
262{ return ((pos.x * w.y - pos.y * w.x) / len2); }
263
264vec3 * out_arr = NULL;
266
267// FFTs the water texture, bit reversal first.
268// output always in po
273void
275 (
276 GLuint pi,
277 GLuint po
278 )
279
280{
281
282 int stages = log2(WATER_FFT_TEXTURE_SIZE);
283 glUseProgram(BIT_REVERSAL_COMPUTE_SHADER);
284
285 glUniform1i(glGetUniformLocation(BIT_REVERSAL_COMPUTE_SHADER, "log2N"), stages);
286 glBindImageTexture(0, pi, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA32F);
287 glBindImageTexture(1, po, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);
288 glDispatchCompute((WATER_FFT_TEXTURE_SIZE+15) / 16, (WATER_FFT_TEXTURE_SIZE+15) / 16, 1);
289 glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL_SHADER_STORAGE_BARRIER_BIT);
290
291
292 glUseProgram(WATER_FFT_COMPUTE_SHADER);
293 GLuint * ping = &po;
294 GLuint * pong = &pi;
295 for (int d = 0; d < 2; d++)
296 {
297 for (int stage = 0; stage < stages; stage++)
298 {
299 glUniform1i(glGetUniformLocation(WATER_FFT_COMPUTE_SHADER, "direction"), d);
300 glUniform1i(glGetUniformLocation(WATER_FFT_COMPUTE_SHADER, "stage"), stage);
301 glUniform1i(glGetUniformLocation(WATER_FFT_COMPUTE_SHADER, "final_stage"), (stage == stages - 1 && d == 1) ? 1 : 0);
302
303 glBindImageTexture(0, *ping, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA32F);
304 glBindImageTexture(1, *pong, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);
305
306 glDispatchCompute((WATER_FFT_TEXTURE_SIZE+15) / 16, (WATER_FFT_TEXTURE_SIZE+15) / 16, 1);
307 glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT);
308 GLuint * temp = pong;
309 pong = ping;
310 ping = temp;
311 }
312 }
313}
314
315
321void
323 (
324 float t
325 )
326
327{
328
329 glUseProgram(WATER_COMPUTE_SHADER);
330 glBindImageTexture(0, WATER_FFT_PING_TEXTURE, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);
331 glBindImageTexture(1, WATER_FFT_PING_TEXTURE_2, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);
332 glUniform1f(glGetUniformLocation(WATER_COMPUTE_SHADER, "g"), 9.81f);
333 glUniform1f(glGetUniformLocation(WATER_COMPUTE_SHADER, "t"), t);
334
335 glDispatchCompute((WATER_FFT_TEXTURE_SIZE+15) / 16, (WATER_FFT_TEXTURE_SIZE+15) / 16, 1);
336
337 glMemoryBarrier(GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL_SHADER_STORAGE_BARRIER_BIT);
338
341}
342
343
344// Noise pregen:
345// FBM
346float * fbm_tex = NULL;
347
348
349void
351
352{
353
354 fbm_tex = calloc(FBM_TEXTURE_SIZE * FBM_TEXTURE_SIZE * FBM_TEXTURE_SIZE, sizeof(float));
355
356 for (int z = 0; z < FBM_TEXTURE_SIZE; z++)
357 {
358
359 for (int y = 0; y < FBM_TEXTURE_SIZE; y++)
360 {
361
362 for (int x = 0; x < FBM_TEXTURE_SIZE; x++)
363 {
364 vec3 p = {(float)x + 0.5f, (float)y + 0.5f, (float)z + 0.5f};
365 float d = fbm(p);
366
368 }
369 }
370 }
371
372 glBindTexture(GL_TEXTURE_3D, FBM_TEXTURE);
373 glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, FBM_TEXTURE_SIZE, FBM_TEXTURE_SIZE, FBM_TEXTURE_SIZE, GL_RED, GL_FLOAT, fbm_tex);
374}
375
376// Worley
378
379vec3
381 ( vec3 p )
382
383{
384 vec3 s = (vec3){
385 vec3_dot(p, (vec3){127.1,311.7,473.4}),
386 vec3_dot(p, (vec3){446.1,269.5,183.3}),
387 vec3_dot(p, (vec3){232.5,460.2,124.2})
388 };
389
390 s = (vec3){sinf(s.x), sinf(s.y), sinf(s.z)};
391 s = vec3_scale(s, 43758.5453);
392 s.x -= floorf(s.x);
393 s.y -= floorf(s.y);
394 s.z -= floorf(s.z);
395
396 return s;
397}
398
399float
401 ( vec3 p )
402
403{
404
405 vec3 fp = (vec3){floorf(p.x), floorf(p.y), floorf(p.z)};
406 vec3 frp = (vec3){p.x - fp.x, p.y - fp.y, p.z - fp.z};
407
408 float m_dist = 1;
409
410 for (int z = -1; z <= 1; z++)
411 {
412 for (int y = -1; y <= 1; y++)
413 {
414 for (int x = -1; x <= 1; x++)
415 {
416
417 vec3 neighbor = (vec3){x, y, z};
418 vec3 point = random3(vec3_add(fp, neighbor));
419 vec3 diff = vec3_sub(vec3_add(neighbor, point), frp);
420
421 float dist = vec3_length(diff);
422 m_dist = MIN(m_dist, dist);
423
424 }
425 }
426 }
427
428 return m_dist;
429
430}
431
432
433void
435{
437
438 const float f0 = 0.05f;
439 const float f1 = 0.51;
440 const float f2 = 1.05f;
441 const float f3 = 2.1f;
442
443 for (int z = 0; z < WORLEY_TEXTURE_SIZE; z++)
444 {
445
446 for (int y = 0; y < WORLEY_TEXTURE_SIZE; y++)
447 {
448
449 for (int x = 0; x < WORLEY_TEXTURE_SIZE; x++)
450 {
451 vec3 p = {(float)x + 0.5f, (float)y + 0.5f, (float)z + 0.5f};
452 vec3 p0 = vec3_scale(p, f0);
453 vec3 p1 = vec3_scale(p, f1);
454 vec3 p2 = vec3_scale(p, f2);
455 vec3 p3 = vec3_scale(p, f3);
456
457
458 vec4 d = (vec4){worley(p0), worley(p1), worley(p2), worley(p3)};
459
461 }
462 }
463 }
464
465 glBindTexture(GL_TEXTURE_3D, WORLEY_TEXTURE);
466 glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, WORLEY_TEXTURE_SIZE, WORLEY_TEXTURE_SIZE, WORLEY_TEXTURE_SIZE, GL_RGBA, GL_FLOAT, worley_tex);
467
468}
469
470
471// Perlin
472float fade(float t) { return t * t * t * (t * (t * 6.0 - 15.0) + 10.0); }
473
475
476void
478
479{
480
481 for (int i = 0; i < PERLIN_TEXTURE_SIZE / 2; i++) {
482 permutations[i] = i;
483 }
484
485 for (int i = PERLIN_TEXTURE_SIZE / 2 - 1; i > 0; i--) {
486 int index = rand() % (PERLIN_TEXTURE_SIZE / 2 - 1);
487 int temp = permutations[i];
488 permutations[i] = permutations[index];
489 permutations[index] = temp;
490 }
491
492 for (int i = PERLIN_TEXTURE_SIZE / 2; i < PERLIN_TEXTURE_SIZE; i++) {
494 }
495}
496
497vec3 gradients[12] = {{1, 1, 0}, {-1, 1, 0}, {1, -1, 0}, {-1, -1, 0},
498 {1, 0, 1}, {-1, 0, 1}, {1, 0, -1}, {-1, 0, -1},
499 {0, 1, 1}, {0, -1, 1}, {0, 1, -1}, {0, -1, -1}};
500
501float
503 ( float t )
504{ return t - (floor(t) / 256) * 256; }
505
506float
508 ( vec3 p )
509{
510 int pm1 = PERLIN_TEXTURE_SIZE - 1;
511
512 vec3 pw = {fmodf(p.x, PERLIN_TEXTURE_SIZE), fmodf(p.y, PERLIN_TEXTURE_SIZE),
513 fmodf(p.z, PERLIN_TEXTURE_SIZE)};
514 ivec3 p0 = (ivec3){(int)floorf(pw.x), (int)floorf(pw.y), (int)floorf(pw.z)};
515
516 int px1 = (int)(p0.x + 1) & pm1;
517 int py1 = (int)(p0.y + 1) & pm1;
518 int pz1 = (int)(p0.z + 1) & pm1;
519
520 float pmx = pw.x - px1;
521 if (fabsf(pmx) > 1) {
522 pmx = (pw.x - pm1) - px1;
523 }
524 float pmy = pw.y - py1;
525 if (fabsf(pmy) > 1) {
526 pmy = (pw.y - pm1) - py1;
527 }
528 float pmz = pw.z - pz1;
529 if (fabsf(pmz) > 1) {
530 pmz = (pw.z - pm1) - pz1;
531 }
532
533 ivec3 p1 = {px1, p0.y, p0.z};
534 ivec3 p2 = {p0.x, py1, p0.z};
535 ivec3 p3 = {px1, py1, p0.z};
536 ivec3 p4 = {p0.x, p0.y, pz1};
537 ivec3 p5 = {px1, p0.y, pz1};
538 ivec3 p6 = {p0.x, py1, pz1};
539 ivec3 p7 = {px1, py1, pz1};
540
541 int e0 =
542 permutations[(permutations[(permutations[p0.x] + p0.y) & pm1] + p0.z) &
543 pm1];
544 int e1 =
545 permutations[(permutations[(permutations[p1.x] + p1.y) & pm1] + p1.z) &
546 pm1];
547 int e2 =
548 permutations[(permutations[(permutations[p2.x] + p2.y) & pm1] + p2.z) &
549 pm1];
550 int e3 =
551 permutations[(permutations[(permutations[p3.x] + p3.y) & pm1] + p3.z) &
552 pm1];
553 int e4 =
554 permutations[(permutations[(permutations[p4.x] + p4.y) & pm1] + p4.z) &
555 pm1];
556 int e5 =
557 permutations[(permutations[(permutations[p5.x] + p5.y) & pm1] + p5.z) &
558 pm1];
559 int e6 =
560 permutations[(permutations[(permutations[p6.x] + p6.y) & pm1] + p6.z) &
561 pm1];
562 int e7 =
563 permutations[(permutations[(permutations[p7.x] + p7.y) & pm1] + p7.z) &
564 pm1];
565
566 vec3 g0 = gradients[e0 % 12];
567 vec3 g1 = gradients[e1 % 12];
568 vec3 g2 = gradients[e2 % 12];
569 vec3 g3 = gradients[e3 % 12];
570 vec3 g4 = gradients[e4 % 12];
571 vec3 g5 = gradients[e5 % 12];
572 vec3 g6 = gradients[e6 % 12];
573 vec3 g7 = gradients[e7 % 12];
574
575 float t0 = pw.x - p0.x;
576 float fade_t0 = fade(t0);
577
578 float t1 = pw.y - p0.y;
579 float fade_t1 = fade(t1);
580
581 float t2 = pw.z - p0.z;
582 float fade_t2 = fade(t2);
583 // printf("T0 %f T1 %f T2 %f\n", t0, t1, t2);
584
585 vec3 pp0 = {pw.x - p0.x, pw.y - p0.y, pw.z - p0.z};
586 vec3 pp1 = {pmx, pw.y - p1.y, pw.z - p1.z};
587 vec3 pp2 = {pw.x - p2.x, pmy, pw.z - p2.z};
588 vec3 pp3 = {pmx, pmy, pw.z - p3.z};
589 vec3 pp4 = {pw.x - p4.x, pw.y - p4.y, pmz};
590 vec3 pp5 = {pmx, pw.y - p5.y, pmz};
591 vec3 pp6 = {pw.x - p6.x, pmy, pmz};
592 vec3 pp7 = {pmx, pmy, pmz};
593
594 float p0p1 =
595 (1.0 - fade_t0) * vec3_dot(g0, pp0) + fade_t0 * vec3_dot(g1, pp1);
596 float p2p3 =
597 (1.0 - fade_t0) * vec3_dot(g2, pp2) + fade_t0 * vec3_dot(g3, pp3);
598
599 float p4p5 =
600 (1.0 - fade_t0) * vec3_dot(g4, pp4) + fade_t0 * vec3_dot(g5, pp5);
601 float p6p7 =
602 (1.0 - fade_t0) * vec3_dot(g6, pp6) + fade_t0 * vec3_dot(g7, pp7);
603
604 float y1 = (1.0 - fade_t1) * p0p1 + fade_t1 * p2p3;
605 float y2 = (1.0 - fade_t1) * p4p5 + fade_t1 * p6p7;
606
607 return (1.0 - fade_t2) * y1 + fade_t2 * y2;
608}
609
611
612void
614{
615
616 make_perm();
617 const float FREQUENCY = 1.0;
618 const float AMPLITUDE = 1.0;
619
620 perlin_tex =
622 sizeof(float));
623
624 for (int z = 0; z < PERLIN_TEXTURE_SIZE; z++) {
625 for (int y = 0; y < PERLIN_TEXTURE_SIZE; y++) {
626 for (int x = 0; x < PERLIN_TEXTURE_SIZE; x++) {
627
628 vec3 p = {(float)x + 0.5, (float)y + 0.5, (float)z + 0.5};
629
630 float n = noise3d(vec3_scale(p, FREQUENCY)) * AMPLITUDE;
631
633 y * PERLIN_TEXTURE_SIZE + x] = (n + 1) / 2;
634 }
635 }
636 }
637
638 glBindTexture(GL_TEXTURE_3D, PERLIN_TEXTURE);
639 glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, PERLIN_TEXTURE_SIZE,
640 PERLIN_TEXTURE_SIZE, PERLIN_TEXTURE_SIZE, GL_RED, GL_FLOAT,
641 perlin_tex);
642}
643
645{
646
647 GLOBALS.min_mass = 1000;
648 GLOBALS.max_mass = 1000;
649 GLOBALS.mass_pow = 2.0f;
650 GLOBALS.radius = 2000;
655
656}
657
658bool
660 (
661 SDL_Window ** window,
662 SDL_GLContext * context
663 )
664
665{
666
667 printf("Initializing\n");
668 if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) {
669 printf("SDL Init failed: %s\n", SDL_GetError());
670 return false;
671 }
672
673 #ifdef INCLUDE_CONFIGURATOR
674 static struct nk_color color_table[NK_COLOR_COUNT];
675 memcpy(color_table, nk_default_color_style, sizeof(color_table));
676 #endif
677
678 SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
679 SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 4);
680 SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
681
682 SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
683 SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
684 SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
685 SDL_GL_SetSwapInterval(1);
690
691 *window = SDL_CreateWindow("Space", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_OPENGL);
692
693 // SDL_SetWindowFullscreen(*window, SDL_WINDOW_FULLSCREEN);
694 SDL_SetWindowGrab(*window, SDL_TRUE);
695 SDL_SetRelativeMouseMode(SDL_TRUE);
696 if (!*window) {
697 printf("Window creation failed: %s\n", SDL_GetError());
698 return false;
699 }
700
701 *context = SDL_GL_CreateContext(*window);
702 if (!*context) {
703 printf("GL Context failed: %s\n", SDL_GetError());
704 return false;
705 }
706
707 glewExperimental = GL_TRUE;
708 if (glewInit() != GLEW_OK) {
709 printf("GLEW Init failed\n");
710 return false;
711 }
712
713 NK_CTX = nk_sdl_init(*window);
714 if (!NK_CTX)
715 {
716 printf("NUKLEAR INIT FAILED\n");
717 return false;
718 }
719 {struct nk_font_atlas *atlas;
720 nk_sdl_font_stash_begin(&atlas);
721 nk_sdl_font_stash_end();
722 }
723
724 #ifdef INCLUDE_STYLE
725 #ifdef STYLE_WHITE
726 set_style(ctx, THEME_WHITE);
727 #elif defined(STYLE_RED)
728 set_style(ctx, THEME_RED);
729 #elif defined(STYLE_BLUE)
730 set_style(ctx, THEME_BLUE);
731 #elif defined(STYLE_DARK)
732 set_style(ctx, THEME_DARK);
733 #endif
734 #endif
735
736 struct nk_color transparent = nk_rgba(30, 30, 30, 90);
737 struct nk_color border = nk_rgba(60, 60, 60, 150);
738 struct nk_color text = nk_rgba(255, 255, 255, 255);
739
740 NK_CTX->style.window.fixed_background = nk_style_item_color(transparent);
741 NK_CTX->style.window.border_color = border;
742 NK_CTX->style.window.padding = nk_vec2(10, 10);
743 NK_CTX->style.window.border = 1;
744
745 NK_CTX->style.text.color = text;
746
747
748 init_globals();
749
750 printf("Textures\n");
751 glGenTextures(1, &SPHERE_TEXTURE);
752 glBindTexture(GL_TEXTURE_2D, SPHERE_TEXTURE);
753
754 glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, 256, 256, 0, GL_RED, GL_FLOAT, NULL);
755 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
756 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
757 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
758 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
759
761
762 glGenTextures(1, &WATER_FFT_PING_TEXTURE);
763 glBindTexture(GL_TEXTURE_2D, WATER_FFT_PING_TEXTURE);
764
765 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, WATER_FFT_TEXTURE_SIZE, WATER_FFT_TEXTURE_SIZE, 0, GL_RGBA, GL_FLOAT, NULL);
766 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
767 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
768 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
769 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
770
771 glGenTextures(1, &WATER_FFT_PONG_TEXTURE);
772 glBindTexture(GL_TEXTURE_2D, WATER_FFT_PONG_TEXTURE);
773
774 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, WATER_FFT_TEXTURE_SIZE, WATER_FFT_TEXTURE_SIZE, 0, GL_RGBA, GL_FLOAT, NULL);
775 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
776 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
777 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
778 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
779
780 glGenTextures(1, &WATER_FFT_PING_TEXTURE_2);
781 glBindTexture(GL_TEXTURE_2D, WATER_FFT_PING_TEXTURE_2);
782
783 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, WATER_FFT_TEXTURE_SIZE, WATER_FFT_TEXTURE_SIZE, 0, GL_RGBA, GL_FLOAT, NULL);
784 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
785 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
786 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
787 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
788
789 glGenTextures(1, &WATER_FFT_PONG_TEXTURE_2);
790 glBindTexture(GL_TEXTURE_2D, WATER_FFT_PONG_TEXTURE_2);
791
792 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, WATER_FFT_TEXTURE_SIZE, WATER_FFT_TEXTURE_SIZE, 0, GL_RGBA, GL_FLOAT, NULL);
793 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
794 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
795 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
796 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
797
798 glGenTextures(1, &WORLEY_TEXTURE);
799 glBindTexture(GL_TEXTURE_3D, WORLEY_TEXTURE);
800
801 glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA16F, WORLEY_TEXTURE_SIZE, WORLEY_TEXTURE_SIZE, WORLEY_TEXTURE_SIZE, 0, GL_RGBA, GL_FLOAT, NULL);
802 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
803 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
804 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_REPEAT);
805 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_REPEAT);
806 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_REPEAT);
807
809
810 glGenTextures(1, &PERLIN_TEXTURE);
811 glBindTexture(GL_TEXTURE_3D, PERLIN_TEXTURE);
812
813 glTexImage3D(GL_TEXTURE_3D, 0, GL_R16F, PERLIN_TEXTURE_SIZE, PERLIN_TEXTURE_SIZE, PERLIN_TEXTURE_SIZE, 0, GL_RED, GL_FLOAT, NULL);
814 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
815 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
816 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_REPEAT);
817 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_REPEAT);
818 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_REPEAT);
819
821
822 glGenTextures(1, &FBM_TEXTURE);
823 glBindTexture(GL_TEXTURE_3D, FBM_TEXTURE);
824
825 glTexImage3D(GL_TEXTURE_3D, 0, GL_R16F, FBM_TEXTURE_SIZE, FBM_TEXTURE_SIZE, FBM_TEXTURE_SIZE, 0, GL_RED, GL_FLOAT, NULL);
826 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
827 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
828 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_REPEAT);
829 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_REPEAT);
830 glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_REPEAT);
831
833
834 glGenTextures(1, &SKY_CUBEMAP);
835 glBindTexture(GL_TEXTURE_CUBE_MAP, SKY_CUBEMAP);
836
837 int sky_cubemap_size = 128;
838 for (int i = 0; i < 6; i++)
839 {
840 glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGBA, sky_cubemap_size, sky_cubemap_size, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
841 }
842
843 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
844 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
845 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_REPEAT);
846 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_REPEAT);
847 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_REPEAT);
848
849 ROCK_NORMAL_TEXTURE = load_texture("./textures/rocky_terrain_03_nor_gl_4k.png", GL_RGB8, GL_RGB, GL_UNSIGNED_BYTE);
850 ROCK_DIFFUSE_TEXTURE = load_texture("./textures/rocky_terrain_03_diff_4k.png", GL_SRGB8_ALPHA8, GL_RGB, GL_UNSIGNED_BYTE);
851
852 ROCK_SPECULAR_TEXTURE = load_texture("./textures/rocky_terrain_03_spec_4k.png", GL_R8, GL_RED, GL_UNSIGNED_BYTE);
853 ROCK_AO_TEXTURE = load_texture("./textures/rocky_terrain_03_ao_4k.png", GL_R8, GL_RED, GL_UNSIGNED_BYTE);
854
855 CUBEMAP_TEXTURE = load_cubemap("./cubemap");
856
857 glGenTextures(1, &MAIN_TEXTURE);
858 glBindTexture(GL_TEXTURE_2D, MAIN_TEXTURE);
859
860 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, SCREEN_WIDTH, SCREEN_HEIGHT, 0, GL_RGBA, GL_FLOAT, NULL);
861 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
862 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
863 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
864 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
865
866 glGenTextures(1, &ID_TEXTURE);
867 glBindTexture(GL_TEXTURE_2D, ID_TEXTURE);
868
869 glTexImage2D(GL_TEXTURE_2D, 0, GL_R32I, SCREEN_WIDTH, SCREEN_HEIGHT, 0, GL_RED_INTEGER, GL_INT, NULL);
870 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
871 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
872 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
873 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
874
875
876 glGenTextures(1, &DEPTH_TEXTURE);
877 glBindTexture(GL_TEXTURE_2D, DEPTH_TEXTURE);
878 glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, SCREEN_WIDTH, SCREEN_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
879 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
880 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
881 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
882 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
883 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);
884
885 glGenFramebuffers(1, &MAIN_FBO);
886 glBindFramebuffer(GL_FRAMEBUFFER, MAIN_FBO);
887 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, MAIN_TEXTURE, 0);
888 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, ID_TEXTURE, 0);
889 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, DEPTH_TEXTURE, 0);
890
891 glGenTextures(1, &COMPOSITE_TEXTURE);
892 glBindTexture(GL_TEXTURE_2D, COMPOSITE_TEXTURE);
893
894 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, SCREEN_WIDTH, SCREEN_HEIGHT, 0, GL_RGBA, GL_FLOAT, NULL);
895 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
896 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
897 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
898 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
899
900 glGenTextures(1, &COMPOSITE_DEPTH_TEXTURE);
901 glBindTexture(GL_TEXTURE_2D, COMPOSITE_DEPTH_TEXTURE);
902 glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, SCREEN_WIDTH, SCREEN_HEIGHT, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
903 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
904 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
905 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
906 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
907 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);
908
909 glGenFramebuffers(1, &COMPOSITE_FBO);
910 glBindFramebuffer(GL_FRAMEBUFFER, COMPOSITE_FBO);
911 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, COMPOSITE_TEXTURE, 0);
912 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, COMPOSITE_DEPTH_TEXTURE, 0);
913
914 // this is hilarious i am keeping it
915 if (!glewIsSupported("GL_ARB_buffer_storage")) {
916 printf("SHIT\n");
917 }
918
919 glGenTextures(1, &EXP_LOOKUP_TEXTURE);
920 glBindTexture(GL_TEXTURE_2D, EXP_LOOKUP_TEXTURE);
921
922
923 float exp_lookup[1000];
924
925 for (int i = 0; i < 1000; i++)
926 {
927 exp_lookup[i] = expf((float)-i / 50);
928 }
929
930 glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, 1000, 1, 0, GL_RED, GL_FLOAT, exp_lookup);
931 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
932 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
933 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
934 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
935
936
937 glGenFramebuffers(1, &SKY_FBO);
938 glBindFramebuffer(GL_FRAMEBUFFER, SKY_FBO);
939 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP, SKY_CUBEMAP, 0);
940
941 glGenTextures(1, &SHADOW_MAP_TEXTURE);
942 glBindTexture(GL_TEXTURE_2D, SHADOW_MAP_TEXTURE);
943 glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, SHADOW_MAP_SIZE, SHADOW_MAP_SIZE, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
944 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
945 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
946 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
947 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
948
949 float border_color[] = {1.0f, 1.0f, 1.0f, 1.0f};
950 glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color);
951
952 glGenFramebuffers(1, &SHADOW_MAP_FBO);
953 glBindFramebuffer(GL_FRAMEBUFFER, SHADOW_MAP_FBO);
954 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, SHADOW_MAP_TEXTURE, 0);
955 glDrawBuffer(GL_NONE);
956 glReadBuffer(GL_NONE);
957
958 glBindFramebuffer(GL_FRAMEBUFFER, 0);
959
960
961 glGenTextures(1, &POSTPROCESS_TEXTURE);
962 glBindTexture(GL_TEXTURE_2D, POSTPROCESS_TEXTURE);
963 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, SCREEN_WIDTH, SCREEN_HEIGHT, 0, GL_RGBA, GL_FLOAT, NULL);
964 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
965 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
966 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
967 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
968
969 glGenFramebuffers(1, &POSTPROCESS_FBO);
970 glBindFramebuffer(GL_FRAMEBUFFER, POSTPROCESS_FBO);
971 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, POSTPROCESS_TEXTURE, 0);
972
973 glGenTextures(1, &BLOOM_TEXTURE);
974 glBindTexture(GL_TEXTURE_2D, BLOOM_TEXTURE);
975 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, BLOOM_WIDTH, BLOOM_HEIGHT, 0, GL_RGBA, GL_FLOAT, NULL);
976 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
977 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
978 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
979 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
980
981 glGenFramebuffers(1, &BLOOM_FBO);
982 glBindFramebuffer(GL_FRAMEBUFFER, BLOOM_FBO);
983 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, BLOOM_TEXTURE, 0);
984
985 glGenTextures(1, &BLUR_TEXTURE);
986 glBindTexture(GL_TEXTURE_2D, BLUR_TEXTURE);
987 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, BLOOM_WIDTH, BLOOM_HEIGHT, 0, GL_RGBA, GL_FLOAT, NULL);
988 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
989 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
990 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
991 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
992
993 glGenFramebuffers(1, &BLUR_FBO);
994 glBindFramebuffer(GL_FRAMEBUFFER, BLUR_FBO);
995 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, BLUR_TEXTURE, 0);
996
997 glGenTextures(1, &BLOOM2_TEXTURE);
998 glBindTexture(GL_TEXTURE_2D, BLOOM2_TEXTURE);
999 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, BLOOM2_WIDTH, BLOOM2_HEIGHT, 0, GL_RGBA, GL_FLOAT, NULL);
1000 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1001 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1002 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1003 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1004
1005 glGenFramebuffers(1, &BLOOM2_FBO);
1006 glBindFramebuffer(GL_FRAMEBUFFER, BLOOM2_FBO);
1007 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, BLOOM2_TEXTURE, 0);
1008
1009 glGenTextures(1, &BLUR2_TEXTURE);
1010 glBindTexture(GL_TEXTURE_2D, BLUR2_TEXTURE);
1011 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, BLOOM2_WIDTH, BLOOM2_HEIGHT, 0, GL_RGBA, GL_FLOAT, NULL);
1012 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1013 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1014 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1015 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1016
1017 glGenFramebuffers(1, &BLUR2_FBO);
1018 glBindFramebuffer(GL_FRAMEBUFFER, BLUR2_FBO);
1019 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, BLUR2_TEXTURE, 0);
1020
1021 glGenTextures(1, &HISTORY_TEXTURE[0]);
1022 glBindTexture(GL_TEXTURE_2D, HISTORY_TEXTURE[0]);
1023 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, BLOOM_WIDTH, BLOOM_HEIGHT, 0, GL_RGBA, GL_FLOAT, NULL);
1024 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1025 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1026 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1027 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1028
1029 glGenFramebuffers(1, &HISTORY_FBO[0]);
1030 glBindFramebuffer(GL_FRAMEBUFFER, HISTORY_FBO[0]);
1031 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, HISTORY_TEXTURE[0], 0);
1032
1033 glGenTextures(1, &HISTORY_TEXTURE[1]);
1034 glBindTexture(GL_TEXTURE_2D, HISTORY_TEXTURE[1]);
1035 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, BLOOM_WIDTH, BLOOM_HEIGHT, 0, GL_RGBA, GL_FLOAT, NULL);
1036 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1037 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1038 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1039 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1040
1041 glGenFramebuffers(1, &HISTORY_FBO[1]);
1042 glBindFramebuffer(GL_FRAMEBUFFER, HISTORY_FBO[1]);
1043 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, HISTORY_TEXTURE[1], 0);
1044
1045 printf("SSBO\n");
1046
1047 glGenBuffers(1, &CAM_UBO);
1048 glBindBuffer(GL_UNIFORM_BUFFER, CAM_UBO);
1049 glBufferData(GL_UNIFORM_BUFFER, sizeof(CamData), NULL, GL_DYNAMIC_DRAW);
1050 glBindBufferBase(GL_UNIFORM_BUFFER, 0, CAM_UBO);
1051
1052 glGenBuffers(1, &SPACE_CAM_UBO);
1053 glBindBuffer(GL_UNIFORM_BUFFER, SPACE_CAM_UBO);
1054 glBufferData(GL_UNIFORM_BUFFER, sizeof(CamData), NULL, GL_DYNAMIC_DRAW);
1055 glBindBufferBase(GL_UNIFORM_BUFFER, 1, SPACE_CAM_UBO);
1056
1057 glGenBuffers(1, &RENDER_UBO);
1058 glBindBuffer(GL_UNIFORM_BUFFER, RENDER_UBO);
1060 glBufferData(GL_UNIFORM_BUFFER, sizeof(RenderData), &res, GL_DYNAMIC_DRAW);
1061 glBindBufferBase(GL_UNIFORM_BUFFER, 2, RENDER_UBO);
1062
1063 glGenBuffers(1, &PARTICLE_SSBO);
1064 glBindBuffer(GL_SHADER_STORAGE_BUFFER, PARTICLE_SSBO);
1065 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(ParticleData), NULL, GL_DYNAMIC_DRAW);
1066 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, PARTICLE_SSBO);
1067
1068 glGenBuffers(1, &MORTON_SSBO);
1069 glBindBuffer(GL_SHADER_STORAGE_BUFFER, MORTON_SSBO);
1070 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(MortonData), NULL, GL_DYNAMIC_DRAW);
1071 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, MORTON_SSBO);
1072
1073 glGenBuffers(1, &MORTON_PING_SSBO);
1074 glBindBuffer(GL_SHADER_STORAGE_BUFFER, MORTON_PING_SSBO);
1075 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(MortonData), NULL, GL_DYNAMIC_DRAW);
1076 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, MORTON_PING_SSBO);
1077
1078 glGenBuffers(1, &NODE_SSBO);
1079 glBindBuffer(GL_SHADER_STORAGE_BUFFER, NODE_SSBO);
1080 glBufferStorage(GL_SHADER_STORAGE_BUFFER, sizeof(NodeData), NULL, GL_MAP_READ_BIT);
1081 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, NODE_SSBO);
1082
1083 glGenBuffers(1, &BOUNDS_SSBO);
1084 glBindBuffer(GL_SHADER_STORAGE_BUFFER, BOUNDS_SSBO);
1085 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(BoundsData), NULL, GL_DYNAMIC_DRAW);
1086 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 5, BOUNDS_SSBO);
1087
1088 glGenBuffers(1, &NODE_COUNTER_SSBO);
1089 glBindBuffer(GL_SHADER_STORAGE_BUFFER, NODE_COUNTER_SSBO);
1090 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(NodeCounter), NULL, GL_DYNAMIC_DRAW);
1091 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 6, NODE_COUNTER_SSBO);
1092
1093 glGenBuffers(1, &RADIX_SSBO);
1094 glBindBuffer(GL_SHADER_STORAGE_BUFFER, RADIX_SSBO);
1095 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(RadixData), NULL, GL_DYNAMIC_DRAW);
1096 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 7, RADIX_SSBO);
1097
1098 glGenBuffers(1, &MARCHING_CUBES_SSBO);
1099 glBindBuffer(GL_SHADER_STORAGE_BUFFER, MARCHING_CUBES_SSBO);
1100
1102 memset(&DD, 0, sizeof(DD));
1104 memcpy(DD.EDGE_TABLE, EDGE_TABLE, sizeof(EDGE_TABLE));
1105 memcpy(DD.TRIANGLE_TABLE, TRIANGLE_TABLE, sizeof(TRIANGLE_TABLE));
1106
1107 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(MarchingCubesData), &DD, GL_DYNAMIC_DRAW);
1108 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 8, MARCHING_CUBES_SSBO);
1109
1110 for (int i = 0; i < LODMAX; i++)
1111 {
1112 glGenBuffers(1, &DENSITY_SSBO[i]);
1113 glBindBuffer(GL_SHADER_STORAGE_BUFFER, DENSITY_SSBO[i]);
1114
1115 LOD_DENSITY_SIZES[i] = (LOD_RES[i]+1) * (LOD_RES[i]+1) * (LOD_RES[i]+1) * MAX_CHUNKS_LOD[i];
1116 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(float) * LOD_DENSITY_SIZES[i], NULL, GL_DYNAMIC_DRAW);
1117
1118
1119 }
1120 for (int i = 0; i < LODMAX; i++)
1121 {
1122
1123 glGenBuffers(1, &DENSITY_VERTEX_SSBO[i]);
1124 glBindBuffer(GL_SHADER_STORAGE_BUFFER, DENSITY_VERTEX_SSBO[i]);
1125
1126 // 12 = number of edges, 6 = 2 quads
1127 LOD_VERTEX_SIZES[i] = (((LOD_RES[i]) * (LOD_RES[i]) * (LOD_RES[i]) * 15) + ((LOD_RES[i] + 2) * 12 * 6)) * MAX_CHUNKS_LOD[i];
1128 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(int) * MAX_CHUNKS + LOD_VERTEX_SIZES[i] * sizeof(Vertex), NULL, GL_DYNAMIC_DRAW);
1129 }
1130
1131
1132
1133 // This is sort of still a problem. Because of our drivers not supporting persistent mapping, we need to consistently map buffers to check for empty chunks.
1134 // There has to be some workaround for it but I haven't found it.
1135 for (int i = 0; i < 3; i++)
1136 {
1137
1138 glGenBuffers(1, &CHUNK_DATA_SSBO[i]);
1139 GPUChunk chunk;
1140 memset(&chunk, -1, sizeof(chunk));
1141 chunk.lod_dist[0] = CHUNK_WORLD_SIZE * 2 - 1e-4;
1142 chunk.lod_dist[1] = CHUNK_WORLD_SIZE * 4 - 1e-4;
1143 chunk.lod_dist[2] = CHUNK_WORLD_SIZE * 6 - 1e-4;
1144 chunk.emitted_chunks = 0;
1145
1146
1147 glBindBuffer(GL_SHADER_STORAGE_BUFFER, CHUNK_DATA_SSBO[i]);
1148 glBufferStorage(GL_SHADER_STORAGE_BUFFER, sizeof(GPUChunk), &chunk, GL_DYNAMIC_STORAGE_BIT | GL_MAP_READ_BIT);
1149 // glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(GPUChunk), &chunk, GL_DYNAMIC_DRAW);
1150 // CHUNK_DATA_PTR[i] = glMapBufferRange(
1151 // GL_SHADER_STORAGE_BUFFER,
1152 // offsetof(GPUChunk, vertex_counts),
1153 // sizeof(int) * LODMAX * MAX_CHUNKS,
1154 // GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT
1155 // );
1156
1157 }
1158
1159 CHUNK_DATA_FLAG = 0;
1160 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 12, CHUNK_DATA_SSBO[CHUNK_DATA_FLAG]);
1161
1162 PLANET_DATA.sun_dir = (vec4){0.1, 0.2, -0.8, 0.0};
1163 PLANET_DATA.sun_color = (vec4){1.0, 0.7, 0.5, 1.0f};
1165 PLANET_DATA.warp_layers[0].offset0 = (vec3){0, 0, 0};
1166 PLANET_DATA.warp_layers[0].freq0 = 0.001f;
1167 PLANET_DATA.warp_layers[0].offset1 = (vec3){1, 1, 1};
1168 PLANET_DATA.warp_layers[0].freq1 = 0.001f;
1169 PLANET_DATA.warp_layers[0].offset2 = (vec3){5, 5, 5};
1170 PLANET_DATA.warp_layers[0].freq2 = 0.001f;
1171 PLANET_DATA.warp_layers[0].amp = 0.0f;
1173 PLANET_DATA.perlin_layers[0].freq = 0.001f;
1174 PLANET_DATA.perlin_layers[0].amp = 50.0f;
1175 PLANET_DATA.perlin_layers[1].freq = 0.0025f;
1176 PLANET_DATA.perlin_layers[1].amp = 1.0f;
1177 PLANET_DATA.perlin_layers[2].freq = 0.0005f;
1178 PLANET_DATA.perlin_layers[2].amp = 5.0f;
1179 PLANET_DATA.perlin_layers[3].freq = 0.0001f;
1180 PLANET_DATA.perlin_layers[3].amp = 8.0f;
1182 PLANET_DATA.fbm_layers[0].freq = 0.0005f;
1183 PLANET_DATA.fbm_layers[0].amp = 10.0f;
1184
1185 glGenBuffers(1, &PLANET_DATA_SSBO);
1186 glBindBuffer(GL_SHADER_STORAGE_BUFFER, PLANET_DATA_SSBO);
1187 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(PlanetData), &PLANET_DATA, GL_DYNAMIC_DRAW);
1188 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 13, PLANET_DATA_SSBO);
1189
1190 glGenBuffers(1, &WATER_SSBO);
1191 glBindBuffer(GL_SHADER_STORAGE_BUFFER, WATER_SSBO);
1192 glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(WaterData), &WATER_DATA, GL_DYNAMIC_DRAW);
1193 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 14, WATER_SSBO);
1194
1195 printf("Shaders\n");
1196 init_shaders();
1197
1198 MAIN_COMPUTE_SHADER = create_compute_shader("./src/particles/main.comp");
1199 ZERO_COMPUTE_SHADER = create_compute_shader("./src/particles/zero.comp");
1200 CHUNK_ZERO_COMPUTE_SHADER = create_compute_shader("./src/mesh/chunk_zero.comp");
1201 BOUNDS_COMPUTE_SHADER = create_compute_shader("./src/particles/bounds.comp");
1202 MORTON_COMPUTE_SHADER = create_compute_shader("./src/particles/morton.comp");
1203 RADIX_COMPUTE_SHADER = create_compute_shader("./src/particles/radix_new.comp");
1204 RADIX_GLOBAL_COMPUTE_SHADER = create_compute_shader("./src/particles/radix_global.comp");
1205 RADIX_FINAL_COMPUTE_SHADER = create_compute_shader("./src/particles/radix_scatter.comp");
1206 TREE_COMPUTE_SHADER = create_compute_shader("./src/particles/tree.comp");
1207 TREE_COUNT_COMPUTE_SHADER = create_compute_shader("./src/particles/treecount.comp");
1208 COM_COMPUTE_SHADER = create_compute_shader("./src/particles/com22.comp");
1209 NEXT_COMPUTE_SHADER = create_compute_shader("./src/particles/next.comp");
1210 SPAWN_COMPUTE_SHADER = create_compute_shader("./src/particles/spawn.comp");
1211 POS_COMPUTE_SHADER = create_compute_shader("./src/particles/pos.comp");
1212 WATER_COMPUTE_SHADER = create_compute_shader("./src/FFT/water.comp");
1213 BIT_REVERSAL_COMPUTE_SHADER = create_compute_shader("./src/FFT/bit_reversal.comp");
1214 WATER_FFT_COMPUTE_SHADER = create_compute_shader("./src/FFT/fft.comp");
1215
1216 printf("Vertices\n");
1217 glGenVertexArrays(1, &SKY_VAO);
1218 glBindVertexArray(SKY_VAO);
1219 glGenBuffers(1, &SKY_VBO);
1220 glBindBuffer(GL_ARRAY_BUFFER, SKY_VBO);
1221
1222 float skyboxVertices[] = {
1223
1224 -1.0f, 1.0f, -1.0f,
1225 -1.0f, -1.0f, -1.0f,
1226 1.0f, -1.0f, -1.0f,
1227 1.0f, -1.0f, -1.0f,
1228 1.0f, 1.0f, -1.0f,
1229 -1.0f, 1.0f, -1.0f,
1230
1231 -1.0f, -1.0f, 1.0f,
1232 -1.0f, -1.0f, -1.0f,
1233 -1.0f, 1.0f, -1.0f,
1234 -1.0f, 1.0f, -1.0f,
1235 -1.0f, 1.0f, 1.0f,
1236 -1.0f, -1.0f, 1.0f,
1237
1238 1.0f, -1.0f, -1.0f,
1239 1.0f, -1.0f, 1.0f,
1240 1.0f, 1.0f, 1.0f,
1241 1.0f, 1.0f, 1.0f,
1242 1.0f, 1.0f, -1.0f,
1243 1.0f, -1.0f, -1.0f,
1244
1245 -1.0f, -1.0f, 1.0f,
1246 -1.0f, 1.0f, 1.0f,
1247 1.0f, 1.0f, 1.0f,
1248 1.0f, 1.0f, 1.0f,
1249 1.0f, -1.0f, 1.0f,
1250 -1.0f, -1.0f, 1.0f,
1251
1252 -1.0f, 1.0f, -1.0f,
1253 1.0f, 1.0f, -1.0f,
1254 1.0f, 1.0f, 1.0f,
1255 1.0f, 1.0f, 1.0f,
1256 -1.0f, 1.0f, 1.0f,
1257 -1.0f, 1.0f, -1.0f,
1258
1259 -1.0f, -1.0f, -1.0f,
1260 -1.0f, -1.0f, 1.0f,
1261 1.0f, -1.0f, -1.0f,
1262 1.0f, -1.0f, -1.0f,
1263 -1.0f, -1.0f, 1.0f,
1264 1.0f, -1.0f, 1.0f
1265
1266 };
1267
1268 glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 36 * 3, skyboxVertices, GL_STATIC_DRAW);
1269
1270
1271 // Skybox
1272 size_t sky_stride = sizeof(float) * 3;
1273 // pos
1274 glEnableVertexAttribArray(0);
1275 glVertexAttribPointer(0, 3, GL_FLOAT, 0, sky_stride, (void *)(uintptr_t)0);
1276
1277 // Particle VAO
1278 glGenVertexArrays(1, &MAIN_VAO);
1279 glBindVertexArray(MAIN_VAO);
1280 glGenBuffers(1, &MAIN_VBO);
1281 glBindBuffer(GL_ARRAY_BUFFER, MAIN_VBO);
1282
1283 size_t main_stride = sizeof(float) * 6;
1284 // pos
1285 glEnableVertexAttribArray(0);
1286 glVertexAttribPointer(0, 3, GL_FLOAT, 0, main_stride, (void *)(uintptr_t)0);
1287 // vel
1288 glEnableVertexAttribArray(1);
1289 glVertexAttribPointer(1, 3, GL_FLOAT, 0, main_stride, (void *)(uintptr_t)(sizeof(float) * 3));
1290
1291 // Mesh VAO
1292 glGenVertexArrays(1, &MESH_VAO);
1293 glBindVertexArray(MESH_VAO);
1294 glGenBuffers(1, &MESH_VBO);
1295 glBindBuffer(GL_ARRAY_BUFFER, MESH_VBO);
1296 glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex) * MESH_RES * MESH_RES * 6 * 10, NULL, GL_DYNAMIC_DRAW);
1297
1298 glGenBuffers(1, &MESH_EBO);
1299 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, MESH_EBO);
1300 glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32_t) * MESH_RES * MESH_RES * 6 * 10, NULL, GL_DYNAMIC_DRAW);
1301
1302 size_t mesh_stride = sizeof(float) * 9;
1303 // pos
1304 glEnableVertexAttribArray(0);
1305 glVertexAttribPointer(0, 3, GL_FLOAT, 0, mesh_stride, (void *)(uintptr_t)0);
1306 // normal
1307 glEnableVertexAttribArray(1);
1308 glVertexAttribPointer(1, 3, GL_FLOAT, 0, mesh_stride, (void *)(uintptr_t)(sizeof(float) * 3));
1309 // color
1310 glEnableVertexAttribArray(2);
1311 glVertexAttribPointer(2, 3, GL_FLOAT, 0, mesh_stride, (void *)(uintptr_t)(sizeof(float) * 6));
1312
1313 // Atmosphere VAO
1314 glGenVertexArrays(1, &ATMOSPHERE_VAO);
1315 glBindVertexArray(ATMOSPHERE_VAO);
1316 glGenBuffers(1, &ATMOSPHERE_VBO);
1317 glBindBuffer(GL_ARRAY_BUFFER, ATMOSPHERE_VBO);
1318 glBufferData(GL_ARRAY_BUFFER, sizeof(AtmosphereVertex) * ATMOSPHERE_RES * ATMOSPHERE_RES * 6 * 10, NULL, GL_DYNAMIC_DRAW);
1319
1320 glGenBuffers(1, &ATMOSPHERE_EBO);
1321 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ATMOSPHERE_EBO);
1322 glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32_t) * ATMOSPHERE_RES * ATMOSPHERE_RES * 6 * 10, NULL, GL_DYNAMIC_DRAW);
1323
1324 size_t atmosphere_stride = sizeof(float) * 6;
1325 // pos
1326 glEnableVertexAttribArray(0);
1327 glVertexAttribPointer(0, 3, GL_FLOAT, 0, atmosphere_stride, (void *)(uintptr_t)0);
1328 // normal
1329 glEnableVertexAttribArray(1);
1330 glVertexAttribPointer(1, 3, GL_FLOAT, 0, atmosphere_stride, (void *)(uintptr_t)(sizeof(float) * 3));
1331
1332 // Water VAO
1333 glGenVertexArrays(1, &WATER_VAO);
1334 glBindVertexArray(WATER_VAO);
1335
1336 water_quad_count= (WATER_RES - 1) * (WATER_RES - 1);
1338
1339 // Water Plane Vertex Generation
1340 // simply makes a horizontal plane so we can interpolate during runtime
1341 uint32_t* indices = malloc(sizeof(uint32_t) * water_index_count);
1342 int i = 0;
1343 WaterVertex * vertices = malloc(sizeof(WaterVertex) * WATER_RES * WATER_RES);
1344 for (int y = 0; y < WATER_RES; y++)
1345 for (int x = 0; x < WATER_RES; x++)
1346 {
1347
1348 float u = (x + 0.5f) / WATER_RES;
1349 float v = (y + 0.5f) / WATER_RES;
1350
1351 vertices[y * WATER_RES + x].pos = (vec3){
1352 u - 0.5f,
1353 v - 0.5f,
1354 0.0f
1355 };
1356
1357 }
1358 for (int y = 0; y < WATER_RES-1; y++)
1359 for (int x = 0; x < WATER_RES-1; x++)
1360 {
1361
1362 int i0 = y * WATER_RES + x;
1363 int i1 = i0 + 1;
1364 int i2 = i0 + WATER_RES;
1365 int i3 = i2 + 1;
1366
1367 indices[i++] = i0;
1368 indices[i++] = i2;
1369 indices[i++] = i1;
1370
1371 indices[i++] = i1;
1372 indices[i++] = i2;
1373 indices[i++] = i3;
1374 }
1375
1376 glGenBuffers(1, &WATER_VBO);
1377 glBindBuffer(GL_ARRAY_BUFFER, WATER_VBO);
1378 glBufferData(GL_ARRAY_BUFFER, sizeof(WaterVertex) * WATER_RES * WATER_RES, vertices, GL_STATIC_DRAW);
1379 size_t water_stride = sizeof(float) * 3;
1380 glEnableVertexAttribArray(0);
1381 glVertexAttribPointer(0, 3, GL_FLOAT, 0, water_stride, (void *)(uintptr_t)0);
1382
1383 glGenBuffers(1, &WATER_EBO);
1384 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, WATER_EBO);
1385 glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32_t) * water_index_count, indices, GL_STATIC_DRAW);
1386
1387 free(vertices);
1388 free(indices);
1389
1390 // Chunk Indirect Buffers
1391 // Used to hold per-chunk vertices and data
1392 // for (int l = 0; l < LODMAX; l++)
1393 // {
1394 // for (int i = 0; i < MAX_CHUNKS_LOD[l]; i++)
1395 // {
1396 // glGenBuffers(1, &INDIRECT_BUFFER[l][i]);
1397
1398 // glBindBuffer(GL_DRAW_INDIRECT_BUFFER, INDIRECT_BUFFER[l][i]);
1399 // glBufferData(GL_DRAW_INDIRECT_BUFFER,
1400 // sizeof(DrawArraysIndirectCommand),
1401 // NULL,
1402 // GL_DYNAMIC_DRAW);
1403
1404 // CHUNK_DATA[l][i].free = true;
1405 // CHUNK_DATA[l][i].is_child = false;
1406 // CHUNK_DATA[l][i].uID = -1;
1407 // CHUNK_DATA[l][i].id0 = -1;
1408 // CHUNK_DATA[l][i].id1 = -1;
1409
1410 // }
1411
1412 // }
1413
1414 glGenVertexArrays(1, &FS_VAO);
1415 init_random();
1417
1418 return true;
1419}
in vec3 t0
#define N
const float radius
Definition camera.c:580
#define LODMAX
float fbm(vec3 x)
Definition density.comp:139
uniform int stage
Definition fft.comp:14
GLuint ATMOSPHERE_VBO
Definition main.c:183
void init_chunk_data()
Initializes and frees old ChunkData and hash tables.
Definition mesh.c:796
int LOD_VERTEX_SIZES[LODMAX]
Definition main.c:65
int LOD_DENSITY_SIZES[LODMAX]
Definition main.c:64
void init_water_grid(int N, int L, float A)
Initializes the water grid at the start of the simulation with a wind direction.
Definition init.c:197
void fft_textures(GLuint pi, GLuint po)
Performs a bit reversal and FFTs the water group.
Definition init.c:275
void update_water_fft(float t)
Updates the water grid and FFTs it once per frame.
Definition init.c:323
GLuint WATER_FFT_PING_TEXTURE
Definition main.c:100
void make_perm()
Definition init.c:477
GLuint load_texture(const char *path, GLenum iformat, GLenum format, GLenum type)
Definition init.c:20
float * perlin_tex
Definition init.c:610
float MASS
Definition init.c:112
float noise3d(vec3 p)
Definition init.c:508
float * phi
Definition init.c:174
struct nk_context * NK_CTX
Definition init.c:170
int permutations[PERLIN_TEXTURE_SIZE]
Definition init.c:474
float angular_velocity(vec2 pos, vec2 w, float len2)
Definition init.c:257
WaterData WATER_DATA
Definition init.c:187
void init_random()
Definition init.c:115
float * fbm_tex
Definition init.c:346
vec4 * water_fft_arr
Definition init.c:173
bool NUKLEAR_HOVERED
Definition init.c:171
float rand_normal()
Definition init.c:177
float power_law(float min_m, float max_m, float alpha)
Definition init.c:103
GLuint load_cubemap(const char *path)
Definition init.c:58
void precompute_fbm_texture()
Definition init.c:350
vec3 gradients[12]
Definition init.c:497
float worley(vec3 p)
Definition init.c:401
float fade(float t)
Definition init.c:472
GLuint * CURRENT_WATER_FFT_TEXTURE
Definition init.c:265
bool init(SDL_Window **window, SDL_GLContext *context)
Definition init.c:660
vec4 * worley_tex
Definition init.c:377
void init_globals()
Definition init.c:644
void precompute_worley_texture()
Definition init.c:434
void precompute_perlin_texture()
Definition init.c:613
vec3 random3(vec3 p)
Definition init.c:381
float wrap_256(float t)
Definition init.c:503
vec3 * out_arr
Definition init.c:264
GLuint SKY_FBO
Definition main.c:109
GLuint FS_VAO
Definition main.c:175
GLuint WATER_FFT_COMPUTE_SHADER
Definition main.c:159
GLuint RADIX_FINAL_COMPUTE_SHADER
Definition main.c:149
GLuint BLUR2_FBO
Definition main.c:115
GLuint MARCHING_CUBES_SSBO
Definition main.c:211
GLuint MAIN_TEXTURE
Definition main.c:74
GLuint PERLIN_TEXTURE
Definition main.c:92
GLuint WATER_VBO
Definition main.c:165
GLuint ID_TEXTURE
Definition main.c:81
GLuint TREE_COUNT_COMPUTE_SHADER
Definition main.c:151
GLuint PLANET_DATA_SSBO
Definition main.c:213
GLuint CUBEMAP_TEXTURE
Definition main.c:56
GLuint BLOOM_TEXTURE
Definition main.c:87
GLuint MAIN_COMPUTE_SHADER
Definition main.c:137
GLuint EXP_LOOKUP_TEXTURE
Definition main.c:78
int BLOOM2_HEIGHT
Definition main.c:47
GLuint ROCK_AO_TEXTURE
Definition main.c:54
GLuint NEXT_COMPUTE_SHADER
Definition main.c:154
GLuint SKY_CUBEMAP
Definition main.c:75
int CHUNK_DATA_FLAG
Definition main.c:69
GLuint RADIX_GLOBAL_COMPUTE_SHADER
Definition main.c:148
GLuint COMPOSITE_DEPTH_TEXTURE
Definition main.c:77
GLuint ATMOSPHERE_EBO
Definition main.c:184
GLuint HISTORY_TEXTURE[2]
Definition main.c:89
GLuint MAIN_VBO
Definition main.c:163
GLuint ROCK_DIFFUSE_TEXTURE
Definition main.c:52
GLuint WATER_FFT_PONG_TEXTURE_2
Definition main.c:103
ParticleData PD
Definition main.c:244
GLuint SPHERE_TEXTURE
Definition main.c:82
GLuint DENSITY_SSBO[LODMAX]
Definition main.c:209
GLuint BLOOM_FBO
Definition main.c:112
GLuint COMPOSITE_TEXTURE
Definition main.c:76
GLuint MAIN_VAO
Definition main.c:169
GLuint WATER_FFT_PING_TEXTURE_2
Definition main.c:102
GLuint CHUNK_ZERO_COMPUTE_SHADER
Definition main.c:141
GLuint SPAWN_COMPUTE_SHADER
Definition main.c:155
GLuint ATMOSPHERE_VAO
Definition main.c:185
GLuint PARTICLE_SSBO
Definition main.c:202
int SCREEN_WIDTH
Definition main.c:41
GLuint MORTON_SSBO
Definition main.c:203
int BLOOM_WIDTH
Definition main.c:44
GLuint WATER_VAO
Definition main.c:171
GLuint BIT_REVERSAL_COMPUTE_SHADER
Definition main.c:160
GLuint BLOOM2_FBO
Definition main.c:113
GLuint WATER_EBO
Definition main.c:166
GLuint WATER_COMPUTE_SHADER
Definition main.c:158
GLuint BLUR2_TEXTURE
Definition main.c:86
GLuint BOUNDS_COMPUTE_SHADER
Definition main.c:145
GLuint DENSITY_VERTEX_SSBO[LODMAX]
Definition main.c:210
GLuint HISTORY_FBO[2]
Definition main.c:111
GLuint SPACE_CAM_UBO
Definition main.c:198
GLuint TREE_COMPUTE_SHADER
Definition main.c:150
GLuint POS_COMPUTE_SHADER
Definition main.c:156
GLuint MORTON_PING_SSBO
Definition main.c:204
GLuint SHADOW_MAP_FBO
Definition main.c:116
GLuint SKY_VBO
Definition main.c:164
GLuint SKY_VAO
Definition main.c:170
int BLOOM_HEIGHT
Definition main.c:45
GLuint ROCK_SPECULAR_TEXTURE
Definition main.c:53
GLuint NODE_COUNTER_SSBO
Definition main.c:206
GLuint WATER_SSBO
Definition main.c:214
GLuint MAIN_FBO
Definition main.c:107
GLuint COMPOSITE_FBO
Definition init.h:63
GLuint FBM_TEXTURE
Definition main.c:93
GLuint CHUNK_DATA_SSBO[3]
Definition main.c:215
GLuint RADIX_SSBO
Definition main.c:208
GLuint NODE_SSBO
Definition main.c:207
GLuint MESH_VAO
Definition main.c:174
GLuint RADIX_COMPUTE_SHADER
Definition main.c:147
uint32_t water_quad_count
Definition main.c:167
GLuint SHADOW_MAP_TEXTURE
Definition main.c:94
GLuint BLOOM2_TEXTURE
Definition main.c:88
GLuint BLUR_TEXTURE
Definition main.c:84
GLuint MORTON_COMPUTE_SHADER
Definition main.c:146
PlanetData PLANET_DATA
Definition main.c:194
GLuint POSTPROCESS_FBO
Definition main.c:110
int BLOOM2_WIDTH
Definition main.c:46
uint32_t water_index_count
Definition main.c:168
GLuint CAM_UBO
Definition main.c:197
GLuint WORLEY_TEXTURE
Definition main.c:91
GLuint ROCK_NORMAL_TEXTURE
Definition main.c:51
GLuint DEPTH_TEXTURE
Definition main.c:83
GLuint RENDER_UBO
Definition main.c:199
GLuint BOUNDS_SSBO
Definition main.c:205
GLuint MESH_EBO
Definition main.c:173
GLuint ZERO_COMPUTE_SHADER
Definition main.c:144
GLuint MESH_VBO
Definition main.c:172
GLuint WATER_FFT_PONG_TEXTURE
Definition main.c:101
int SCREEN_HEIGHT
Definition main.c:42
GLuint BLUR_FBO
Definition main.c:114
GLuint COM_COMPUTE_SHADER
Definition main.c:152
GLuint POSTPROCESS_TEXTURE
Definition main.c:90
Globals GLOBALS
Definition main.c:39
Marching cubes static header with constants.
const int TRIANGLE_TABLE[256][16]
const int EDGE_TO_VERTICES[12][2]
const int EDGE_TABLE[256]
vec3 vec3_cross(vec3 a, vec3 b)
Definition mathf.h:27
float vec3_dot(vec3 a, vec3 b)
Definition mathf.h:101
float vec2_dot(vec2 a, vec2 b)
Definition mathf.h:104
#define MIN(a, b)
Definition mathf.h:193
vec3 vec3_normalize(vec3 v)
Definition mathf.h:7
vec3 vec3_scale(vec3 a, float b)
Definition mathf.h:39
vec3 vec3_sub(vec3 a, vec3 b)
Definition mathf.h:57
vec3 vec3_add(vec3 a, vec3 b)
Definition mathf.h:73
float vec3_length(vec3 v)
Definition mathf.h:107
bool s
Definition menu.c:6
const vec2 res
vec4 acc
Definition types.h:97
vec4 p_m
Definition types.h:94
vec4 mat
Definition types.h:95
vec3 vel
Definition main.h:10
shared uint temp[RADIX_SORT_BINS]
GLuint create_compute_shader(const char *filename)
Definition shaders.c:20
void init_shaders()
Definition shaders.c:498
vec4 water_data[WATER_FFT_TEXTURE_SIZE *WATER_FFT_TEXTURE_SIZE]
Definition types.h:428
float x
Definition types.h:45
int EDGE_TO_VERTICES[12][2]
Definition types.h:341
float w
Definition types.h:47
PerlinLayer perlin_layers[MAX_LAYERS]
Definition types.h:418
float z
Definition types.h:47
const int LOD_RES[LODMAX]
Definition types.h:299
bool particle_toggle
Definition types.h:266
vec4 sun_dir
Definition types.h:415
WarpLayer warp_layers[MAX_LAYERS]
Definition types.h:417
float mass_pow
Definition types.h:261
float x
Definition types.h:47
vec4 sun_color
Definition types.h:416
#define FBM_TEXTURE_SIZE
Definition types.h:510
float x
Definition main.h:5
int y
Definition types.h:48
#define CHUNK_WORLD_SIZE
Definition types.h:318
#define BODY_COUNT
Definition types.h:39
int fbm_count
Definition types.h:413
float y
Definition types.h:45
#define WATER_FFT_L
Definition types.h:424
float y
Definition types.h:47
int warp_count
Definition types.h:411
int perlin_count
Definition types.h:412
float y
Definition main.h:5
#define WORLEY_TEXTURE_SIZE
Definition types.h:509
const int MAX_CHUNKS_LOD[LODMAX]
Definition types.h:309
float radius
Definition types.h:262
#define SHADOW_MAP_SIZE
Definition types.h:42
#define WATER_RES
Definition types.h:471
int z
Definition types.h:48
#define MESH_RES
Definition types.h:501
#define MAX_CHUNKS
Definition types.h:182
float max_mass
Definition types.h:260
bool water_toggle
Definition types.h:265
float z
Definition main.h:5
int EDGE_TABLE[256]
Definition types.h:342
bool planet_meshing_toggle
Definition types.h:264
float lod_dist[3]
Definition types.h:494
#define PERLIN_TEXTURE_SIZE
Definition types.h:508
vec3 pos
Definition types.h:367
int x
Definition types.h:48
FBMLayer fbm_layers[MAX_LAYERS]
Definition types.h:419
uint32_t emitted_chunks
Definition types.h:495
float min_mass
Definition types.h:259
#define ATMOSPHERE_RES
Definition types.h:503
int TRIANGLE_TABLE[256][16]
Definition types.h:343
#define WATER_FFT_TEXTURE_SIZE
Definition types.h:423
bool sky_toggle
Definition types.h:267
Particle p[BODY_COUNT]
Definition types.h:137
Definition types.h:48
Definition types.h:49
Definition types.h:45
Definition main.h:5
Definition types.h:47
#define L
Definition water.comp:15
uniform float t
Definition water.comp:23
vec3 offset2
Definition types.h:378
float amp
Definition types.h:401
float freq0
Definition types.h:375
vec3 offset1
Definition types.h:376
float freq
Definition types.h:400
float amp
Definition types.h:391
float freq1
Definition types.h:377
float freq2
Definition types.h:379
vec3 offset0
Definition types.h:374
float amp
Definition types.h:380
float freq
Definition types.h:390