4 #include "simulation.hpp"
11 #include <glm/ext.hpp>
12 #include <glm/glm.hpp>
16 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
18 enum Mode { render, debugContDist, debugColor, debugProbExt, debugProbAct };
19 Mode curMode = render;
24 const float metaballR = 1.f / 16.f;
25 inline float metaballField(float r) {
28 const float a = r / (1);
29 return (-4.f / 9.f * powf(a, 6)) + (17.f / 9.f * powf(a, 4)) -
30 (22.f / 9.f * powf(a, 2)) + 1;
33 const float normalizationFactor = (748.f / 405.f) * M_PI;
36 if (GLenum e = glGetError()) {
37 fprintf(stderr, "%s\n", gluErrorString(e));
42 GLuint bbProg, sunProg;
45 // Here we need to generate n_q textures for different densities of metaballs
46 // These textures then go on the billboards
47 // The texture stores attenuation ratio?
52 // Stores attenuation ratio inside r channel
53 // Should be highest value at center
54 void precalculateBillboardTextures() {
55 fprintf(stderr, "Calculating billboard textures...\n");
56 glGenTextures(NQ, bbTexIds);
58 for (int d = 0; d < NQ; d++) {
60 for (int j = 0; j < 32; j++) {
61 for (int i = 0; i < 32; i++) {
62 // TODO: properly calculate this instead of whatever this is
63 float r = distance(vec2(i, j), vec2(16, 16)) / 16;
64 float density = (float)d / NQ;
67 fmin(1, (3 * density * (metaballField(r) / normalizationFactor)));
73 snprintf(path, 32, "bbtex/%i.tga", d);
74 saveGrayscale(data, 32, 32, path);
76 glBindTexture(GL_TEXTURE_2D, bbTexIds[d]);
78 glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, 32, 32, 0, GL_RED, GL_FLOAT, data);
79 glGenerateMipmap(GL_TEXTURE_2D); // required, otherwise texture is blank
81 fprintf(stderr, "\r%i out of %i densities calculated%s", d + 1, NQ,
82 d == NQ - 1 ? "\n" : "");
94 array<Metaball, CLOUD_DIM_X * CLOUD_DIM_Y * CLOUD_DIM_Z> metaballs;
96 const float cloudScale = metaballR;
97 const float metaballScale = metaballR * 1.5f;
100 void calculateMetaballs() {
102 /* for (int i = 0; i < 256; i++) { */
103 /* float x = ((float)rand()/(float)(RAND_MAX) - 0.5) * 2; */
104 /* float y = ((float)rand()/(float)(RAND_MAX) - 0.5) * 2; */
105 /* float z = ((float)rand()/(float)(RAND_MAX) - 0.5) * 2; */
106 /* float r = (float)rand()/(float)(RAND_MAX) * 1; */
107 /* Metaball m = {{x,y,z}, r}; */
108 /* metaballs.push_back(m); */
110 for (int i = 0; i < CLOUD_DIM_X; i++) {
111 for (int j = 0; j < CLOUD_DIM_Y; j++) {
112 for (int k = 0; k < CLOUD_DIM_Z; k++) {
113 Metaball m = {vec3(i, j, k) * vec3(cloudScale), {i, j, k}};
114 /* m.pos = (m.pos * vec3(2)) - (cloudScale / 2); */
115 m.pos -= vec3(CLOUD_DIM_X, CLOUD_DIM_Y, CLOUD_DIM_Z) * cloudScale / 2.f;
118 metaballs[i * CLOUD_DIM_Y * CLOUD_DIM_Z + j * CLOUD_DIM_Z + k] = m;
122 /* for (int z = 0; z < CLOUD_DIM_Z; z++) */
123 /* metaballs[32 * CLOUD_DIM_Y * CLOUD_DIM_Z + 32 * CLOUD_DIM_Z + z].d = 1;
127 vec3 sunPos = {0, 5, 0}, sunDir = {0, -1, 0};
128 size_t envColorIdx = 0;
129 // First color is sun color, second is sky color
130 std::array<std::array<vec4, 2>, 3> envColors{
131 {{vec4(1, 1, 1, 1), vec4(0.9, 1, 1, 1)},
132 {vec4(0.939, 0.632, 0.815, 1), vec4(0.9, 1, 1, 1)},
133 {vec4(0.999, 0.999, 0.519, 1), vec4(0.981, 0.667, 0.118, 1)}}};
134 vec3 camPos = {0, 0, -3}, viewPos = {0, 0, 0};
135 mat4 proj; // projection matrix
136 mat4 view; // view matrix
137 float znear = 0.001, zfar = 1000;
138 // for performance with glReadPixels these should be powers of 2!
139 float width = 1200, height = 800;
141 void setProjectionAndViewUniforms(GLuint progId) {
142 GLuint projLoc = glGetUniformLocation(progId, "projection");
143 glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(proj));
145 GLuint viewLoc = glGetUniformLocation(progId, "view");
146 glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
149 /** Orientates the transformation matrix to face the camera in the view matrix
151 mat4 faceView(mat4 m) {
152 m[0][0] = view[0][0];
153 m[0][1] = view[1][0];
154 m[0][2] = view[2][0];
155 m[1][0] = view[0][1];
156 m[1][1] = view[1][1];
157 m[1][2] = view[2][1];
158 m[2][0] = view[0][2];
159 m[2][1] = view[1][2];
160 m[2][2] = view[2][2];
166 /* const int shadeWidth = 256, shadeHeight = 256; */
167 const int shadeWidth = 256, shadeHeight = 256;
170 const int numPbos = 512;
171 GLuint pboBufs[numPbos];
172 GLuint pboOffsets[numPbos]; // offsets into GL_PIXEL_PACK_BUFFER that
173 // mapPixelRead should read from
174 GLbyte sink[shadeWidth * shadeHeight * 4];
176 void inline mapPixelRead(int pboBuf, int metaball) {
177 glBindBuffer(GL_PIXEL_PACK_BUFFER, pboBufs[pboBuf]);
179 (GLubyte *)glMapBufferRange(GL_PIXEL_PACK_BUFFER, 0,
180 4 * sizeof(GLubyte), GL_MAP_READ_BIT);
181 /* (GLubyte *)glMapBufferRange(GL_PIXEL_PACK_BUFFER, pboOffsets[pboBuf], */
182 /* 4 * sizeof(GLubyte), GL_MAP_READ_BIT); */
183 vec4 pixel = vec4(src[0], src[1], src[2], src[3]) / vec4(255.f);
184 glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
186 glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
188 // Multiply the pixel value by the sunlight color.
189 pixel *= envColors[envColorIdx][0];
191 // Store the color for the previous set of pixels
192 metaballs[metaball].col = pixel;
199 glDisable(GL_DEPTH_TEST);
200 // shaderOutput * 0 + buffer * shader alpha
201 glBlendFunc(GL_ZERO, GL_SRC_ALPHA);
204 // sort by ascending distance from the sun
205 sort(metaballs.begin(), metaballs.end(), [](Metaball &a, Metaball &b) {
206 return distance(sunPos, a.pos) < distance(sunPos, b.pos);
209 glActiveTexture(GL_TEXTURE0);
210 glUniform1i(glGetUniformLocation(bbProg, "tex"), 0);
212 GLuint modelLoc = glGetUniformLocation(bbProg, "model");
213 glUniform1i(glGetUniformLocation(bbProg, "debug"), 0);
215 glViewport(0, 0, shadeWidth, shadeHeight);
221 auto begin_time = std::chrono::system_clock::now();
223 for (auto &k : metaballs) {
224 /* fprintf(stderr, "\rShading metaball %lu/%lu...", i, metaballs.size()); */
225 // place the billboard at the center of k
226 mat4 model = translate(mat4(1), k.pos);
228 // rotate the billboard so that its normal is oriented to the sun
229 model = faceView(model);
231 model = scale(model, vec3(metaballScale));
233 glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
235 // Set the billboard color as RGBA = (1.0, 1.0, 1.0, 1.0).
236 vec4 color = {1, 1, 1, 1};
237 glUniform4fv(glGetUniformLocation(bbProg, "color"), 1,
238 glm::value_ptr(color));
240 // Map the billboard texture with GL_MODULATE.
241 // i.e. multiply rather than add
242 // but glTexEnv is for the old fixed function pipeline --
243 // need to just tell our fragment shader then to modulate
245 glBindTexture(GL_TEXTURE_2D, bbTexIds[dIdx]);
246 glUniform1i(glGetUniformLocation(bbProg, "modulate"), 1);
248 // Render the billboard.
249 glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
251 // Read the pixel value corresponding to the center of metaball k.
252 // 1. First get position in opengl screen space: from [-1,1]
253 // 2. Normalize to [0,1]
254 // 3. Multiply by (width * height)
256 ((vec2(proj * view * model * vec4(0, 0, 0, 1)) + vec2(1)) / vec2(2)) *
257 vec2(shadeWidth, shadeHeight);
261 // TODO: This is a huge bottleneck
262 glReadPixels(screenPos.x, screenPos.y, 1, 1, GL_RGBA, GL_FLOAT, &pixel);
264 // Multiply the pixel value by the sunlight color.
265 pixel *= envColors[envColorIdx][0];
267 // Store the color into an array C[k] as the color of the billboard.
271 glBindBuffer(GL_PIXEL_PACK_BUFFER, pboBufs[pboIdx]);
272 // It would be nice if this worked. But it doesn't
273 // macOS driver does this synchronously
274 /* glReadPixels(screenPos.x, screenPos.y, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
277 /* glReadPixels(0, 0, shadeWidth, shadeHeight, GL_RGBA, GL_UNSIGNED_BYTE, */
279 glReadPixels(screenPos.x, screenPos.y, 64, 64, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
280 /* pboOffsets[pboIdx] = screenPos.x * 4 + screenPos.y * shadeWidth * 4; */
282 int nextPbo = (pboIdx + 1) % numPbos;
283 if (i >= numPbos - 1) {
284 // start mapping the read values back
285 mapPixelRead(nextPbo, i - numPbos + 1);
292 /* fprintf(stderr, "\n"); */
295 // sink remaining reads
296 for (int i = 0; i < numPbos; i++) {
297 mapPixelRead(i, metaballs.size() - numPbos + i);
301 auto elapsed = std::chrono::system_clock::now() - begin_time;
302 double elapsed_seconds =
303 std::chrono::duration_cast<std::chrono::duration<double>>(elapsed)
305 fprintf(stderr, "Time taken to shade: %fs\n", elapsed_seconds);
309 glViewport(0, 0, width, height);
312 void renderObject() {
315 glUseProgram(sunProg);
316 mat4 model = translate(mat4(1), sunPos);
317 model = lookAt(sunPos, sunPos + sunDir, {0, 1, 0}) * model;
318 model = translate(scale(translate(model, -sunPos), vec3(0.3)), sunPos);
319 glUniformMatrix4fv(glGetUniformLocation(sunProg, "model"), 1, GL_FALSE,
320 glm::value_ptr(model));
321 glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
324 void renderClouds() {
325 glUseProgram(bbProg);
327 // Sort metaballs in descending order from the viewpoint
328 sort(metaballs.begin(), metaballs.end(), [](Metaball &a, Metaball &b) {
329 return distance(camPos, a.pos) > distance(camPos, b.pos);
332 glUniform1i(glGetUniformLocation(bbProg, "debug"), curMode != render);
334 glDisable(GL_DEPTH_TEST);
336 // shaderOutput * 1 + buffer * shader alpha
337 glBlendFunc(GL_ONE, GL_SRC_ALPHA);
339 /* glBlendColor(1.f,1.f,1.f,1.f); */
340 /* glBlendFuncSeparate(GL_ONE, GL_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_SRC_ALPHA);
343 glActiveTexture(GL_TEXTURE0);
344 glUniform1i(glGetUniformLocation(bbProg, "tex"), 0);
346 for (int i = 0; i < metaballs.size(); i++) {
347 Metaball k = metaballs[i];
349 GLuint modelLoc = glGetUniformLocation(bbProg, "model");
351 // Place the billboard at the center of the corresponding metaball n.
352 mat4 model = translate(mat4(1), k.pos);
353 // Rotate the billboard so that its normal is oriented to the viewpoint.
354 model = faceView(model);
356 model = scale(model, vec3(metaballScale));
358 glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
360 // Set the billboard color as C[n].
362 glUniform4fv(glGetUniformLocation(bbProg, "color"), 1,
363 glm::value_ptr(k.col));
365 // Map the billboard texture.
366 int dIdx = k.d * (NQ - 1);
367 glBindTexture(GL_TEXTURE_2D, bbTexIds[dIdx]);
369 // Don't modulate it -- blend it
370 glUniform1i(glGetUniformLocation(bbProg, "modulate"), 0);
372 glUniform1f(glGetUniformLocation(bbProg, "debugColor"),
373 curMode == debugColor);
374 if (curMode != render) {
376 if (curMode == debugContDist)
378 else if (curMode == debugProbAct)
379 debugVal = cs.p_act[k.coords.x][k.coords.y][k.coords.z] / P_ACT;
380 else if (curMode == debugProbExt)
381 debugVal = cs.p_ext[k.coords.x][k.coords.y][k.coords.z] / P_EXT;
382 glUniform1f(glGetUniformLocation(bbProg, "debugVal"), debugVal);
383 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
384 model = scale(model, vec3(0.1));
385 glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
388 // Render the billboard with the blending function.
389 glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
393 bool curBeenShaded = false;
396 if (!curBeenShaded && (curMode == render || curMode == debugColor)) {
397 // TODO: find a way to make sure there's no clipping
398 view = glm::lookAt(sunPos + sunDir * vec3(100.f), sunPos, {0, 0, 1});
399 // TODO: calculate bounds so everything is covered
400 proj = glm::ortho(2.5f, -2.5f, -2.5f, 2.5f, znear, 10000.f);
401 glUseProgram(bbProg);
402 setProjectionAndViewUniforms(bbProg);
404 glClearColor(1, 1, 1, 1);
405 glClear(GL_COLOR_BUFFER_BIT);
407 curBeenShaded = true;
410 view = glm::lookAt(camPos, viewPos, {0, 1, 0});
411 const float aspect = width / height;
412 proj = glm::perspective(45.f, aspect, znear, zfar);
413 glUseProgram(sunProg);
414 setProjectionAndViewUniforms(sunProg);
415 glUseProgram(bbProg);
416 setProjectionAndViewUniforms(bbProg);
418 vec4 skyColor = envColors[envColorIdx][1];
419 glClearColor(skyColor.r, skyColor.g, skyColor.b,
420 skyColor.a); // background color
421 glClear(GL_COLOR_BUFFER_BIT);
422 renderObject(); // render things that aren't clouds
428 bool needsRedisplay = false;
430 if (needsRedisplay) {
433 needsRedisplay = false;
434 glutTimerFunc(16, timer, 0);
437 void keyboard(unsigned char key, int x, int y) {
439 calculateMetaballs();
440 needsRedisplay = true;
441 curBeenShaded = false;
445 needsRedisplay = true;
448 curMode = debugContDist;
449 needsRedisplay = true;
452 curMode = debugColor;
453 needsRedisplay = true;
456 curMode = debugProbAct;
457 needsRedisplay = true;
460 curMode = debugProbExt;
461 needsRedisplay = true;
464 envColorIdx = (envColorIdx + 1) % envColors.size();
465 needsRedisplay = true;
466 curBeenShaded = false;
470 int prevMouseX, prevMouseY;
471 bool firstMouse = true;
472 void motion(int x, int y) {
478 float dx = x - prevMouseX, dy = y - prevMouseY;
481 const vec3 origin(0, 0, 0);
482 const float sensitivity = 0.003f;
483 auto camMat = translate(mat4(1), origin + camPos);
484 auto rotation = rotate(rotate(mat4(1), -dx * sensitivity, {0, 1, 0}),
485 -dy * sensitivity, {1, 0, 0});
486 auto rotAroundOrig = camMat * rotation * translate(mat4(1), origin - camPos);
487 camPos = rotAroundOrig * glm::vec4(camPos, 0);
488 needsRedisplay = true;
491 void passiveMotion(int x, int y) {
496 void reshape(int w, int h) {
501 int main(int argc, char **argv) {
502 glutInit(&argc, argv);
503 glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA | GLUT_ALPHA |
504 GLUT_3_2_CORE_PROFILE);
505 glutInitWindowSize(width, height);
506 glutCreateWindow("Clouds");
507 glutDisplayFunc(display);
508 glutReshapeFunc(reshape);
509 glutKeyboardFunc(keyboard);
510 glutMotionFunc(motion);
511 glutPassiveMotionFunc(passiveMotion);
512 glutTimerFunc(16, timer, 0);
516 Program prog("billboardvert.glsl", "billboardfrag.glsl");
517 bbProg = prog.progId;
518 Program sProg("sunvert.glsl", "sunfrag.glsl");
519 sunProg = sProg.progId;
521 glGenVertexArrays(1, &bbVao);
522 glUseProgram(sunProg);
523 glBindVertexArray(bbVao);
524 glUseProgram(bbProg);
525 glBindVertexArray(bbVao);
527 glGenBuffers(2, vbos);
529 vector<vec3> poss = {{-1, -1, 0}, {-1, 1, 0}, {1, 1, 0}, {1, -1, 0}};
530 vector<GLuint> indices = {2, 1, 0, 3, 2, 0};
532 GLuint posLoc = glGetAttribLocation(bbProg, "vPosition");
533 glBindBuffer(GL_ARRAY_BUFFER, vbos[0]);
534 glBufferData(GL_ARRAY_BUFFER, poss.size() * sizeof(glm::vec3), &poss[0],
536 glEnableVertexAttribArray(posLoc);
537 glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, 0, 0);
539 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbos[1]);
540 glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLuint),
541 &indices[0], GL_STATIC_DRAW);
545 precalculateBillboardTextures();
548 calculateMetaballs();
551 // setup PBOs for buffering readPixels
552 glGenBuffers(numPbos, pboBufs);
553 for (int i = 0; i < numPbos; i++) {
554 glBindBuffer(GL_PIXEL_PACK_BUFFER, pboBufs[i]);
555 glBufferData(GL_PIXEL_PACK_BUFFER, 64 * 64 * 4, NULL,
558 glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);