Space Sim
Loading...
Searching...
No Matches
menu.c
Go to the documentation of this file.
1
2#include "mesh/mesh.h"
3#include "core/types.h"
4#include "core/init.h"
5
6bool s = false;
7bool change = false;
8// 32 bits
9void
11 (
12 size_t offset,
13 void * val
14 )
15
16{
17
18 glBindBuffer(GL_SHADER_STORAGE_BUFFER, PLANET_DATA_SSBO);
19 glBufferSubData(GL_SHADER_STORAGE_BUFFER, offset, sizeof(float), val);
20 change = true;
21
22}
23
24// Main UI, uploads to an ssbo with params on update using dirty flag.
25void
27
28{
29
30 change = false;
31 const float OFFSET_BOUNDS = 100.0f;
32 const float FREQ_BOUNDS = 100.0f;
33 const float AMP_BOUNDS = 100.0f;
34
35 if
36 (
37 nk_begin
38 (
39 NK_CTX,
40 "Main",
41 nk_rect(20, 20, 300, SCREEN_HEIGHT),
42 NK_WINDOW_TITLE | NK_WINDOW_SCROLL_AUTO_HIDE
43 )
44 )
45 {
46
47 struct nk_rect win_bounds = nk_window_get_bounds(NK_CTX);
48 if (nk_input_is_mouse_hovering_rect(&NK_CTX->input, win_bounds)) { NUKLEAR_HOVERED = true; }
49
50 size_t offset = offsetof(PlanetData, sun_dir);
51
52
53 nk_layout_row_dynamic(NK_CTX, 20, 1);
54 float min_m = nk_propertyf(NK_CTX, "Min Mass", 0.0f, GLOBALS.min_mass, 1000000.0f, 0.01f, 0.01f);
55 if (min_m != GLOBALS.min_mass)
56 {
57 GLOBALS.min_mass = min_m;
58 }
59 float max_m = nk_propertyf(NK_CTX, "Max Mass", 0.0f, GLOBALS.min_mass, 1000000.0f, 0.01f, 0.01f);
60 if (max_m != GLOBALS.max_mass)
61 {
62 GLOBALS.max_mass = max_m;
63 }
64 float mass_pow = nk_propertyf(NK_CTX, "Mass Pow", 0.0f, GLOBALS.mass_pow, 1000000, 0.01f, 0.01f);
65 if (mass_pow != GLOBALS.mass_pow)
66 {
67 GLOBALS.mass_pow = mass_pow;
68 }
69 float radius= nk_propertyf(NK_CTX, "Radius", 0.0f, GLOBALS.radius, 1000000, 0.01f, 0.01f);
70 if (radius != GLOBALS.radius)
71 {
73 }
74 nk_bool planet_toggle = GLOBALS.planet_meshing_toggle;
75 if (nk_checkbox_label(NK_CTX, "Planet Toggle", &planet_toggle))
76 {
77 GLOBALS.planet_meshing_toggle = planet_toggle;
79 }
80 nk_bool water_toggle = GLOBALS.water_toggle;
81 if (nk_checkbox_label(NK_CTX, "Water Toggle", &water_toggle))
82 {
83 GLOBALS.water_toggle = water_toggle;
84 }
85 nk_bool particle_toggle = GLOBALS.particle_toggle;
86 if (nk_checkbox_label(NK_CTX, "Particle Toggle", &particle_toggle))
87 {
88 GLOBALS.particle_toggle = particle_toggle;
89 }
90 nk_bool sky_toggle = GLOBALS.sky_toggle;
91 if (nk_checkbox_label(NK_CTX, "Sky Toggle", &sky_toggle))
92 {
93 GLOBALS.sky_toggle = sky_toggle;
94 }
95 nk_bool profiling = GLOBALS.profiling;
96 if (nk_checkbox_label(NK_CTX, "Profiling", &profiling))
97 {
98 GLOBALS.profiling = profiling;
99 }
100 if (nk_button_label(NK_CTX, "Reset Sim"))
101 {
102 init_random();
103 }
104 char origin[256];
105 sprintf(origin, "Origin: %f %f %f", planet_origin.x, planet_origin.y, planet_origin.z);
106
107 nk_label(NK_CTX, origin, NK_TEXT_ALIGN_LEFT);
108 if (nk_button_label(NK_CTX, "Reset Origin"))
109 {
110 planet_origin = (vec3){0,0,0};
111 }
112
113
114 nk_layout_row_dynamic(NK_CTX, 20, 1);
115 nk_label(NK_CTX, "Sun Dir:", NK_TEXT_ALIGN_LEFT);
116
117 nk_layout_row_dynamic(NK_CTX, 20, 3);
118 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "X: %f", PLANET_DATA.sun_dir.x);
119 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "Y: %f", PLANET_DATA.sun_dir.y);
120 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "Z: %f", PLANET_DATA.sun_dir.z);
121 float x0 = nk_propertyf(NK_CTX, "Sun X", -1.0f, PLANET_DATA.sun_dir.x, 1, 0.001f, 0.001f);
122 if (x0 != PLANET_DATA.sun_dir.x)
123 {
124
125 PLANET_DATA.sun_dir.x = x0;
126 upload_param_to_ssbo(offset, &x0);
127 }
128 offset += sizeof(float);
129 float y0 = nk_propertyf(NK_CTX, "Sun Y", -1.0f, PLANET_DATA.sun_dir.y, 1, 0.001f, 0.001f);
130 if (y0 != PLANET_DATA.sun_dir.y)
131 {
132
133 PLANET_DATA.sun_dir.y = y0;
134 upload_param_to_ssbo(offset, &y0);
135 }
136 offset += sizeof(float);
137 float z0 = nk_propertyf(NK_CTX, "Sun Z", -1.0f, PLANET_DATA.sun_dir.z, 1, 0.001f, 0.001f);
138 if (z0 != PLANET_DATA.sun_dir.z)
139 {
140
141 PLANET_DATA.sun_dir.z = z0;
142 upload_param_to_ssbo(offset, &z0);
143 }
144 offset += sizeof(float);
145
146 nk_layout_row_dynamic(NK_CTX, 20, 1);
147 nk_label(NK_CTX, "Sun Color:", NK_TEXT_ALIGN_LEFT);
148
149 offset = offsetof(PlanetData, sun_color);
150 struct nk_colorf sun_color= {
154 1.0f
155 };
156
157 nk_label(NK_CTX, "Sun Color", NK_TEXT_LEFT);
158
159 if (nk_combo_begin_color(NK_CTX, nk_rgb_cf(sun_color), nk_vec2(150, 150))) {
160 nk_layout_row_dynamic(NK_CTX, 120, 1);
161 sun_color = nk_color_picker(NK_CTX, sun_color, NK_RGB);
162
163 nk_layout_row_dynamic(NK_CTX, 25, 1);
164 sun_color.r = nk_propertyf(NK_CTX, "#R:", 0.0f, sun_color.r, 1.0f, 0.01f, 0.005f);
165 sun_color.g = nk_propertyf(NK_CTX, "#G:", 0.0f, sun_color.g, 1.0f, 0.01f, 0.005f);
166 sun_color.b = nk_propertyf(NK_CTX, "#B:", 0.0f, sun_color.b, 1.0f, 0.01f, 0.005f);
167
169 {
172 }
173 offset += sizeof(float);
175 {
178 }
179 offset += sizeof(float);
181 {
184 }
185 offset += sizeof(float);
186 nk_combo_end(NK_CTX);
187 }
188
189 nk_layout_row_dynamic(NK_CTX, 20, 1);
190 float esun = nk_propertyf(NK_CTX, "ESun", 0, ESun, 50, 0.01f, 0.01f);
191 ESun = esun;
192
193 struct nk_colorf wavelength_color= {
197 1.0f
198 };
199
200 nk_label(NK_CTX, "Wavelength Color", NK_TEXT_LEFT);
201
202 if (nk_combo_begin_color(NK_CTX, nk_rgb_cf(wavelength_color), nk_vec2(150, 150))) {
203 nk_layout_row_dynamic(NK_CTX, 120, 1);
204 wavelength_color = nk_color_picker(NK_CTX, wavelength_color, NK_RGB);
205
206 nk_layout_row_dynamic(NK_CTX, 25, 1);
207 wavelength_color.r = nk_propertyf(NK_CTX, "#R:", 0.0f, wavelength_color.r, 1.0f, 0.01f, 0.005f);
208 wavelength_color.g = nk_propertyf(NK_CTX, "#G:", 0.0f, wavelength_color.g, 1.0f, 0.01f, 0.005f);
209 wavelength_color.b = nk_propertyf(NK_CTX, "#B:", 0.0f, wavelength_color.b, 1.0f, 0.01f, 0.005f);
210
211 wavelength.x = wavelength_color.r;
212 wavelength.y = wavelength_color.g;
213 wavelength.z = wavelength_color.b;
214 nk_combo_end(NK_CTX);
215 }
216
217
218 nk_label(NK_CTX, "Cam Pos World:", NK_TEXT_ALIGN_LEFT);
219
220 nk_layout_row_dynamic(NK_CTX, 20, 3);
221 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "X: %f", cam_pos_world.x);
222 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "Y: %f", cam_pos_world.y);
223 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "Z: %f", cam_pos_world.z);
224 float cx = nk_propertyf(NK_CTX, "Cam X", -1.0f, cam_pos_world.x, 2, 0.001f, 0.001f);
225 cam_pos_world.x = cx;
226 float cy = nk_propertyf(NK_CTX, "Cam Y", -1.0f, cam_pos_world.y, 2, 0.001f, 0.001f);
227 cam_pos_world.y = cy;
228 float cz = nk_propertyf(NK_CTX, "Cam Z", -1.0f, cam_pos_world.z, 2, 0.001f, 0.001f);
229 cam_pos_world.z = cz;
230
231
232 nk_layout_row_dynamic(NK_CTX, 20, 1);
233 float g= nk_propertyf(NK_CTX, "G", -1.0f, G, 2, 0.01f, 0.01f);
234 G = g;
235 float fr = nk_propertyd(NK_CTX, "fKr", 0, fKr, 1, 0.0001f, 0.0001f);
236 fKr = fr;
237 float fm = nk_propertyd(NK_CTX, "fKm", 0, fKm, 1, 0.0001f, 0.0001f);
238 fKm = fm;
239
240 nk_layout_row_dynamic(NK_CTX, 20, 1);
241
242
243 offset = 0;
244 int warp_count = nk_propertyi(NK_CTX, "Warp Count", 0, PLANET_DATA.warp_count, MAX_LAYERS, 1, 0.1f);
245 if (warp_count != PLANET_DATA.warp_count)
246 {
247 PLANET_DATA.warp_count = warp_count;
248 upload_param_to_ssbo(offsetof(PlanetData, warp_count), &warp_count);
249 }
250 offset = offsetof(PlanetData, warp_layers);
251
252 for (int i = 0; i < PLANET_DATA.warp_count; i++)
253 {
254
255 nk_layout_row_dynamic(NK_CTX, 20, 1);
256 char l[128];
257 sprintf(l, "Warp %d:", i);
258 nk_label(NK_CTX, l, NK_TEXT_ALIGN_LEFT);
259 nk_label(NK_CTX, "Offset 0:", NK_TEXT_ALIGN_LEFT);
260
261 nk_layout_row_dynamic(NK_CTX, 20, 3);
262
263 char xs[128];
264 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "X0 %f", PLANET_DATA.warp_layers[i].offset0.x);
265 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "Y0 %f", PLANET_DATA.warp_layers[i].offset0.y);
266 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "Z0 %f", PLANET_DATA.warp_layers[i].offset0.z);
267 sprintf(xs, "%d X0", i);
268 float x0 = nk_propertyf(NK_CTX, xs, -OFFSET_BOUNDS, PLANET_DATA.warp_layers[i].offset0.x, OFFSET_BOUNDS, 1, 1);
269 if (x0 != PLANET_DATA.warp_layers[i].offset0.x)
270 {
271
273 upload_param_to_ssbo(offset, &x0);
274 }
275 offset += sizeof(float);
276 sprintf(xs, "%d Y0", i);
277 float y0 = nk_propertyf(NK_CTX, xs, -OFFSET_BOUNDS, PLANET_DATA.warp_layers[i].offset0.y, OFFSET_BOUNDS, 1, 1);
278 if (y0 != PLANET_DATA.warp_layers[i].offset0.y)
279 {
280
282 upload_param_to_ssbo(offset, &y0);
283 }
284 offset += sizeof(float);
285 sprintf(xs, "%d Z0", i);
286 float z0 = nk_propertyf(NK_CTX, xs, -OFFSET_BOUNDS, PLANET_DATA.warp_layers[i].offset0.z, OFFSET_BOUNDS, 1, 1);
287 if (z0 != PLANET_DATA.warp_layers[i].offset0.z)
288 {
289
291 upload_param_to_ssbo(offset, &z0);
292 }
293 offset += sizeof(float);
294
295
296 nk_layout_row_dynamic(NK_CTX, 20, 2);
297 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "Freq0: %f", PLANET_DATA.warp_layers[i].freq0);
298 sprintf(xs, "%d Freq0", i);
299 float freq0 = nk_propertyf(NK_CTX, xs, -FREQ_BOUNDS, PLANET_DATA.warp_layers[i].freq0, FREQ_BOUNDS, 0.0001f, 0.0001f);
300 if (freq0 != PLANET_DATA.warp_layers[i].freq0)
301 {
302 PLANET_DATA.warp_layers[i].freq0 = freq0;
303 upload_param_to_ssbo(offset, &freq0);
304
305 }
306 offset += sizeof(float);
307
308 nk_layout_row_dynamic(NK_CTX, 20, 3);
309 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "X1 %f", PLANET_DATA.warp_layers[i].offset1.x);
310 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "Y1 %f", PLANET_DATA.warp_layers[i].offset1.y);
311 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "Z1 %f", PLANET_DATA.warp_layers[i].offset1.z);
312
313 sprintf(xs, "%d X1", i);
314 float x1 = nk_propertyf(NK_CTX, xs, -OFFSET_BOUNDS, PLANET_DATA.warp_layers[i].offset1.x, OFFSET_BOUNDS, 1, 1);
315 if (x1 != PLANET_DATA.warp_layers[i].offset1.x)
316 {
317
319 upload_param_to_ssbo(offset, &x1);
320 }
321 offset += sizeof(float);
322 sprintf(xs, "%d Y1", i);
323 float y1 = nk_propertyf(NK_CTX, xs, -OFFSET_BOUNDS, PLANET_DATA.warp_layers[i].offset1.y, OFFSET_BOUNDS, 1, 1);
324 if (y1 != PLANET_DATA.warp_layers[i].offset1.y)
325 {
326
328 upload_param_to_ssbo(offset, &y1);
329 }
330 offset += sizeof(float);
331 sprintf(xs, "%d Z1", i);
332 float z1 = nk_propertyf(NK_CTX, xs, -OFFSET_BOUNDS, PLANET_DATA.warp_layers[i].offset1.z, OFFSET_BOUNDS, 1, 1);
333 if (z1 != PLANET_DATA.warp_layers[i].offset1.z)
334 {
335
337 upload_param_to_ssbo(offset, &z1);
338 }
339 offset += sizeof(float);
340
341
342 nk_layout_row_dynamic(NK_CTX, 20, 2);
343 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "Freq1: %f", PLANET_DATA.warp_layers[i].freq1);
344 sprintf(xs, "%d Freq1", i);
345 float freq1 = nk_propertyf(NK_CTX, xs, -FREQ_BOUNDS, PLANET_DATA.warp_layers[i].freq1, FREQ_BOUNDS, 0.0001f, 0.0001f);
346 if (freq1 != PLANET_DATA.warp_layers[i].freq1)
347 {
348 PLANET_DATA.warp_layers[i].freq1 = freq1;
349 upload_param_to_ssbo(offset, &freq1);
350
351 }
352 offset += sizeof(float);
353 nk_layout_row_dynamic(NK_CTX, 20, 3);
354
355 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "X2 %f", PLANET_DATA.warp_layers[i].offset2.x);
356 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "Y2 %f", PLANET_DATA.warp_layers[i].offset2.y);
357 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "Z2 %f", PLANET_DATA.warp_layers[i].offset2.z);
358 sprintf(xs, "%d X2", i);
359 float x2 = nk_propertyf(NK_CTX, xs, -OFFSET_BOUNDS, PLANET_DATA.warp_layers[i].offset2.x, OFFSET_BOUNDS, 1, 1);
360 if (x2 != PLANET_DATA.warp_layers[i].offset2.x)
361 {
362
364 upload_param_to_ssbo(offset, &x2);
365 }
366 offset += sizeof(float);
367 sprintf(xs, "%d Y2", i);
368 float y2 = nk_propertyf(NK_CTX, xs, -OFFSET_BOUNDS, PLANET_DATA.warp_layers[i].offset2.y, OFFSET_BOUNDS, 1, 1);
369 if (y2 != PLANET_DATA.warp_layers[i].offset2.y)
370 {
371
373 upload_param_to_ssbo(offset, &y2);
374 }
375 offset += sizeof(float);
376 sprintf(xs, "%d Z2", i);
377 float z2 = nk_propertyf(NK_CTX, xs, -OFFSET_BOUNDS, PLANET_DATA.warp_layers[i].offset2.z, OFFSET_BOUNDS, 1, 1);
378 if (z2 != PLANET_DATA.warp_layers[i].offset2.z)
379 {
380
382 upload_param_to_ssbo(offset, &z2);
383 }
384 offset += sizeof(float);
385
386
387 nk_layout_row_dynamic(NK_CTX, 20, 2);
388 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "Freq2: %f", PLANET_DATA.warp_layers[i].freq2);
389 sprintf(xs, "%d Freq2", i);
390 float freq2 = nk_propertyf(NK_CTX, xs, -FREQ_BOUNDS, PLANET_DATA.warp_layers[i].freq2, FREQ_BOUNDS, 0.0001f, 0.0001f);
391 if (freq2 != PLANET_DATA.warp_layers[i].freq2)
392 {
393 PLANET_DATA.warp_layers[i].freq2 = freq2;
394 upload_param_to_ssbo(offset, &freq2);
395
396 }
397 offset += sizeof(float);
398
399 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "Amp: %f", PLANET_DATA.warp_layers[i].amp);
400 sprintf(xs, "%d Amp", i);
401 float amp = nk_propertyf(NK_CTX, xs, -AMP_BOUNDS, PLANET_DATA.warp_layers[i].amp, AMP_BOUNDS, 0.0001f, 0.0001f);
402
403 if (amp != PLANET_DATA.warp_layers[i].amp)
404 {
405 PLANET_DATA.warp_layers[i].amp = amp;
406 upload_param_to_ssbo(offset, &amp);
407
408 }
409 offset += sizeof(float);
410 offset += sizeof(float);
411 offset += sizeof(float);
412 offset += sizeof(float);
413 }
414
415 offset = sizeof(int);
416 nk_layout_row_dynamic(NK_CTX, 20, 1);
417 int perlin_count = nk_propertyi(NK_CTX, "Perlin Count", 0, PLANET_DATA.perlin_count, MAX_LAYERS, 1, 0.1f);
418 if (perlin_count!= PLANET_DATA.perlin_count)
419 {
420 PLANET_DATA.perlin_count = perlin_count;
421 upload_param_to_ssbo(offsetof(PlanetData, perlin_count), &perlin_count);
422 }
423
424 offset = offsetof(PlanetData, perlin_layers);
425
426 for (int i = 0; i < PLANET_DATA.perlin_count; i++)
427 {
428
429 char l[128];
430 nk_layout_row_dynamic(NK_CTX, 20, 1);
431 sprintf(l, "Perlin %d:", i);
432 nk_label(NK_CTX, l, NK_TEXT_ALIGN_LEFT);
433
434 char f[128];
435 nk_layout_row_dynamic(NK_CTX, 20, 2);
436
437 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "Freq: %f", PLANET_DATA.perlin_layers[i].freq);
438 sprintf(f, "%d PFreq", i);
439 float freq = nk_propertyd(NK_CTX, f, -FREQ_BOUNDS, PLANET_DATA.perlin_layers[i].freq, FREQ_BOUNDS, 0.0001f, 0.0001f);
440
441 if (freq != PLANET_DATA.perlin_layers[i].freq)
442 {
444 upload_param_to_ssbo(offset, &freq);
445 }
446
447 offset += sizeof(float);
448 char a[128];
449 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "Amp: %f", PLANET_DATA.perlin_layers[i].amp);
450 sprintf(a, "%d PAmp", i);
451 float amp = nk_propertyd(NK_CTX, a, -AMP_BOUNDS, PLANET_DATA.perlin_layers[i].amp, AMP_BOUNDS, 0.0001f, 0.0001f);
452 if (amp != PLANET_DATA.perlin_layers[i].amp)
453 {
455 upload_param_to_ssbo(offset, &amp);
456 }
457
458 offset += sizeof(float);
459 offset += sizeof(float);
460 offset += sizeof(float);
461 }
462
463
464 nk_layout_row_dynamic(NK_CTX, 20, 1);
465 int fbm_count = nk_propertyi(NK_CTX, "FBM Count", 0, PLANET_DATA.fbm_count, MAX_LAYERS, 1, 0.1f);
466 if (fbm_count != PLANET_DATA.fbm_count)
467 {
468 PLANET_DATA.fbm_count = fbm_count;
469 upload_param_to_ssbo(offsetof(PlanetData, fbm_count), &fbm_count);
470
471 }
472 offset = offsetof(PlanetData, fbm_layers);
473
474 for (int i = 0; i < PLANET_DATA.fbm_count; i++)
475 {
476
477 char l[128];
478 sprintf(l, "FBM %d:", i);
479 nk_layout_row_dynamic(NK_CTX, 20, 1);
480 nk_label(NK_CTX, l, NK_TEXT_ALIGN_LEFT);
481
482 char f[128];
483 nk_layout_row_dynamic(NK_CTX, 20, 2);
484 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "Freq: %f", PLANET_DATA.fbm_layers[i].freq);
485 sprintf(f, "%d FFreq", i);
486 float freq = nk_propertyd(NK_CTX, f, -FREQ_BOUNDS, PLANET_DATA.fbm_layers[i].freq, FREQ_BOUNDS, 0.0001f, 0.0001f);
487 if (freq != PLANET_DATA.fbm_layers[i].freq)
488 {
489
490 PLANET_DATA.fbm_layers[i].freq = freq;
491 upload_param_to_ssbo(offset, &freq);
492 }
493
494 offset += sizeof(float);
495
496 char a[128];
497 nk_labelf(NK_CTX, NK_TEXT_ALIGN_LEFT, "Amp: %f", PLANET_DATA.fbm_layers[i].amp);
498 sprintf(a, "%d FAmp", i);
499 float amp = nk_propertyd(NK_CTX, a, -AMP_BOUNDS, PLANET_DATA.fbm_layers[i].amp, AMP_BOUNDS, 0.0001f, 0.0001f);
500
501 if (amp != PLANET_DATA.fbm_layers[i].amp)
502 {
503
504 PLANET_DATA.fbm_layers[i].amp = amp;
505 upload_param_to_ssbo(offset, &amp);
506 }
507
508 offset += sizeof(float);
509 offset += sizeof(float);
510 offset += sizeof(float);
511 }
512
513
514 }
515
516 nk_end(NK_CTX);
517
518 // free chunks and rebuild
519 if (change)
520 {
521 for (int l = 0; l < LODMAX; l++)
522 {
523 for (int i = 0; i < MAX_CHUNKS_LOD[l]; i++)
524 {
525 free_parent(l, i);
526 free_child(l, i);
528 }
529 }
530
531 dirty_cubemap = true;
532 }
533
534}
const float radius
Definition camera.c:580
#define LODMAX
float G
Definition main.c:239
float ESun
Definition main.c:234
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
vec3 wavelength
Definition main.c:235
float fKr
Definition main.c:240
void init_chunk_data()
Initializes and frees old ChunkData and hash tables.
Definition mesh.c:796
bool free_parent(int lod, int i)
Frees the parent of given LOD.
Definition mesh.c:691
bool free_current_parent(int lod, int i)
Frees the given LOD (as a parent).
Definition mesh.c:662
bool free_child(int lod, int i)
Frees the child of given LOD.
Definition mesh.c:725
struct nk_context * NK_CTX
Definition init.c:170
void init_random()
Definition init.c:115
bool NUKLEAR_HOVERED
Definition init.c:171
GLuint PLANET_DATA_SSBO
Definition main.c:213
vec3 planet_origin
Definition main.c:260
PlanetData PLANET_DATA
Definition main.c:194
bool dirty_cubemap
Definition main.c:1247
int SCREEN_HEIGHT
Definition main.c:42
Globals GLOBALS
Definition main.c:39
bool s
Definition menu.c:6
void display_main_menu()
Definition menu.c:26
void upload_param_to_ssbo(size_t offset, void *val)
Definition menu.c:11
bool change
Definition menu.c:7
PerlinLayer perlin_layers[MAX_LAYERS]
Definition types.h:418
float z
Definition types.h:47
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
float x
Definition main.h:5
int fbm_count
Definition types.h:413
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
const int MAX_CHUNKS_LOD[LODMAX]
Definition types.h:309
float radius
Definition types.h:262
float max_mass
Definition types.h:260
bool water_toggle
Definition types.h:265
float z
Definition main.h:5
bool planet_meshing_toggle
Definition types.h:264
bool profiling
Definition types.h:268
FBMLayer fbm_layers[MAX_LAYERS]
Definition types.h:419
#define MAX_LAYERS
Definition types.h:407
float min_mass
Definition types.h:259
bool sky_toggle
Definition types.h:267
Definition main.h:5
uniform float g
Definition water.comp:24
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