Space Sim
Loading...
Searching...
No Matches
main.c
Go to the documentation of this file.
1#include <GL/glew.h>
2#include <SDL2/SDL.h>
3#include <SDL2/SDL_events.h>
4#include <SDL2/SDL_mouse.h>
5#include <SDL2/SDL_render.h>
6#include <SDL2/SDL_scancode.h>
7#include <SDL2/SDL_timer.h>
8#include <SDL2/SDL_video.h>
9#include "core/camera.h"
10#include "core/init.h"
11#include "utilities/mathf.h"
12#include "core/menu.h"
13#include "mesh/mesh.h"
14#include "core/shaders.h"
15#include "core/types.h"
16#include <omp.h>
17#include <stdbool.h>
18#include <stddef.h>
19#include <stdint.h>
20#include <stdio.h>
21#include <assert.h>
22#include <immintrin.h>
23#include <stdalign.h>
24#include <stdlib.h>
25#include <time.h>
26
27#define DEFAULT_WIDTH 1280
28#define DEFAULT_HEIGHT 960
29#define STB_IMAGE_IMPLEMENTATION
30
31#include "stb/stb_image.h"
32
33#include "nk_config.h"
34#include "nuklear/nuklear.h"
35#include "nuklear/nuklear_sdl_gl3.h"
36#define MAX_VERTEX_MEMORY 512 * 1024
37#define MAX_ELEMENT_MEMORY 128 * 1024
38
40
41int SCREEN_WIDTH = 1280;
42int SCREEN_HEIGHT = 960;
43
44int BLOOM_WIDTH = 1280 / 2;
45int BLOOM_HEIGHT = 960 / 2;
46int BLOOM2_WIDTH = 1280 / 4;
47int BLOOM2_HEIGHT = 960 / 4;
48
49// Placeholder Textures
50// per planet type
55
57
62// Chunk Settings
66// Chunk Data
70
72
73// Textures
95
105
106// FBOs
107GLuint MAIN_FBO;
109GLuint SKY_FBO;
111GLuint HISTORY_FBO[2];
114GLuint BLUR_FBO;
117
118// Shaders
135
136// Compute Shaders
161
162// Buffers
163GLuint MAIN_VBO;
164GLuint SKY_VBO;
169GLuint MAIN_VAO;
170GLuint SKY_VAO;
172GLuint MESH_VBO;
173GLuint MESH_EBO;
174GLuint MESH_VAO;
175GLuint FS_VAO;
177
178
191
192
193
195
196// UBOs
197GLuint CAM_UBO;
200
201// SSBOs
216
217
218// Flag for if the application is running
219int running = 0;
220
221// Cameras (Swaps between because space coords != planet coords)
226float move_speed = 0.1f;
227
228// Delta time (frame)
229float dt;
230// Delta time (particles)
231float DT = 0.5f;
232
233// Rayleigh / Mie starting values
234float ESun = 20.0f;
235vec3 wavelength = {0.650f, 0.570f, 0.475f};
236vec3 cam_pos_world = {0.01f, 0.01f, 1.001f};
237vec3 sun_dir = {0.1f, 0.2f, -0.8f};
238vec3 sun_color = {1.0, 0.7, 0.5};
239float G = -0.88f;
240float fKr = 0.0025f;
241float fKm = 0.001f;
242
243// Particle data structures (SSBO)
246
247GLsync fence;
248
252
253
255bool display_menu = true;
256bool halt_chunks = false;
257
258// info based on current planet for mesh calculations
259bool is_on_planet = true;
261vec4 mat = (vec4){0, 0, 0, 0};
262float planet_radius = 1000;
279
281
282
283
284
285
286// initializes particle values to a solid distribution
287
288
289int frame = 0;
290uint32_t *level_flag_ptr = NULL;
291
292
293#define NUM_WORKGROUPS 128
294
295
296GLuint64 retrieve_gl_query(GLuint query)
297{
298 GLint available = 0;
299 glGetQueryObjectiv(query, GL_QUERY_RESULT_AVAILABLE, &available);
300 GLuint64 e = 0;
301 if (available)
302 {
303
304 glGetQueryObjectui64v(query, GL_QUERY_RESULT, &e);
305 }
306 return e;
307}
308
309// Particle simulation iteration
310
439void
441 ()
442
443{
444
445 glBeginQuery(GL_TIME_ELAPSED, bounds_queries[current_query_frame]);
446
447 // Zeros out certain values necessary for each iteration
448 glUseProgram(ZERO_COMPUTE_SHADER);
449 glDispatchCompute(1, 1, 1);
450 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
451
452 // Computes the bounds of all particles
453 glUseProgram(BOUNDS_COMPUTE_SHADER);
454 glDispatchCompute(
456 1,
457 1
458 );
459 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
460 glEndQuery(GL_TIME_ELAPSED);
461
462 glBeginQuery(GL_TIME_ELAPSED, morton_queries[current_query_frame]);
463 // Assigns mortons to each particle
464 glUseProgram(MORTON_COMPUTE_SHADER);
465 glDispatchCompute(
467 1,
468 1
469 );
470 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
471 glEndQuery(GL_TIME_ELAPSED);
472
473 glBeginQuery(GL_TIME_ELAPSED, radix_queries[current_query_frame]);
474 // Performs a radix sort over all mortons
475 int wg_count = (BODY_COUNT + NUM_WORKGROUPS - 1) / NUM_WORKGROUPS;
476 for (int i = 0; i < 8; i++) {
477
478 glUseProgram(RADIX_COMPUTE_SHADER);
479 glUniform1i(
480 glGetUniformLocation(
482 "iteration"
483 ),
484 i
485 );
486 glDispatchCompute(
488 1,
489 1
490 );
491 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
492
493 glUseProgram(RADIX_GLOBAL_COMPUTE_SHADER);
494 glUniform1i(
495 glGetUniformLocation(
497 "workgroup_count"
498 ),
499 wg_count
500 );
501
502 glDispatchCompute(1, 1, 1);
503 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
504
505 glUseProgram(RADIX_FINAL_COMPUTE_SHADER);
506 glUniform1i(
507 glGetUniformLocation(
509 "iteration"
510 ),
511 i
512 );
513 glDispatchCompute(
515 1,
516 1
517 );
518 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
519 }
520 glEndQuery(GL_TIME_ELAPSED);
521
522 // Initializes nodes and particles to values necessary for build
523 glBeginQuery(GL_TIME_ELAPSED, treecount_queries[current_query_frame]);
524 glUseProgram(TREE_COUNT_COMPUTE_SHADER);
525 glDispatchCompute(
527 1,
528 1
529 );
530 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
531 glEndQuery(GL_TIME_ELAPSED);
532
533 // Builds the LBVH
534 glBeginQuery(GL_TIME_ELAPSED, tree_queries[current_query_frame]);
535 glUseProgram(TREE_COMPUTE_SHADER);
536 glDispatchCompute(
538 1,
539 1
540 );
541 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
542 glEndQuery(GL_TIME_ELAPSED);
543
544 // Propagates mass from leaves up to the root at BODY_COUNT - 1
545 glBeginQuery(GL_TIME_ELAPSED, com_queries[current_query_frame]);
546 glUseProgram(COM_COMPUTE_SHADER);
547 glBindBuffer(GL_SHADER_STORAGE_BUFFER, NODE_SSBO);
548
549 uint32_t depth_offsets[MAX_DEPTH + 1];
550 memset(depth_offsets, 0, sizeof(depth_offsets));
551 depth_offsets[0] = BODY_COUNT;
552
553
554 for (int i = 0; i < MAX_DEPTH; i++) {
555 glUniform1i(
556 glGetUniformLocation(
558 "depth"
559 ),
560 i
561 );
562 glDispatchCompute(
564 1,
565 1
566 );
567
568 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
569 }
570
571 // Linearizes the tree by assigning a next index (the parent's right node) so we only have to traverse through left nodes
572 glUseProgram(NEXT_COMPUTE_SHADER);
573 for (int i = MAX_DEPTH - 1; i >= 0; i--) {
574
575 glUniform1i(glGetUniformLocation(NEXT_COMPUTE_SHADER, "depth"), i);
576 glDispatchCompute(
578 1,
579 1
580 );
581
582 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
583 }
584
585
586 glEndQuery(GL_TIME_ELAPSED);
587
588 // Calculates velocity and resolves collisions
589 glBeginQuery(GL_TIME_ELAPSED, main_queries[current_query_frame]);
590 glUseProgram(MAIN_COMPUTE_SHADER);
591 glDispatchCompute(
593 1,
594 1
595 );
596 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
597
598 // Spawns particles based on accretion
599
600 // Integrates positions
601 glUseProgram(POS_COMPUTE_SHADER);
602 glUniform1f(
603 glGetUniformLocation(
605 "DT"
606 ),
607 DT
608 );
609 glDispatchCompute(
611 1,
612 1
613 );
614 glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
615 glEndQuery(GL_TIME_ELAPSED);
616
617
618
619}
620
621// Process keyboard / mouse input
625void
627 ( SDL_Window **window )
628
629{
630
631 vec3 move_dir = {0};
632
633 Uint32 buttons = SDL_GetMouseState(NULL, NULL);
634 bool lmouse_down = buttons & SDL_BUTTON(SDL_BUTTON_LEFT);
635
636 // Selects a planet
637 if (lmouse_down && !NUKLEAR_HOVERED) {
638
639 if (GLOBALS.hovered_body != -1) {
640
642
643 Particle test;
644 glClientWaitSync(fence, GL_SYNC_FLUSH_COMMANDS_BIT, 60);
645 glBindBuffer(GL_SHADER_STORAGE_BUFFER, PARTICLE_SSBO);
646
647 Particle *ptr = glMapBufferRange(
648 GL_SHADER_STORAGE_BUFFER,
649 offsetof(ParticleData, p) + sizeof(Particle) * GLOBALS.selected_body,
650 sizeof(Particle), GL_MAP_READ_BIT
651 );
652
653 memcpy(&test, ptr, sizeof(Particle));
654 glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
655 planet_origin = (vec3){test.p_m.x, test.p_m.y, test.p_m.z};
656 mat = test.mat;
657
658 }
659
660 }
661
662
663 nk_input_begin(NK_CTX);
664
665 SDL_Event event;
666 while (SDL_PollEvent(&event)) {
667
668 if (!SDL_GetRelativeMouseMode()) {
669 nk_sdl_handle_event(&event);
670 }
671
672 // Exit
673 if (event.type == SDL_QUIT) running = 0;
674
675 // Look
676 if (event.type == SDL_MOUSEMOTION && SDL_GetRelativeMouseMode()) {
677
678 int dx = event.motion.xrel;
679 int dy = event.motion.yrel;
680
681 float sensitivity = 0.0012f;
682 current_cam->yaw -= dx * sensitivity;
683
684 current_cam->pitch -= dy * sensitivity;
685
686 float max_pitch = (M_PI / 2.0f);
687 float min_pitch = -(M_PI / 2.0f) + 0.01f;
689 SDL_clamp(current_cam->pitch, min_pitch, max_pitch);
690
691 }
692
693 }
694
695 nk_input_end(NK_CTX);
696
697 const Uint8 *keystates = SDL_GetKeyboardState(NULL);
698
699 // Exit
700 if (keystates[SDL_SCANCODE_ESCAPE]) running = 0;
701
702 // WASD
703 if (keystates[SDL_SCANCODE_W]) move_dir.x += 1.0f;
704 if (keystates[SDL_SCANCODE_S]) move_dir.x -= 1.0f;
705 if (keystates[SDL_SCANCODE_A]) move_dir.y += 1.0f;
706 if (keystates[SDL_SCANCODE_D]) move_dir.y -= 1.0f;
707
708 // Unlock mouse
709 if (keystates[SDL_SCANCODE_P]) {
710
711 SDL_SetWindowGrab(*window, SDL_FALSE);
712 SDL_SetRelativeMouseMode(SDL_FALSE);
713
714 }
715
716 // Lock mouse
717 if (keystates[SDL_SCANCODE_O]) {
718
719 SDL_SetWindowGrab(*window, SDL_TRUE);
720 SDL_SetRelativeMouseMode(SDL_TRUE);
721
722 }
723
724 // Old functionality for visualizing particles TODO
725 // if (keystates[SDL_SCANCODE_E]) look_at_selected_body();
726 // if (keystates[SDL_SCANCODE_TAB]) GLOBALS.lock_on = !GLOBALS.lock_on;
727
728 // Jump
729 if (keystates[SDL_SCANCODE_SPACE] && current_cam->on_ground) {
730
731 cam.cam_data.cam_vel.z += 0.1f;
732 cam.on_ground = false;
733
734 }
735
736 // Noclip
737 if (keystates[SDL_SCANCODE_T]) is_on_planet = !is_on_planet;
738
739 // Pause particle sim
740 if (keystates[SDL_SCANCODE_R]) {
741
742 if (GLOBALS.paused) {
743 DT = 0.05f;
744 GLOBALS.paused = false;
745 } else {
746 DT = 0;
747 GLOBALS.paused = true;
748 }
749
750 }
751
752 // Reload shaders
753 if (keystates[SDL_SCANCODE_Y]) init_shaders();
754
755 // Halt chunks
756 if (keystates[SDL_SCANCODE_U]) halt_chunks = !halt_chunks;
757
758 // Display menu
759 if (keystates[SDL_SCANCODE_Q]) display_menu = !display_menu;
760
761 // Apply velocity and resolve collisions
762 if (is_on_planet) {
763
766
767 } else {
768
769 apply_velocity(current_cam, move_dir, dt);
770
771 }
772
773}
774
775float uTime = 0;
778
779// Renders a planet from outside its atmosphere (Only used on selected planet)
780// I never really got the visual artifacts worked out on this, not sure what I'm missing
786void
788 ()
789
790{
791
793 glBindVertexArray(ATMOSPHERE_VAO);
794 glBindBuffer(GL_ARRAY_BUFFER, ATMOSPHERE_VBO);
795 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ATMOSPHERE_EBO);
796
797 // Moves cam into local planet space and scales by a realistic margin
798 float inner_radius = 1;
799 float outer_radius_factor = 1000;
800 cam_pos_world.z = (cam.cam_data.cam_pos.z - planet_origin.z) / outer_radius_factor;
801
804 );
805
806 // inner radius
807 // inner radius ** 2
809 inner_radius
810 );
812 inner_radius * inner_radius
813 );
814
815 // outer radius
816 // outer radius ** 2
817 float outer_radius = 1.1;
818 // float outer_radius = inner_radius + inner_radius * 0.2f;
820 outer_radius
821 );
823 outer_radius * outer_radius
824 );
825
826 vec3 inv;
827 inv.x = 1.0f / powf(wavelength.x, 4.0f);
828 inv.y = 1.0f / powf(wavelength.y, 4.0f);
829 inv.z = 1.0f / powf(wavelength.z, 4.0f);
831 inv.x, inv.y, inv.z
832 );
833
834 // fscale -> 1 / (outer radius - inner radius)
835 float fscale = 1 / (outer_radius - inner_radius);
837 fscale
838 );
839
840 const float fscaledepth = 1.0f;
841 // const float fscaledepth = 50;
842 // fscale / fscaledepth
844 fscale / fscaledepth
845 );
846
848 1 / fscaledepth
849 );
850
852 fscaledepth
853 );
854
855 // g
857 G
858 );
859
860 // g ** 2
862 G * G
863 );
864
865 // fKrESun
867 fKr * ESun
868 );
869
870 // fKmESun
872 fKm * ESun
873 );
874
875 // fKr4Pi
877 fKr * 4 * M_PI
878 );
879
880 // fKm4Pi
882 fKm * 4 * M_PI
883 );
884
885 // TODO cache these positions
886 glUniformMatrix4fv
887 (
888 glGetUniformLocation
889 (
891 "uFakeProj"
892 ),
893 1,
894 0,
895 (GLfloat *)&cam.cam_data.proj
896 );
897
898 glUniformMatrix4fv
899 (
901 1,
902 0,
903 (GLfloat *)&cam.cam_data.view
904 );
905
906 glUniform3f
907 (
908 glGetUniformLocation
909 (
911 "uCamPos"
912 ),
916 );
917
918 glDrawElements
919 (
920 GL_TRIANGLES,
922 GL_UNSIGNED_INT,
923 (const void *)0
924 );
925
926}
927
933void
935 ()
936
937{
938
939 glBeginQuery(GL_TIME_ELAPSED, atmosphere_queries[current_query_frame]);
940 glBindFramebuffer(GL_FRAMEBUFFER, SKY_FBO);
941 glFramebufferTexture2D(
942 GL_FRAMEBUFFER,
943 GL_COLOR_ATTACHMENT0,
944 GL_TEXTURE_CUBE_MAP,
946 0
947 );
948
949 glViewport(0, 0, 128, 128);
950 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
951
952 float yaws[6] = {0, M_PI, M_PI, M_PI, M_PI / 2.0f + M_PI, M_PI / 2.0f};
953 float pitches[6] = {0, 0, M_PI / 2.0f, -M_PI / 2.0f, 0, 0};
954 vec3 flips[6];
955 flips[0] = (vec3){0, 0, -1};
956 flips[1] = (vec3){0, 0, -1};
957 flips[2] = (vec3){0, -1, 0};
958 flips[3] = (vec3){0, -1, 0};
959 flips[4] = (vec3){0, 0, -1};
960 flips[5] = (vec3){0, 0, -1};
961
962 glUseProgram(ATMOSPHERE_SHADER.program);
963 glBindVertexArray(ATMOSPHERE_VAO);
964 glBindBuffer(GL_ARRAY_BUFFER, ATMOSPHERE_VBO);
965 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ATMOSPHERE_EBO);
966
967 float inner_radius = 1;
968 float outer_radius_factor = 1000;
970 (cam.cam_data.cam_pos.z - planet_origin.z) / outer_radius_factor;
971
972 glUniform3f(
975 );
976
977 // inner radius
978 // inner radius ** 2
979 glUniform1f(ATMOSPHERE_SHADER.uniforms[1].location,
980 inner_radius
981 );
982 glUniform1f(ATMOSPHERE_SHADER.uniforms[2].location,
983 inner_radius * inner_radius
984 );
985
986 // outer radius
987 // outer radius ** 2
988 float outer_radius = 1.1;
989 // float outer_radius = inner_radius + inner_radius * 0.2f;
990 glUniform1f(ATMOSPHERE_SHADER.uniforms[3].location,
991 outer_radius
992 );
993 glUniform1f(ATMOSPHERE_SHADER.uniforms[4].location,
994 outer_radius * outer_radius
995 );
996
997 vec3 inv;
998 inv.x = 1.0f / powf(wavelength.x, 4.0f);
999 inv.y = 1.0f / powf(wavelength.y, 4.0f);
1000 inv.z = 1.0f / powf(wavelength.z, 4.0f);
1001
1002 glUniform3f(ATMOSPHERE_SHADER.uniforms[5].location,
1003 inv.x, inv.y, inv.z
1004 );
1005
1006 float fscale = 1 / (outer_radius - inner_radius);
1007 // fscale -> 1 / (outer radius - inner radius)
1008 glUniform1f(ATMOSPHERE_SHADER.uniforms[6].location, fscale);
1009
1010 const float fscaledepth = 0.25f;
1011 // const float fscaledepth = 50;
1012 // fscale / fscaledepth
1013 glUniform1f(ATMOSPHERE_SHADER.uniforms[7].location,
1014 fscale / fscaledepth
1015 );
1016 glUniform1f(ATMOSPHERE_SHADER.uniforms[8].location,
1017 1 / fscaledepth
1018 );
1019 glUniform1f(ATMOSPHERE_SHADER.uniforms[9].location,
1020 fscaledepth
1021 );
1022
1023 // g
1024 glUniform1f(ATMOSPHERE_SHADER.uniforms[10].location,
1025 G
1026 );
1027 // g ** 2
1028 glUniform1f(ATMOSPHERE_SHADER.uniforms[11].location,
1029 G * G
1030 );
1031
1032 // fKrESun
1033 glUniform1f(ATMOSPHERE_SHADER.uniforms[12].location,
1034 fKr * ESun
1035 );
1036 // fKmESun
1037 glUniform1f(ATMOSPHERE_SHADER.uniforms[13].location,
1038 fKm * ESun
1039 );
1040 // fKr4Pi
1041 glUniform1f(ATMOSPHERE_SHADER.uniforms[14].location,
1042 fKr * 4 * M_PI
1043 );
1044 // fKm4Pi
1045 glUniform1f(ATMOSPHERE_SHADER.uniforms[15].location,
1046 fKm * 4 * M_PI
1047 );
1048
1049 mat4 proj = make_projection(90, 128.0f / 128.0f, 0.01, 100.0f);
1050
1051 for (int i = 0; i < 6; i++) {
1052 // cam.cam_data.cam_pos.z += 0.5f;
1053 glFramebufferTexture2D(
1054 GL_FRAMEBUFFER,
1055 GL_COLOR_ATTACHMENT0,
1056 GL_TEXTURE_CUBE_MAP_POSITIVE_X + i,
1058 0
1059 );
1060
1061 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1062
1063 Camera sky_cam;
1064 sky_cam.yaw = yaws[i];
1065 sky_cam.pitch = pitches[i];
1066
1067 compute_camera_basis(&sky_cam, flips[i]);
1068
1070 &sky_cam,
1071 (vec3){
1075 }
1076 );
1077
1078 glUniformMatrix4fv
1079 (
1080 glGetUniformLocation
1081 (
1083 "uFakeProj"
1084 ),
1085 1,
1086 0,
1087 (GLfloat *)&proj
1088 );
1089 glUniformMatrix4fv(
1091 1,
1092 0,
1093 (GLfloat *)&view
1094 );
1095 // glUniform1f(glGetUniformLocation(ATMOSPHERE_SHADER.program,
1096 // "uColor"), i);
1097 glUniform3f
1098 (
1099 glGetUniformLocation
1100 (
1102 "uCamPos"
1103 ),
1107 );
1108
1109 glDrawElements(
1110 GL_TRIANGLES,
1112 GL_UNSIGNED_INT,
1113 (const void *)0
1114 );
1115 }
1116
1117 glEndQuery(GL_TIME_ELAPSED);
1118
1119 glBeginQuery(GL_TIME_ELAPSED, clouds_queries[current_query_frame]);
1120 glUseProgram(CLOUDS_SHADER.program);
1121
1122 glActiveTexture(GL_TEXTURE0);
1123 glBindTexture(GL_TEXTURE_3D, PERLIN_TEXTURE);
1124 glActiveTexture(GL_TEXTURE1);
1125 glBindTexture(GL_TEXTURE_3D, FBM_TEXTURE);
1126 glActiveTexture(GL_TEXTURE2);
1127 glBindTexture(GL_TEXTURE_CUBE_MAP, SKY_CUBEMAP);
1128 glActiveTexture(GL_TEXTURE3);
1129 glBindTexture(GL_TEXTURE_3D, WORLEY_TEXTURE);
1130
1131 glUniform3f(CLOUDS_SHADER.uniforms[0].location,
1133 glUniform1f(CLOUDS_SHADER.uniforms[1].location,
1134 inner_radius);
1135 glUniform1i(CLOUDS_SHADER.uniforms[2].location,
1136 0);
1137 glUniform1i(CLOUDS_SHADER.uniforms[3].location,
1138 1);
1139 glUniformMatrix4fv(
1141 1, 0, (GLfloat *)&proj
1142 );
1143 glUniform1i(glGetUniformLocation(CLOUDS_SHADER.program, "uCubemap"),
1144 2
1145 );
1146 glUniform1i(glGetUniformLocation(CLOUDS_SHADER.program, "worley_tex"),
1147 3
1148 );
1149 glUniform1f(glGetUniformLocation(CLOUDS_SHADER.program, "uOuterRadius"),
1150 outer_radius
1151 );
1152 glUniform1f(glGetUniformLocation(CLOUDS_SHADER.program, "uPlanetRadius"),
1154 );
1155
1156 for (int i = 0; i < 6; i++) {
1157
1158 glFramebufferTexture2D(
1159 GL_FRAMEBUFFER,
1160 GL_COLOR_ATTACHMENT0,
1161 GL_TEXTURE_CUBE_MAP_POSITIVE_X + i,
1163 0
1164 );
1165
1166 Camera sky_cam;
1167 sky_cam.yaw = yaws[i];
1168 sky_cam.pitch = pitches[i];
1169
1170 compute_camera_basis(&sky_cam, flips[i]);
1171
1173 &sky_cam,
1174 (vec3){
1178 }
1179 );
1180
1181 glUniformMatrix4fv
1182 (
1184 1,
1185 0,
1186 (GLfloat *)&view
1187 );
1188
1189 glDrawElements(
1190 GL_TRIANGLES,
1192 GL_UNSIGNED_INT,
1193 (const void *)0
1194 );
1195 }
1196 glEndQuery(GL_TIME_ELAPSED);
1197}
1198
1203void
1205 ()
1206
1207{
1208
1209
1210 for (int l = 0; l < LODMAX; l++) {
1211
1213 glBindBufferBase(
1214 GL_SHADER_STORAGE_BUFFER,
1215 9,
1216 DENSITY_SSBO[l]
1217 );
1218 glBindBufferBase(
1219 GL_SHADER_STORAGE_BUFFER,
1220 10,
1222 );
1223
1224 int lid = 0;
1225 for (int i = 0; i < MAX_CHUNKS_LOD[l]; i++) {
1226
1227 if (CHUNK_DATA[l][i].free) continue;
1228
1229 bool child = true;
1230
1231 if ( CHUNK_DATA[l][i].id1 == -1 || !CHUNK_DATA[l][i].is_child )
1232 { child = false; }
1233
1234 if (child) continue;
1235
1236 glBindBuffer(GL_DRAW_INDIRECT_BUFFER, INDIRECT_BUFFER[l][i]);
1237 glUniform1i(MESH_SHADER.uniforms[11].location, child);
1238 glUniform1i(MESH_SHADER.uniforms[12].location, l);
1239 glUniform1i(glGetUniformLocation(MESH_SHADER.program, "cid"), lid++);
1240 glDrawArraysIndirect(GL_TRIANGLES, 0);
1241 }
1242 }
1243}
1244
1245
1246float wt = 0;
1247bool dirty_cubemap = false;
1248
1250bool selection_mode = false;
1251
1252
1256void
1258
1259{
1260
1261
1262 wt += 0.1f;
1263
1264 glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
1265
1266 cur_history ^= 1;
1267 glDisable(GL_BLEND);
1268 glDisable(GL_DEPTH_TEST);
1269 glDepthMask(GL_TRUE);
1270 glDepthFunc(GL_LEQUAL);
1271
1272 // Upload camera UBOs
1273 glBindBufferBase(GL_UNIFORM_BUFFER, 0, CAM_UBO);
1274 glBindBuffer(GL_UNIFORM_BUFFER, CAM_UBO);
1275 glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(CamData), &cam.cam_data);
1276 glBindBufferBase(GL_UNIFORM_BUFFER, 1, SPACE_CAM_UBO);
1277 glBindBuffer(GL_UNIFORM_BUFFER, SPACE_CAM_UBO);
1278 glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(CamData), &space_cam.cam_data);
1279 glBindBufferBase(GL_UNIFORM_BUFFER, 2, RENDER_UBO);
1280
1281 // if (dirty_cubemap)
1282 // {
1283
1284 // Update Sky Cubemap
1286
1288
1289 }
1290
1291 // dirty_cubemap = false;
1292 // }
1293
1294
1295
1296 /*
1297 SKY PASS
1298 Render Target:
1299 MAIN_TEXTURE on MAIN_FBO
1300 Using:
1301 SKY_VAO
1302 SKY_VBO
1303 SKY_SHADER
1304 SKY_CUBEMAP
1305 Desc:
1306 Draws the cubemap to the main framebuffer.
1307 */
1308
1309 glBeginQuery(GL_TIME_ELAPSED, particle_queries[current_query_frame]);
1310 glBindFramebuffer(GL_FRAMEBUFFER, MAIN_FBO);
1311 glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
1312 glClearColor(0, 0, 0, 1.0f);
1313 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1314
1315
1316 glEnable(GL_DEPTH_TEST);
1317 glDepthMask(GL_TRUE);
1318 glDepthFunc(GL_LEQUAL);
1319
1321
1322 glUseProgram(SKY_SHADER.program);
1323 glBindVertexArray(SKY_VAO);
1324 glBindBuffer(GL_ARRAY_BUFFER, SKY_VBO);
1325
1326 glActiveTexture(GL_TEXTURE0);
1327 glBindTexture(GL_TEXTURE_CUBE_MAP, SKY_CUBEMAP);
1328
1329 glUniform1i(SKY_SHADER.uniforms[0].location, 0);
1330
1331 glDrawArrays(GL_TRIANGLES, 0, 36);
1332
1333 }
1334 // else
1335 // {
1336 // // render_sky_from_outside_atmosphere();
1337
1338 // }
1339
1340
1341
1342 // If selection mode is enabled, this clears the id texture.
1343 if (selection_mode) {
1344 int n1 = -1;
1345 glClearTexImage(
1346 ID_TEXTURE,
1347 0,
1348 GL_RED_INTEGER,
1349 GL_INT,
1350 &n1
1351 );
1352 }
1353
1354 /*
1355 PARTICLE PASS
1356 Render Target:
1357 MAIN_TEXTURE on MAIN_FBO
1358 Using:
1359 MAIN_VAO
1360 MAIN_VBO
1361 MAIN_SHADER
1362 Desc:
1363 Draws the particles to the main framebuffer.
1364 Uses sky cubemap to overlay transparency.
1365 Draws as quads with cut edges.
1366 Draws particle IDs to the ID_TEXTURE to be used for selections.
1367 */
1368
1370 {
1371
1372 glUseProgram(MAIN_SHADER.program);
1373 glBindVertexArray(MAIN_VAO);
1374 glBindBuffer(GL_ARRAY_BUFFER, MAIN_VBO);
1375 glActiveTexture(GL_TEXTURE0);
1376 glBindTexture(GL_TEXTURE_2D, SPHERE_TEXTURE);
1377 glActiveTexture(GL_TEXTURE1);
1378 glBindTexture(GL_TEXTURE_3D, PERLIN_TEXTURE);
1379 glActiveTexture(GL_TEXTURE2);
1380 glBindTexture(GL_TEXTURE_3D, FBM_TEXTURE);
1381 glActiveTexture(GL_TEXTURE3);
1382 glBindTexture(GL_TEXTURE_CUBE_MAP, SKY_CUBEMAP);
1383
1384 GLuint attachments[] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1};
1385 glDrawBuffers(2, attachments);
1386
1387 glUniform1i(MAIN_SHADER.uniforms[0].location, 0);
1390 glUniform3f(MAIN_SHADER.uniforms[2].location, cam.right.x, cam.right.y,
1391 cam.right.z);
1392 glUniform3f(MAIN_SHADER.uniforms[3].location, cam.up.x, cam.up.y, cam.up.z);
1394 cam.forward.z);
1395 glUniform1i(glGetUniformLocation(MAIN_SHADER.program, "perlin_tex"), 1);
1396 glUniform1i(glGetUniformLocation(MAIN_SHADER.program, "fbm_tex"), 2);
1397 glUniform1i(glGetUniformLocation(MAIN_SHADER.program, "uSky"), 3);
1398
1399 glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, BODY_COUNT);
1400 }
1401 glEndQuery(GL_TIME_ELAPSED);
1402
1403 // ID Texture for particle selection
1404 // if (selection_mode) {
1405 // glMemoryBarrier(GL_TEXTURE_FETCH_BARRIER_BIT);
1406 // glReadBuffer(GL_COLOR_ATTACHMENT1);
1407 // glReadPixels(
1408 // SCREEN_WIDTH / 2,
1409 // SCREEN_HEIGHT / 2,
1410 // 1,
1411 // 1,
1412 // GL_RED_INTEGER,
1413 // GL_INT,
1414 // &GLOBALS.hovered_body
1415 // );
1416 // }
1417
1419
1420
1421 /*
1422 SHADOW PASS
1423 Render Target:
1424 SHADOW_MAP_TEXTURE on SHADOW_MAP_FBO
1425 Using:
1426 MESH_VAO
1427 MESH_VBO
1428 SHADOW_SHADER
1429 Desc:
1430 */
1431
1432 glBeginQuery(GL_TIME_ELAPSED, draw_queries[current_query_frame]);
1433 glDisable(GL_CULL_FACE);
1434 glBindFramebuffer(GL_FRAMEBUFFER, SHADOW_MAP_FBO);
1435 glClearColor(0, 0, 0, 0);
1436 glBindVertexArray(MESH_VAO);
1437 glViewport(0, 0, SHADOW_MAP_SIZE, SHADOW_MAP_SIZE);
1438 glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
1439 glClearColor(0, 0, 0, 1.0f);
1440
1441 glUseProgram(SHADOW_MAP_SHADER.program);
1442
1443 glUniformMatrix4fv(
1445 1,
1446 GL_FALSE,
1447 (GLfloat *)&LIGHT_CAM.cam_data.proj
1448 );
1449 glUniformMatrix4fv(
1451 1,
1452 GL_FALSE,
1453 (GLfloat *)&LIGHT_CAM.cam_data.view
1454 );
1455
1456 glUniform1f(
1457 glGetUniformLocation(SHADOW_MAP_SHADER.program, "uPlanetRadius"),
1459 );
1460
1461 glBindBuffer(GL_ARRAY_BUFFER, MESH_VBO);
1462 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, MESH_EBO);
1463
1464 glCullFace(GL_FRONT);
1465 // render_mesh_planet(true);
1466
1467 glDisable(GL_CULL_FACE);
1468 glBindVertexArray(WATER_VAO);
1469 glUseProgram(SHADOW_WATER_SHADER.program);
1470
1471 glActiveTexture(GL_TEXTURE0);
1472 glBindTexture(GL_TEXTURE_CUBE_MAP, CUBEMAP_TEXTURE);
1473 glActiveTexture(GL_TEXTURE3);
1474 glBindTexture(GL_TEXTURE_2D, WATER_FFT_PONG_TEXTURE);
1475 glActiveTexture(GL_TEXTURE4);
1476 glBindTexture(GL_TEXTURE_2D, WATER_FFT_PONG_TEXTURE_2);
1477 glActiveTexture(GL_TEXTURE5);
1478 glBindTexture(GL_TEXTURE_2D, SKY_TEXTURE);
1479 glActiveTexture(GL_TEXTURE6);
1480 glBindTexture(GL_TEXTURE_CUBE_MAP, SKY_CUBEMAP);
1481 glActiveTexture(GL_TEXTURE7);
1482 glBindTexture(GL_TEXTURE_2D, DEPTH_TEXTURE);
1483 glActiveTexture(GL_TEXTURE8);
1484 glBindTexture(GL_TEXTURE_2D, MAIN_TEXTURE);
1485 glActiveTexture(GL_TEXTURE9);
1486 glBindTexture(GL_TEXTURE_2D, EXP_LOOKUP_TEXTURE);
1487 glActiveTexture(GL_TEXTURE10);
1488 glBindTexture(GL_TEXTURE_3D, FBM_TEXTURE);
1489
1490 glBindBuffer(GL_ARRAY_BUFFER, WATER_VBO);
1491 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, WATER_EBO);
1492 glUniform1f(SHADOW_WATER_SHADER.uniforms[0].location, uTime);
1493 glUniform1i(SHADOW_WATER_SHADER.uniforms[1].location, 1);
1494 glUniform1i(SHADOW_WATER_SHADER.uniforms[2].location, 2);
1495 glUniform1i(SHADOW_WATER_SHADER.uniforms[3].location, 0);
1496 glUniform1i(SHADOW_WATER_SHADER.uniforms[4].location, 3);
1497 glUniform1i(SHADOW_WATER_SHADER.uniforms[5].location, 5);
1498 glUniform1i(SHADOW_WATER_SHADER.uniforms[6].location, 4);
1499 glUniform1i(glGetUniformLocation(SHADOW_WATER_SHADER.program, "uCubemap"),
1500 6);
1501 glUniform1i(glGetUniformLocation(SHADOW_WATER_SHADER.program, "uDepth"),
1502 7);
1503 glUniform1i(glGetUniformLocation(SHADOW_WATER_SHADER.program, "uScene"),
1504 8);
1505 glUniform1i(glGetUniformLocation(SHADOW_WATER_SHADER.program, "uExp"),
1506 9);
1507 glUniform1f(
1508 glGetUniformLocation(SHADOW_WATER_SHADER.program, "uPlanetRadius"),
1510 glUniform1i(
1511 glGetUniformLocation(SHADOW_WATER_SHADER.program, "fbm_tex"), 10);
1512
1513 // glDrawElements(GL_TRIANGLES, water_index_count, GL_UNSIGNED_INT, 0);
1514
1515 glEnable(GL_CULL_FACE);
1516 glCullFace(GL_FRONT);
1517 glEndQuery(GL_TIME_ELAPSED);
1518
1519 glBeginQuery(GL_TIME_ELAPSED, mesh_queries[current_query_frame]);
1520
1521 /*
1522 MESH PASS
1523 Render Target:
1524 MAIN_TEXTURE on MAIN_FBO
1525 Using:
1526 MESH_VAO
1527 MESH_VBO
1528 MESH_SHADER
1529 Desc:
1530 */
1531
1532 glBindFramebuffer(GL_FRAMEBUFFER, MAIN_FBO);
1533 glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
1535 {
1536 glUseProgram(MESH_SHADER.program);
1537
1538 glActiveTexture(GL_TEXTURE0);
1539 glBindTexture(GL_TEXTURE_3D, PERLIN_TEXTURE);
1540 glActiveTexture(GL_TEXTURE1);
1541 glBindTexture(GL_TEXTURE_2D, ROCK_NORMAL_TEXTURE);
1542 glActiveTexture(GL_TEXTURE2);
1543 glBindTexture(GL_TEXTURE_2D, ROCK_DIFFUSE_TEXTURE);
1544 glActiveTexture(GL_TEXTURE3);
1545 glBindTexture(GL_TEXTURE_2D, ROCK_SPECULAR_TEXTURE);
1546 glActiveTexture(GL_TEXTURE4);
1547 glBindTexture(GL_TEXTURE_2D, ROCK_AO_TEXTURE);
1548 glActiveTexture(GL_TEXTURE5);
1549 glBindTexture(GL_TEXTURE_2D, SHADOW_MAP_TEXTURE);
1550
1552 // glUniform1i(glGetUniformLocation(MESH_SHADER, "uSelected"), 1);
1555 glUniform1f(MESH_SHADER.uniforms[2].location, uTime);
1556 glUniform1i(MESH_SHADER.uniforms[3].location, 0);
1557 glUniform1i(MESH_SHADER.uniforms[4].location, 1);
1558 glUniform1i(MESH_SHADER.uniforms[5].location, 2);
1559 glUniform1i(MESH_SHADER.uniforms[6].location, 3);
1560 glUniform1i(MESH_SHADER.uniforms[7].location, 4);
1561 glUniform1i(MESH_SHADER.uniforms[8].location, 5);
1562 glUniformMatrix4fv(
1564 1,
1565 GL_FALSE,
1566 (GLfloat *)&LIGHT_CAM.cam_data.proj
1567 );
1568 glUniformMatrix4fv(
1570 1,
1571 GL_FALSE,
1572 (GLfloat *)&LIGHT_CAM.cam_data.view
1573 );
1574 glUniform1f(glGetUniformLocation(MESH_SHADER.program, "uPlanetRadius"),
1576 );
1577
1579 }
1580 glEndQuery(GL_TIME_ELAPSED);
1581 glDisable(GL_CULL_FACE);
1582
1583
1584 glBeginQuery(GL_TIME_ELAPSED, water_queries[current_query_frame]);
1585 /*
1586 WATER PASS
1587 Render Target:
1588 COMPOSITE_TEXTURE on COMPOSITE_FBO
1589 Using:
1590 WATER_VAO
1591 WATER_VBO
1592 WATER_SHADER
1593 Desc:
1594 */
1595
1596 glBindFramebuffer(GL_FRAMEBUFFER, COMPOSITE_FBO);
1597 glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
1598 glClearColor(0, 0, 0, 1.0f);
1599 glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
1601 {
1602
1603 glBindVertexArray(WATER_VAO);
1604 glUseProgram(WATER_SHADER.program);
1605
1606 glActiveTexture(GL_TEXTURE0);
1607 glBindTexture(GL_TEXTURE_CUBE_MAP, CUBEMAP_TEXTURE);
1608 glActiveTexture(GL_TEXTURE3);
1609 glBindTexture(GL_TEXTURE_2D, WATER_FFT_PONG_TEXTURE);
1610 glActiveTexture(GL_TEXTURE4);
1611 glBindTexture(GL_TEXTURE_2D, WATER_FFT_PONG_TEXTURE_2);
1612 glActiveTexture(GL_TEXTURE5);
1613 glBindTexture(GL_TEXTURE_2D, SKY_TEXTURE);
1614 glActiveTexture(GL_TEXTURE6);
1615 glBindTexture(GL_TEXTURE_CUBE_MAP, SKY_CUBEMAP);
1616 glActiveTexture(GL_TEXTURE7);
1617 glBindTexture(GL_TEXTURE_2D, DEPTH_TEXTURE);
1618 glActiveTexture(GL_TEXTURE8);
1619 glBindTexture(GL_TEXTURE_2D, MAIN_TEXTURE);
1620 glActiveTexture(GL_TEXTURE9);
1621 glBindTexture(GL_TEXTURE_2D, EXP_LOOKUP_TEXTURE);
1622 glActiveTexture(GL_TEXTURE10);
1623 glBindTexture(GL_TEXTURE_3D, FBM_TEXTURE);
1624 glActiveTexture(GL_TEXTURE11);
1625 glBindTexture(GL_TEXTURE_2D, SHADOW_MAP_TEXTURE);
1626
1627 glBindBuffer(GL_ARRAY_BUFFER, WATER_VBO);
1628 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, WATER_EBO);
1629 glUniform1f(WATER_SHADER.uniforms[0].location, uTime);
1630 glUniform1i(WATER_SHADER.uniforms[1].location, 1);
1631 glUniform1i(WATER_SHADER.uniforms[2].location, 2);
1632 glUniform1i(WATER_SHADER.uniforms[3].location, 0);
1633 glUniform1i(WATER_SHADER.uniforms[4].location, 3);
1634 glUniform1i(WATER_SHADER.uniforms[5].location, 5);
1635 glUniform1i(WATER_SHADER.uniforms[6].location, 4);
1636 glUniform1i(glGetUniformLocation(WATER_SHADER.program, "uCubemap"), 6);
1637 glUniform1i(glGetUniformLocation(WATER_SHADER.program, "uDepth"), 7);
1638 glUniform1i(glGetUniformLocation(WATER_SHADER.program, "uScene"), 8);
1639 glUniform1i(glGetUniformLocation(WATER_SHADER.program, "uExp"), 9);
1640 glUniform1f(glGetUniformLocation(WATER_SHADER.program, "uPlanetRadius"),
1642 glUniform1i(glGetUniformLocation(WATER_SHADER.program, "fbm_tex"), 10);
1643 glUniform1i(WATER_SHADER.uniforms[7].location, 11);
1644 glUniformMatrix4fv(WATER_SHADER.uniforms[8].location, 1, GL_FALSE,
1645 (GLfloat *)&LIGHT_CAM.cam_data.proj);
1646 glUniformMatrix4fv(WATER_SHADER.uniforms[9].location, 1, GL_FALSE,
1647 (GLfloat *)&LIGHT_CAM.cam_data.view);
1648
1649 glDrawElements(GL_TRIANGLES, water_index_count, GL_UNSIGNED_INT, 0);
1650 }
1651 glEndQuery(GL_TIME_ELAPSED);
1652
1653 }
1654
1655
1656
1657 /*
1658 POSTPROCESS PASS
1659 Render Target:
1660 DEFAULT_TEXTURE on DEFAULT_FBO
1661 Using:
1662 MAIN_VAO
1663 MAIN_VBO
1664 MAIN_SHADER
1665 Desc:
1666 */
1667 glBeginQuery(GL_TIME_ELAPSED, postprocess_queries[current_query_frame]);
1668 glBindFramebuffer(GL_FRAMEBUFFER, 0);
1669 glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
1670
1671 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1672 glUseProgram(POSTPROCESS_SHADER.program);
1673
1674 glActiveTexture(GL_TEXTURE0);
1675 glBindTexture(GL_TEXTURE_2D, MAIN_TEXTURE);
1676 glActiveTexture(GL_TEXTURE1);
1677 glBindTexture(GL_TEXTURE_2D, ID_TEXTURE);
1678 glActiveTexture(GL_TEXTURE2);
1679 glBindTexture(GL_TEXTURE_2D, DEPTH_TEXTURE);
1680 glActiveTexture(GL_TEXTURE3);
1681 glBindTexture(GL_TEXTURE_2D, BLOOM_TEXTURE);
1682 glActiveTexture(GL_TEXTURE4);
1683 glBindTexture(GL_TEXTURE_2D, BLOOM2_TEXTURE);
1684 glActiveTexture(GL_TEXTURE5);
1685 glBindTexture(GL_TEXTURE_2D, HISTORY_TEXTURE[cur_history]);
1686 glActiveTexture(GL_TEXTURE6);
1687 glBindTexture(GL_TEXTURE_2D, SHADOW_MAP_TEXTURE);
1688 glActiveTexture(GL_TEXTURE7);
1689 glBindTexture(GL_TEXTURE_2D, COMPOSITE_TEXTURE);
1690
1691 glUniform1i(POSTPROCESS_SHADER.uniforms[0].location, 0);
1692 glUniform1i(POSTPROCESS_SHADER.uniforms[1].location, 1);
1693 glUniform1i(POSTPROCESS_SHADER.uniforms[2].location, 2);
1694 glUniform1i(POSTPROCESS_SHADER.uniforms[3].location, 3);
1695 glUniform1i(POSTPROCESS_SHADER.uniforms[4].location, 4);
1696 glUniform1i(POSTPROCESS_SHADER.uniforms[5].location, 5);
1697 glUniform1i(POSTPROCESS_SHADER.uniforms[6].location, 6);
1698 glUniform1i(glGetUniformLocation(POSTPROCESS_SHADER.program, "uWater"), 7);
1699
1702 glUniform2f(POSTPROCESS_SHADER.uniforms[9].location,
1703 1.0 / SCREEN_WIDTH,
1704 1.0 / SCREEN_HEIGHT
1705 );
1706 glUniform1i(glGetUniformLocation(POSTPROCESS_SHADER.program, "outside_atmosphere"),
1708 );
1709
1710 glUniform3f(
1713 );
1714 glDrawArrays(GL_TRIANGLES, 0, 3);
1715 glEndQuery(GL_TIME_ELAPSED);
1716
1717
1718}
1719
1720GLuint64 density_time = 0;
1721GLuint64 mc_time = 0;
1722
1723
1724
1725
1726int main(int argc, char *argv[]) {
1727
1728 SDL_Window *window = NULL;
1729 SDL_GLContext context;
1730 NK_UNUSED(argc);
1731 NK_UNUSED(argv);
1732
1733 // omp_set_num_threads(8);
1734 if (!init(&window, &context))
1735 return -1;
1736
1737
1739 sizeof(AtmosphereVertex));
1741 calloc(ATMOSPHERE_RES * ATMOSPHERE_RES * 6 * 10, sizeof(uint32_t));
1742
1743 srand(time(NULL));
1744
1745 running = 1;
1746 fence = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
1747
1748 // init_random();
1749 // init_chunk_data();
1750
1751
1752 // Initializes the atmosphere spherical mesh
1753
1754 ATMOSPHERE_VCNT = 0;
1755 ATMOSPHERE_ICNT = 0;
1756
1758
1759 glBindVertexArray(ATMOSPHERE_VAO);
1760 glBindBuffer(GL_ARRAY_BUFFER, ATMOSPHERE_VBO);
1761 glBufferSubData(
1762 GL_ARRAY_BUFFER,
1763 0,
1766 );
1767
1768 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ATMOSPHERE_EBO);
1769 glBufferSubData(
1770 GL_ELEMENT_ARRAY_BUFFER,
1771 0,
1772 ATMOSPHERE_ICNT * sizeof(uint32_t),
1774 );
1775
1776 glGenQueries(QUERY_FRAMES, main_queries);
1777 glGenQueries(QUERY_FRAMES, bounds_queries);
1778 glGenQueries(QUERY_FRAMES, morton_queries);
1779 glGenQueries(QUERY_FRAMES, radix_queries);
1780 glGenQueries(QUERY_FRAMES, treecount_queries);
1781 glGenQueries(QUERY_FRAMES, tree_queries);
1782 glGenQueries(QUERY_FRAMES, com_queries);
1783 glGenQueries(QUERY_FRAMES, atmosphere_queries);
1784 glGenQueries(QUERY_FRAMES, clouds_queries);
1785 glGenQueries(QUERY_FRAMES, water_gen_queries);
1786 glGenQueries(QUERY_FRAMES, water_queries);
1788 glGenQueries(QUERY_FRAMES, mesh_queries);
1789 glGenQueries(QUERY_FRAMES, draw_queries);
1790 glGenQueries(QUERY_FRAMES, postprocess_queries);
1791
1792 // upload particle data once
1793
1794
1795 glBindBuffer(GL_ARRAY_BUFFER, MAIN_VBO);
1796
1797 glBufferData(
1798 GL_ARRAY_BUFFER,
1799 BODY_COUNT * sizeof(ParticleVertex),
1800 verts,
1801 GL_DYNAMIC_DRAW
1802 );
1803
1804
1805 Timer master, mesh, frame;
1806
1807 cam.cam_data.cam_pos = (vec4){0, 0, 0, 0};
1808 cam.cam_data.cam_pos.z = 1005;
1809 sim_step();
1810
1811 Timer col;
1812
1813 space_cam = cam;
1814
1815 while (running) {
1816
1817 vec3 cam_pos = (vec3){
1821 };
1822
1824 (cam_pos.z - planet_origin.z) <= planet_radius + 1000;
1825 // within_planet_atmosphere = false;
1826
1828 current_cam = &cam;
1829 } else {
1831 }
1832
1833 frame_available ^= 2;
1834 // Timer top, bottom;
1835 start_timer(&master);
1836 density_time = 0;
1837 mc_time = 0;
1838 // now = SDL_GetTicks() / 1000.0f;
1839 // dt = now - last;
1840 // if (dt > 0.25) dt = 0.25;
1841 // last = now;
1842
1844 dt = 2;
1845 uTime += dt;
1846
1847 // if (GLOBALS.lock_on)
1848 // {
1849 // look_at_selected_body();
1850 // }
1851 // if (within_planet_atmosphere)
1852 // {
1853 // load_chunks();
1854 // }
1855
1856 start_timer(&mesh);
1858
1859 glBeginQuery(GL_TIME_ELAPSED, mesh_generation_queries[current_query_frame]);
1861 glEndQuery(GL_TIME_ELAPSED);
1862
1863 }
1864 double mesh_time = end_timer(&mesh);
1865
1866
1867 start_timer(&col);
1868 process_input(&window);
1869
1871
1875 space_cam.yaw = cam.yaw;
1877
1878 } else {
1879
1880 cam = space_cam;
1881
1882 }
1883
1887
1888 double end = end_timer(&col);
1889
1891 sim_step();
1892 }
1895 {
1896
1897 glBeginQuery(GL_TIME_ELAPSED, water_gen_queries[current_query_frame]);
1898
1900
1901 glEndQuery(GL_TIME_ELAPSED);
1902 }
1903 render();
1904 if (display_menu) {
1905
1907 nk_sdl_render(NK_ANTI_ALIASING_ON, MAX_VERTEX_MEMORY, MAX_ELEMENT_MEMORY);
1908 }
1909 SDL_GL_SwapWindow(window);
1910 double frame_time = end_timer(&frame);
1911
1912
1913 int oldest_frame = (current_query_frame + 1) % QUERY_FRAMES;
1914 GLuint64 query_s[PQUERY_MAX];
1915
1916 query_s[PQUERY_MAIN] = retrieve_gl_query(main_queries[oldest_frame]);
1917 query_s[PQUERY_BOUNDS] = retrieve_gl_query(bounds_queries[oldest_frame]);
1918 query_s[PQUERY_MORTON] = retrieve_gl_query(morton_queries[oldest_frame]);
1919 query_s[PQUERY_RADIX] = retrieve_gl_query(radix_queries[oldest_frame]);
1920 query_s[PQUERY_TREECOUNT] = retrieve_gl_query(treecount_queries[oldest_frame]);
1921 query_s[PQUERY_TREE] = retrieve_gl_query(tree_queries[oldest_frame]);
1922 query_s[PQUERY_COM] = retrieve_gl_query(com_queries[oldest_frame]);
1923 query_s[PQUERY_ATMOSPHERE] = retrieve_gl_query(atmosphere_queries[oldest_frame]);
1924 query_s[PQUERY_CLOUDS] = retrieve_gl_query(clouds_queries[oldest_frame]);
1925 query_s[PQUERY_WATER_GEN] = retrieve_gl_query(water_gen_queries[oldest_frame]);
1926 query_s[PQUERY_WATER] = retrieve_gl_query(water_queries[oldest_frame]);
1928 query_s[PQUERY_PARTICLE] = retrieve_gl_query(particle_queries[oldest_frame]);
1929 query_s[PQUERY_MESH] = retrieve_gl_query(mesh_queries[oldest_frame]);
1930 query_s[PQUERY_DRAW] = retrieve_gl_query(draw_queries[oldest_frame]);
1932
1933 double m = end_timer(&master);
1934 if (GLOBALS.profiling)
1935 {
1936 printf("CPU: COLLISION: %f MESH: %f FRAME: %f FULL: %f\n", end,
1937 mesh_time, frame_time, m);
1938
1939
1940 printf("GPU time: Bounds %.3f ms | Morton %.3f ms | Radix %.3f ms | TC "
1941 "%.3f ms | Tree %.3f ms | COM %.3f ms | Main %.3f ms \n Atmosphere "
1942 "%.3f ms | Clouds %.3f ms | Water Gen %.3f | Mesh Gen %.3f \n Particle %.3f | Water %.3f | Shadowmap %.3f Mesh %.3f Postprocess %.3f\n",
1943 query_s[PQUERY_BOUNDS] / 1e6,
1944 query_s[PQUERY_MORTON] / 1e6,
1945 query_s[PQUERY_RADIX] / 1e6,
1946 query_s[PQUERY_TREECOUNT] / 1e6,
1947 query_s[PQUERY_TREE] / 1e6,
1948 query_s[PQUERY_COM] / 1e6,
1949 query_s[PQUERY_MAIN] / 1e6,
1950 query_s[PQUERY_ATMOSPHERE] / 1e6,
1951 query_s[PQUERY_CLOUDS] / 1e6,
1952 query_s[PQUERY_WATER_GEN] / 1e6,
1953 query_s[PQUERY_MESH_GEN] / 1e6,
1954 query_s[PQUERY_PARTICLE] / 1e6,
1955 query_s[PQUERY_WATER] / 1e6,
1956 query_s[PQUERY_DRAW] / 1e6,
1957 query_s[PQUERY_MESH] / 1e6,
1958 query_s[PQUERY_POSTPROCESS] / 1e6);
1960 }
1961
1962 }
1963
1964 nk_sdl_shutdown();
1965 SDL_GL_DeleteContext(context);
1966
1967 SDL_DestroyWindow(window);
1968 SDL_Quit();
1969
1970 return 1;
1971}
void update_light_camera(Camera *lcam)
Definition camera.c:169
void resolve_collisions(Camera *cam, float planet_radius)
Definition camera.c:639
void apply_velocity(Camera *cam, vec3 move_dir, float dt)
Definition camera.c:732
void update_camera(Camera *cam)
Definition camera.c:223
mat4 make_look_at(Camera *cam, vec3 eye)
Definition camera.c:131
mat4 make_projection(float fov_deg, float aspect, float near, float far)
Definition camera.c:77
void compute_camera_basis(Camera *cam, vec3 world_up)
Definition camera.c:13
void apply_planet_velocity(Camera *cam, vec3 move_dir, float dt)
Definition camera.c:334
Camera cam
Definition main.c:222
#define LODMAX
float G
Definition main.c:239
void render_sky_from_outside_atmosphere()
Renders the atmosphere from outside of the atmosphere.
Definition main.c:788
float ESun
Definition main.c:234
GLuint ATMOSPHERE_VBO
Definition main.c:183
float fKm
Definition main.c:241
vec3 sun_dir
Definition main.c:237
vec3 cam_pos_world
Definition main.c:236
vec3 sun_color
Definition main.c:238
void mesh_atmosphere_sphere()
Creates an atmosphere sphere for rendering.
Definition mesh.c:1741
int ATMOSPHERE_VCNT
Definition main.c:188
AtmosphereVertex * ATMOSPHERE_VERTS
Definition main.c:186
void render_sky_cubemap()
Renders the atmosphere and clouds from inside of the atmosphere.
Definition main.c:935
vec3 wavelength
Definition main.c:235
uint32_t * ATMOSPHERE_INDICES
Definition main.c:187
float fKr
Definition main.c:240
int ATMOSPHERE_ICNT
Definition main.c:189
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 ...
Definition mesh.c:894
void render_mesh_planet()
Renders a planet's meshed surface.
Definition main.c:1205
int LOD_VERTEX_SIZES[LODMAX]
Definition main.c:65
int LOD_DENSITY_SIZES[LODMAX]
Definition main.c:64
int CURRENT_LOD_BOUND
Definition main.c:63
void sim_step()
A single simulation step for the particle sim.
Definition main.c:441
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
struct nk_context * NK_CTX
Definition init.c:170
bool NUKLEAR_HOVERED
Definition init.c:171
bool init(SDL_Window **window, SDL_GLContext *context)
Definition init.c:660
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 FORCE1_COMPUTE_SHADER
Definition main.c:142
GLuint MAIN_TEXTURE
Definition main.c:74
GLuint WATER_TEXTURE
Definition main.c:85
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
ShaderProgram CLOUDS_SHADER
Definition main.c:134
ShaderProgram FULLSCREEN_SHADER
Definition main.c:125
GLuint PLANET_DATA_SSBO
Definition main.c:213
ShaderProgram WATER_SHADER
Definition main.c:124
GLuint CUBEMAP_TEXTURE
Definition main.c:56
GLuint FORCE2_COMPUTE_SHADER
Definition main.c:143
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
ShaderProgram POSTPROCESS_SHADER
Definition main.c:126
GLuint MAIN_VBO
Definition main.c:163
GLuint ROCK_DIFFUSE_TEXTURE
Definition main.c:52
vec3 planet_origin
Definition main.c:260
GLuint WATER_FFT_PONG_TEXTURE_2
Definition main.c:103
ParticleData PD
Definition main.c:244
ShaderProgram MESH_SHADER
Definition main.c:122
GLuint SPHERE_TEXTURE
Definition main.c:82
GLuint DENSITY_SSBO[LODMAX]
Definition main.c:209
ChunkData CHUNK_DATA[LODMAX][MAX_CHUNKS]
Definition main.c:67
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
ShaderProgram SHADOW_WATER_SHADER
Definition main.c:120
GLuint MORTON_SSBO
Definition main.c:203
ShaderProgram MAIN_SHADER
Definition main.c:121
int BLOOM_WIDTH
Definition main.c:44
GLuint WATER_VAO
Definition main.c:171
ComputeShaderProgram DENSITY_COMPUTE_SHADER
Definition main.c:138
GLuint BIT_REVERSAL_COMPUTE_SHADER
Definition main.c:160
GLuint BLOOM2_FBO
Definition main.c:113
int * CHUNK_DATA_PTR[3]
Definition main.c:68
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
ShaderProgram SKY_SHADER
Definition main.c:123
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 DEPTH_COMPUTE_SHADER
Definition main.c:153
GLuint POSITION_SSBO
Definition main.c:212
GLuint COLLISION_COMPUTE_SHADER
Definition main.c:157
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
ShaderProgram ATMOSPHERE_FROM_SPACE_SHADER
Definition main.c:133
GLuint COMPOSITE_FBO
Definition init.h:63
GLuint FBM_TEXTURE
Definition main.c:93
GLuint CHUNK_DATA_SSBO[3]
Definition main.c:215
ShaderProgram BLUR_SHADER
Definition main.c:130
GLuint RADIX_SSBO
Definition main.c:208
GLuint NODE_SSBO
Definition main.c:207
ShaderProgram SHADOW_MAP_SHADER
Definition main.c:119
GLuint INDIRECT_BUFFER[LODMAX][MAX_CHUNKS]
Definition main.c:176
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
ShaderProgram COMPOSITE_SHADER
Definition main.c:131
GLuint BLOOM2_TEXTURE
Definition main.c:88
GLuint BLUR_TEXTURE
Definition main.c:84
GLuint SKY_TEXTURE
Definition main.c:79
GLuint MORTON_COMPUTE_SHADER
Definition main.c:146
ShaderProgram BLOOM_SHADER
Definition main.c:129
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
ShaderProgram ATMOSPHERE_SHADER
Definition main.c:132
GLuint CAM_UBO
Definition main.c:197
ComputeShaderProgram INDIRECT_COMPUTE_SHADER
Definition main.c:140
GLuint WORLEY_TEXTURE
Definition main.c:91
GLuint DEBUG_TEXTURE
Definition main.c:80
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
ComputeShaderProgram MARCHING_CUBES_COMPUTE_SHADER
Definition main.c:139
GLuint MESH_VBO
Definition main.c:172
bool dirty_cubemap
Definition main.c:1247
GLuint WATER_FFT_PONG_TEXTURE
Definition main.c:101
int SCREEN_HEIGHT
Definition main.c:42
ShaderProgram HISTORY_SHADER
Definition main.c:127
GLuint BLUR_FBO
Definition main.c:114
GLuint COM_COMPUTE_SHADER
Definition main.c:152
GLuint POSTPROCESS_TEXTURE
Definition main.c:90
uint32_t * level_flag_ptr
Definition main.c:290
GLuint64 mc_time
Definition main.c:1721
ParticleVertex verts[BODY_COUNT]
Definition main.c:249
GLuint com_queries[QUERY_FRAMES]
Definition main.c:269
GLuint water_queries[QUERY_FRAMES]
Definition main.c:273
int main(int argc, char *argv[])
Definition main.c:1726
GLsync fence
Definition main.c:247
NodeData ND
Definition main.c:245
GLuint postprocess_queries[QUERY_FRAMES]
Definition main.c:278
void process_input(SDL_Window **window)
Processes SDL events.
Definition main.c:627
int running
Definition main.c:219
#define MAX_ELEMENT_MEMORY
Definition main.c:37
int current_query_frame
Definition main.c:280
float planet_radius
Definition main.c:262
#define MAX_VERTEX_MEMORY
Definition main.c:36
#define NUM_WORKGROUPS
Definition main.c:293
Camera * current_cam
Definition main.c:225
float DT
Definition main.c:231
Node nodes[MAX_NODES]
Definition main.c:251
GLuint64 density_time
Definition main.c:1720
GLuint bounds_queries[QUERY_FRAMES]
Definition main.c:264
bool display_menu
Definition main.c:255
GLuint morton_queries[QUERY_FRAMES]
Definition main.c:265
vec4 mat
Definition main.c:261
GLuint clouds_queries[QUERY_FRAMES]
Definition main.c:271
GLuint tree_queries[QUERY_FRAMES]
Definition main.c:268
float dt
Definition main.c:229
Globals GLOBALS
Definition main.c:39
int chunk_count
Definition main.c:777
int frame_available
Definition main.c:254
int cur_history
Definition main.c:776
void render()
Main render loop that updates the sky, then renders water + planet surfaces.
Definition main.c:1257
Camera LIGHT_CAM
Definition main.c:224
float uTime
Definition main.c:775
bool is_on_planet
Definition main.c:259
float wt
Definition main.c:1246
bool within_planet_atmosphere
Definition main.c:1249
Camera space_cam
Definition main.c:223
GLuint64 retrieve_gl_query(GLuint query)
Definition main.c:296
GLuint atmosphere_queries[QUERY_FRAMES]
Definition main.c:270
Particle bodies[BODY_COUNT]
Definition main.c:250
GLuint main_queries[QUERY_FRAMES]
Definition main.c:263
bool halt_chunks
Definition main.c:256
GLuint draw_queries[QUERY_FRAMES]
Definition main.c:277
int frame
Definition main.c:289
GLuint mesh_generation_queries[QUERY_FRAMES]
Definition main.c:274
GLuint radix_queries[QUERY_FRAMES]
Definition main.c:266
GLuint treecount_queries[QUERY_FRAMES]
Definition main.c:267
GLuint water_gen_queries[QUERY_FRAMES]
Definition main.c:272
GLuint particle_queries[QUERY_FRAMES]
Definition main.c:275
bool selection_mode
Definition main.c:1250
float move_speed
Definition main.c:226
GLuint mesh_queries[QUERY_FRAMES]
Definition main.c:276
Definition types.h:109
void display_main_menu()
Definition menu.c:26
vec4 p_m
Definition types.h:94
vec4 mat
Definition types.h:95
Definition main.h:8
void init_shaders()
Definition shaders.c:498
uniform mat4 view
Definition shadow.vert:9
@ PQUERY_MAIN
Definition types.h:72
@ PQUERY_TREECOUNT
Definition types.h:76
@ PQUERY_POSTPROCESS
Definition types.h:87
@ PQUERY_TREE
Definition types.h:77
@ PQUERY_RADIX
Definition types.h:75
@ PQUERY_BOUNDS
Definition types.h:73
@ PQUERY_PARTICLE
Definition types.h:84
@ PQUERY_MORTON
Definition types.h:74
@ PQUERY_MAX
Definition types.h:88
@ PQUERY_DRAW
Definition types.h:86
@ PQUERY_CLOUDS
Definition types.h:80
@ PQUERY_WATER
Definition types.h:82
@ PQUERY_MESH_GEN
Definition types.h:83
@ PQUERY_MESH
Definition types.h:85
@ PQUERY_ATMOSPHERE
Definition types.h:79
@ PQUERY_COM
Definition types.h:78
@ PQUERY_WATER_GEN
Definition types.h:81
float roll
Definition types.h:234
bool on_ground
Definition types.h:240
float z
Definition types.h:47
#define QUERY_FRAMES
Definition types.h:43
bool particle_toggle
Definition types.h:266
float x
Definition types.h:47
double end_timer(Timer *t)
Definition types.h:63
float x
Definition main.h:5
GLuint program
Definition types.h:452
#define MAX_DEPTH
Definition types.h:154
#define BODY_COUNT
Definition types.h:39
float y
Definition types.h:47
int hovered_body
Definition types.h:255
float y
Definition main.h:5
vec3 forward
Definition types.h:233
void start_timer(Timer *t)
Definition types.h:58
const int MAX_CHUNKS_LOD[LODMAX]
Definition types.h:309
#define SHADOW_MAP_SIZE
Definition types.h:42
#define MAX_CHUNKS
Definition types.h:182
bool water_toggle
Definition types.h:265
float z
Definition main.h:5
mat4 view
Definition types.h:225
float pitch
Definition types.h:234
vec3 right
Definition types.h:233
bool planet_meshing_toggle
Definition types.h:264
#define MAX_NODES
Definition types.h:40
bool paused
Definition types.h:258
bool profiling
Definition types.h:268
vec4 cam_vel
Definition types.h:224
float yaw
Definition types.h:234
GLuint location
Definition types.h:435
mat4 proj
Definition types.h:225
int selected_body
Definition types.h:256
#define ATMOSPHERE_RES
Definition types.h:503
CamData cam_data
Definition types.h:235
Uniform uniforms[32]
Definition types.h:456
bool sky_toggle
Definition types.h:267
vec4 cam_pos
Definition types.h:224
vec3 up
Definition types.h:233
Definition types.h:53
Definition types.h:51
Definition main.h:5
Definition types.h:47