Space Sim
Loading...
Searching...
No Matches
marching_cubes.comp
Go to the documentation of this file.
1#version 440
2
8
9layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
10
11layout(std140) uniform CameraData {
12 vec4 cam_pos;
13 vec4 cam_vel;
15 mat4 view;
16 mat4 inv_projection;
17 mat4 inv_view;
18};
19layout(std430, binding=8) buffer MarchingCubesData
20{
21 int EDGE_TO_VERTICES[12][2];
22 int EDGE_TABLE[256];
23 int TRIANGLE_TABLE[256][16];
24};
25layout(std430, binding=9) buffer DensityData
26{
27 float density[];
28};
29struct Vertex
30{
31 vec3 pos;
32 float pad0;
33 vec3 normal;
34 float pad1;
35 vec3 color;
36 float pad2;
37};
38#define LODMAX 4
39#define MAX_CHUNKS 1000
40layout(std430, binding=10) buffer DensityVertexData
41{
42 int chunk_vertex_offset[MAX_CHUNKS];
43 Vertex vertices[];
44};
45#define MAX_LAYERS 24
46
47struct WarpLayer
48{
50 float freq0;
52 float freq1;
54 float freq2;
55 float amp;
56 float pad0;
57 float pad1;
58 float pad3;
59};
60
61struct PerlinLayer
62{
63 float freq;
64 float amp;
65 float pad0;
66 float pad1;
67};
68
69struct FBMLayer
70{
71 float freq;
72 float amp;
73 float pad0;
74 float pad1;
75};
76
77layout(std430, binding=13) buffer PlanetData {
78
79 int warp_count;
80 int perlin_count;
81 int fbm_count;
82 int pad0;
85 WarpLayer warp_layers[MAX_LAYERS];
86 PerlinLayer perlin_layers[MAX_LAYERS];
87 FBMLayer fbm_layers[MAX_LAYERS];
88
89};
90
91const vec3 delta[8] =
92{
93 vec3(0, 0, 0),
94 vec3(1, 0, 0),
95 vec3(1, 0, 1),
96 vec3(0, 0, 1),
97 vec3(0, 1, 0),
98 vec3(1, 1, 0),
99 vec3(1, 1, 1),
100 vec3(0, 1, 1)
101};
102
103const float ISO_VALUE = 0.0;
104uniform int uSize;
106uniform int chunk_id;
107uniform sampler3D perlin_tex;
108uniform sampler3D fbm_tex;
109
110#define NUM_OCTAVES 5
111float mod289(float x){return x - floor(x * (1.0 / 289.0)) * 289.0;}
112vec4 mod289(vec4 x){return x - floor(x * (1.0 / 289.0)) * 289.0;}
113vec4 perm(vec4 x){return mod289(((x * 34.0) + 1.0) * x);}
114
115float noise(vec3 p){
116 vec3 a = floor(p);
117 vec3 d = p - a;
118 d = d * d * (3.0 - 2.0 * d);
119
120 vec4 b = a.xxyy + vec4(0.0, 1.0, 0.0, 1.0);
121 vec4 k1 = perm(b.xyxy);
122 vec4 k2 = perm(k1.xyxy + b.zzww);
123
124 vec4 c = k2 + a.zzzz;
125 vec4 k3 = perm(c);
126 vec4 k4 = perm(c + 1.0);
127
128 vec4 o1 = fract(k3 * (1.0 / 41.0));
129 vec4 o2 = fract(k4 * (1.0 / 41.0));
130
131 vec4 o3 = o2 * d.z + o1 * (1.0 - d.z);
132 vec2 o4 = o3.yw * d.x + o3.xz * (1.0 - d.x);
133
134 return o4.y * d.y + o4.x * (1.0 - d.y);
135}
136
137
138float fbm(vec3 x) {
139 float v = 0.0;
140 float a = 0.5;
141 // float f = 1.0;
142 vec3 shift = vec3(100);
143 for (int i = 0; i < NUM_OCTAVES; ++i) {
144 v += a * noise(x);
145 x = x * 2.0 + shift;
146 // f *= 2.5;
147 a *= 0.45;
148 }
149 return v;
150}
151
153{
154
155 float d = p.z;
156 for (int i = 0; i < warp_count; i++)
157 {
158
159 WarpLayer wl = warp_layers[i];
160 vec3 warp =
161 vec3(texture(perlin_tex, p * wl.freq0 + wl.offset0).r * 2.0f - 1.0f,
162 texture(perlin_tex, p * wl.freq1 + wl.offset1).r * 2.0f - 1.0f,
163 texture(perlin_tex, p * wl.freq2 + wl.offset2).r * 2.0f - 1.0f);
164 p += warp * wl.amp;
165 }
166
167 for (int i = 0; i < perlin_count; i++)
168 {
169 PerlinLayer pl = perlin_layers[i];
170 d += (float(texture(perlin_tex, p * pl.freq).r) * 2.0f - 1.0f) * pl.amp;
171 }
172 for (int i = 0; i < fbm_count; i++)
173 {
174 FBMLayer fl = fbm_layers[i];
175 d += (float(texture(fbm_tex, p * fl.freq).r) * 2.0f - 1.0f) * fl.amp;
176 }
177 return d;
178}
179
180uint density_index(uvec3 p, uint padded)
181{
182
183 return p.z * padded * padded + p.y * padded + p.x + padded * padded * padded * chunk_id;
184}
185
186
187float lookup_density(uvec3 p, uint padded)
188{
189
190 return density[density_index(uvec3(p.x, p.y, p.z), padded)];
191}
192
193float sample_density(vec3 p, vec3 chunk_offset, vec3 center_offset, float voxel_size, uint padded)
194{
195 vec3 grid = (p - chunk_offset - center_offset) / voxel_size;
196
197 uvec3 i = uvec3(floor(grid));
198 vec3 f = fract(grid);
199 uvec3 i1 = uvec3(i + 1);
200 if (i.x < 0 || i.x > uSize || i.y < 0 || i.y > uSize || i.z < 0 || i.z > uSize || i1.x < 0 || i1.x > uSize || i1.y < 0 || i1.y > uSize || i1.z < 0 || i1.z > uSize) return density_fn(p);
201
202 uvec3 p0 = uvec3(i.x, i.y, i.z);
203 uvec3 p1 = uvec3(i1.x, i.y, i.z);
204 uvec3 p2 = uvec3(i.x, i1.y, i.z);
205 uvec3 p3 = uvec3(i1.x, i1.y, i.z);
206 uvec3 p4 = uvec3(i.x, i.y, i1.z);
207 uvec3 p5 = uvec3(i1.x, i.y, i1.z);
208 uvec3 p6 = uvec3(i.x, i1.y, i1.z);
209 uvec3 p7 = uvec3(i1.x, i1.y, i1.z);
210
211 float c000 = lookup_density(p0, padded);
212 float c100 = lookup_density(p1, padded);
213 float c010 = lookup_density(p2, padded);
214 float c110 = lookup_density(p3, padded);
215 float c001 = lookup_density(p4, padded);
216 float c101 = lookup_density(p5, padded);
217 float c011 = lookup_density(p6, padded);
218 float c111 = lookup_density(p7, padded);
219
220 float c00 = mix(c000, c100, f.x);
221 float c10 = mix(c010, c110, f.x);
222 float c01 = mix(c001, c101, f.x);
223 float c11 = mix(c011, c111, f.x);
224
225 float c0 = mix(c00, c10, f.y);
226 float c1 = mix(c01, c11, f.y);
227
228 return mix(c0, c1, f.z);
229}
230
232{
233 vec3 b = vec3(0,0,0);
234 if (p.x <= min.x + 0.1) b.x = -1;
235 if (p.x >= max.x - 0.1) b.x = 1;
236 if (p.y <= min.y + 0.1) b.y = -1;
237 if (p.y >= max.y - 0.1) b.y = 1;
238 if (p.z <= min.z + 0.1) b.z = -1;
239 if (p.z >= max.z - 0.1) b.z = 1;
240
241 return b;
242}
243
244
246void main()
247{
248
249 uint x = gl_GlobalInvocationID.x;
250 uint y = gl_GlobalInvocationID.y;
251 uint z = gl_GlobalInvocationID.z;
252 if (x >= uSize || y >= uSize || z >= uSize) return;
253 float chunk_world_size = 20;
254
255 float voxel_size = chunk_world_size / uSize;
256
257 vec3 center_offset = vec3(-0.5 * chunk_world_size);
258 vec3 p = vec3(x, y, z) * voxel_size + center_offset + chunk_offset;
259 vec3 min = center_offset + chunk_offset;
260 vec3 max = min + vec3(chunk_world_size);
261
262 vec3 points[8];
263 vec3 verts[12];
264 float vals[8];
265 vec3 normals[12];
266 bool point_on_border[8];
267 bool vert_on_border[12];
268 vec3 point_perp_normals[8];
269 vec3 vert_perp_normals[12];
270 uint val = 0;
271 uint padded = uSize + 1;
272
273 for (uint i = 0; i < 8; i++)
274 {
275 points[i] = p + delta[i] * voxel_size;
276 uint xi = x + uint(delta[i].x);
277 uint yi = y + uint(delta[i].y);
278 uint zi = z + uint(delta[i].z);
279 vals[i] = density[zi * padded * padded + yi * padded + xi + padded * padded * padded * chunk_id];
280
281 if (vals[i] > ISO_VALUE) {
282 val = val | (1u << i);
283 }
284 verts[i] = points[i];
285 vert_on_border[i] = point_on_border[i];
286 }
287
288 uint edge = EDGE_TABLE[val];
289
290 float d = voxel_size;
291 for (uint i = 0; i < 12; i++)
292 {
293 if ((edge & (1u << i)) != 0)
294 {
295 int a = EDGE_TO_VERTICES[i][0];
296 int b = EDGE_TO_VERTICES[i][1];
297
298 float T = (ISO_VALUE - vals[a]) / (vals[b] - vals[a]);
299 verts[i] = points[a] + (points[b] - points[a]) * T;
300 // if edge vertex, lookup density
301 vec3 normal_a;
302 float x0 = sample_density(verts[i] + vec3(d, 0, 0), center_offset, chunk_offset, voxel_size, padded);
303 float x1 = sample_density(verts[i] + vec3(-d, 0, 0), center_offset, chunk_offset, voxel_size, padded);
304 float y0 = sample_density(verts[i] + vec3(0, d, 0), center_offset, chunk_offset, voxel_size, padded);
305 float y1 = sample_density(verts[i] + vec3(0, -d, 0), center_offset, chunk_offset, voxel_size, padded);
306 float z0 = sample_density(verts[i] + vec3(0, 0, d), center_offset, chunk_offset, voxel_size, padded);
307 float z1 = sample_density(verts[i] + vec3(0, 0, -d), center_offset, chunk_offset, voxel_size, padded);
308 normal_a.x = x0 - x1;
309 normal_a.y = y0 - y1;
310 normal_a.z = z0 - z1;
311
312 normals[i] = normalize(normal_a);
313 }
314 }
315
316 int tcnt = 0;
317 int next_vertex = TRIANGLE_TABLE[val][tcnt++];
318 int base = ((uSize * uSize * uSize * 15) + ((uSize + 2) * 12 * 6)) * chunk_id;
319 float skirt_length = 3;
320 for (int i = 0; i < 5; i++)
321 {
322
323 if(next_vertex == -1) break;
324 int border_verts[3];
325 int bv_count = 0;
326 int vcnt = atomicAdd(chunk_vertex_offset[chunk_id], 3);
327 vcnt += base;
328
329 vertices[vcnt].pos = verts[next_vertex];
330 if (vert_on_border[next_vertex])
331 {
332 border_verts[bv_count++] = next_vertex;
333 }
334 vertices[vcnt].normal = normals[next_vertex];
335
336 next_vertex = TRIANGLE_TABLE[val][tcnt++];
337
338 vertices[vcnt+1].pos = verts[next_vertex];
339 vertices[vcnt+1].normal = normals[next_vertex];
340 if (vert_on_border[next_vertex])
341 {
342 border_verts[bv_count++] = next_vertex;
343 }
344
345 next_vertex = TRIANGLE_TABLE[val][tcnt++];
346
347 vertices[vcnt+2].pos = verts[next_vertex];
348 vertices[vcnt+2].normal = normals[next_vertex];
349 if (vert_on_border[next_vertex])
350 {
351 border_verts[bv_count++] = next_vertex;
352 }
353
354 next_vertex = TRIANGLE_TABLE[val][tcnt++];
355
356
357 if (next_vertex == -1) break;
358 }
359
360}
in vec3 c0
in vec3 c1
layout(local_size_x=16, local_size_y=16, local_size_z=1) in
#define NUM_OCTAVES
Definition density.comp:111
float mod289(float x)
Definition density.comp:112
uniform int chunk_id
Definition density.comp:159
vec4 perm(vec4 x)
Definition density.comp:114
uniform int uSize
Definition density.comp:153
uniform vec3 chunk_offset
Definition density.comp:155
float fbm(vec3 x)
Definition density.comp:139
vec3 sun_dir
Definition main.c:237
vec3 sun_color
Definition main.c:238
float * perlin_tex
Definition init.c:610
float * fbm_tex
Definition init.c:346
ParticleVertex verts[BODY_COUNT]
Definition main.c:249
int main(int argc, char *argv[])
Definition main.c:1726
const vec3 delta[8]
float density_fn(vec3 p)
float sample_density(vec3 p, vec3 chunk_offset, vec3 center_offset, float voxel_size, uint padded)
uint density_index(uvec3 p, uint padded)
const float ISO_VALUE
float lookup_density(uvec3 p, uint padded)
vec3 check_bounds(vec3 p, vec3 min, vec3 max)
const int TRIANGLE_TABLE[256][16]
const int EDGE_TO_VERTICES[12][2]
const int EDGE_TABLE[256]
vec3 color
Definition types.h:353
float pad1
Definition types.h:352
float pad0
Definition types.h:350
uniform mat4 projection
Definition shadow.vert:8
uniform mat4 view
Definition shadow.vert:9
vec3 pos
Definition types.h:349
float pad2
Definition types.h:354
vec3 normal
Definition types.h:351
float x
Definition main.h:5
float noise(vec3 p)
Definition density.comp:116
float y
Definition types.h:47
float y
Definition main.h:5
#define MAX_CHUNKS
Definition types.h:182
float z
Definition main.h:5
#define MAX_LAYERS
Definition types.h:407
Definition types.h:51
Definition types.h:45
Definition main.h:5
Definition types.h:47
vec3 offset2
Definition types.h:378
float pad1
Definition types.h:403
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 pad3
Definition types.h:383
float freq1
Definition types.h:377
float pad1
Definition types.h:382
float pad0
Definition types.h:392
float freq2
Definition types.h:379
vec3 offset0
Definition types.h:374
float pad1
Definition types.h:393
float pad0
Definition types.h:381
float amp
Definition types.h:380
float freq
Definition types.h:390
float pad0
Definition types.h:402