--- /dev/null
+#include "debug.hpp"
+#include "program.hpp"
+#include <GL/glew.h>
+#include <GLUT/glut.h>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <glm/ext.hpp>
+#include <glm/glm.hpp>
+#include <vector>
+
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+
+using namespace std;
+using namespace glm;
+
+static const int CLOUD_DIM = 16;
+struct Clouds {
+ char cld[CLOUD_DIM][CLOUD_DIM][CLOUD_DIM];
+ float contDist[CLOUD_DIM][CLOUD_DIM][CLOUD_DIM];
+};
+
+// calculate continuous distribution
+void calcContDist(Clouds *clds);
+
+float w(int i, int j, int k) { return 1; }
+
+const float metaballR = 1;
+float metaballField(float r) {
+ if (r > metaballR)
+ return 0;
+ const float a = r / metaballR;
+ return (-4.f / 9.f * powf(a, 6)) + (17.f / 9.f * powf(a, 4)) -
+ (22.f / 9.f * powf(a, 2)) + 1;
+}
+
+/* const float normalizationFactor = 748.f / 405.f * M_PI * metaballR; */
+
+void calcContDist(Clouds *clds, float t) {
+ const int i0 = 2, j0 = 2, k0 = 2, t0 = 2;
+ const float divisor =
+ 1.f / ((2 * t0 + 1) * (2 * k0 + 1) * (2 * j0 + 1) * (2 * i0 + 1));
+ float sum = 0;
+ for (int i = 0; i < CLOUD_DIM; i++) {
+ for (int j = 0; j < CLOUD_DIM; j++) {
+ for (int k = 0; k < CLOUD_DIM; k++) {
+
+ // inner sums
+ /* for (int tp = -t0, tp < t0; tp++) { */
+ for (int ip = -i0; ip < i0; ip++) {
+ for (int jp = -j0; jp < j0; jp++) {
+ for (int kp = -k0; kp < k0; kp++) {
+
+ sum += w(ip, jp, kp) * (float)clds->cld[i + ip][j + jp][k + kp];
+ }
+ }
+ }
+ /* } */
+
+ clds->contDist[i][j][k] = sum / divisor;
+ }
+ }
+ }
+}
+
+void checkError() {
+ if (GLenum e = glGetError()) {
+ fprintf(stderr, "%s\n", gluErrorString(e));
+ abort();
+ }
+}
+
+vector<vec4> bbColors;
+
+GLuint bbProg;
+GLuint bbVao;
+
+void calculateMetaballs() {}
+
+// Here we need to generate n_q textures for different densities of metaballs
+// These textures then go on the billboards
+// The texture stores attenuation ratio?
+
+#define NQ 1
+GLuint bbTexIds[NQ];
+
+void precalculateBillboardTextures() {
+ float data[32 * 32];
+ // TODO: properly calculate this instead of whatever this is
+ for (int j = 0; j < 32; j++)
+ for (int i = 0; i < 32; i++)
+ data[i + j * 32] = fmin(1.f, 0.1f + 2.f * (distance(vec2(i, j), vec2(16, 16)) / 16));
+
+ glGenTextures(NQ, bbTexIds);
+
+ /* GLuint captureFBO; */
+ /* glGenFramebuffers(1, &captureFBO); */
+ for (int i = 0; i < NQ; i++) {
+ glBindTexture(GL_TEXTURE_2D, bbTexIds[i]);
+ /* glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, 32, 32, 0, GL_RED, */
+ /* GL_FLOAT, data); */
+ glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, 32, 32, 0, GL_RED, GL_FLOAT, data);
+ glGenerateMipmap(GL_TEXTURE_2D); // required, otherwise texture is blank
+
+ checkError();
+ }
+}
+
+struct Metaball {
+ vec3 pos;
+ float r;
+};
+// TODO: why is the x axis flipped??
+/* vector<Metaball> metaballs = {{{-0.5, 0.5, 0.5}, 0.25}, */
+/* {{-0.3, 0.5, 0.3}, 0.25}}; */
+vector<Metaball> metaballs = {{{0, 0, 0.5}, 1.f},
+ {{0, 0.3, 0.3}, 0.7f}};
+
+vec3 sunPos = {0, 2, 2}, viewPos = {0, 0, 0}, lookPos = {0, 0, 1};
+mat4 proj; // projection matrix
+mat4 view; // view matrix
+float znear = 0.001, zfar = 1000;
+float width = 600, height = 400;
+float aspect = width / height;
+
+void setProjectionAndViewUniforms(GLuint progId) {
+ GLuint projLoc = glGetUniformLocation(progId, "projection");
+ glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(proj));
+
+ GLuint viewLoc = glGetUniformLocation(progId, "view");
+ glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
+}
+
+/** Orientates the transformation matrix to face the camera in the view matrix
+ */
+void faceView(mat4 m) {
+ m[0][0] = view[0][0];
+ m[0][1] = view[1][0];
+ m[0][2] = view[2][0];
+ m[1][0] = view[0][1];
+ m[1][1] = view[1][1];
+ m[1][2] = view[2][1];
+ m[2][0] = view[0][2];
+ m[2][1] = view[1][2];
+ m[2][2] = view[2][2];
+}
+
+GLuint attenuationTex;
+
+void shadeClouds() {
+
+ bbColors.clear();
+
+ glDisable(GL_DEPTH_TEST);
+ glBlendFunc(GL_ZERO, GL_SRC_ALPHA);
+ glEnable(GL_BLEND);
+
+ // sort by ascending distance from the sun
+ sort(metaballs.begin(), metaballs.end(), [](Metaball &a, Metaball &b) {
+ return distance(sunPos, a.pos) < distance(sunPos, b.pos);
+ });
+ /* GLuint fbo; */
+ /* glGenFramebuffers(1, &fbo); */
+ /* glBindFramebuffer(GL_FRAMEBUFFER, fbo); */
+ /* glBindTexture(GL_TEXTURE_2D, attenuationTex); */
+ /* glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, */
+ /* GL_UNSIGNED_BYTE, NULL); */
+ /* glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, */
+ /* attenuationTex, 0); */
+ /* assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE); */
+
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_2D, bbTexIds[0]);
+ glUniform1i(glGetUniformLocation(bbProg, "tex"), 0);
+
+/* glClearColor(1, 1, 1, 1); */
+/* glClear(GL_COLOR_BUFFER_BIT); */
+
+
+ GLuint modelLoc = glGetUniformLocation(bbProg, "model");
+
+ for (auto k : metaballs) {
+ // place the billboard at the center of k
+ mat4 model = scale(translate(mat4(1), k.pos), vec3(k.r) * 2.f);
+
+ // rotate the billboard so that its normal is oriented to the sun
+ faceView(model);
+
+ glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
+
+ // Set the billboard color as RGBA = (1.0, 1.0, 1.0, 1.0).
+ vec4 color = {1, 1, 1, 1};
+ glUniform4fv(glGetUniformLocation(bbProg, "color"), 1,
+ glm::value_ptr(color));
+
+ // Map the billboard texture with GL_MODULATE.
+ // i.e. multiply rather than add
+ // TODO: FIX- this crashes with invalid operation
+ /* glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); */
+
+ // Render the billboard.
+ glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
+
+ // Read the pixel value corresponding to the center of metaball k.
+ // 1. First get position in opengl screen space: from [-1,1]
+ // 2. Normalize to [0,1]
+ // 3. Multiply by (width * height)
+ vec2 screenPos = ((vec2(proj * view * model * vec4(0,0,0,1)) + vec2(1)) / vec2(2))
+ * vec2(width, height);
+ vec4 pixel;
+ glReadPixels(screenPos.x, screenPos.y, 1, 1, GL_RGBA, GL_FLOAT, value_ptr(pixel));
+
+ // Multiply the pixel value by the sunlight color.
+ vec4 sunColor = {1, 1, 0.9, 1};
+ pixel *= sunColor;
+
+ // Store the color into an array C[k] as the color of the billboard.
+ fprintf(stderr, "pixel: ");
+ dump(pixel);
+ bbColors.push_back(pixel);
+ }
+
+ /* saveFBO(); */
+ checkError();
+
+ /* glDeleteFramebuffers(1, &fbo); */
+ /* glBindFramebuffer(GL_FRAMEBUFFER, 0); // render to screen */
+}
+
+void renderObject() {}
+
+void renderClouds() {
+ // Sort metaballs in descending order from the viewpoint
+ sort(metaballs.begin(), metaballs.end(), [](Metaball &a, Metaball &b) {
+ return distance(viewPos, a.pos) > distance(viewPos, b.pos);
+ });
+
+ glDisable(GL_DEPTH_TEST);
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_ONE, GL_SRC_ALPHA);
+ for (int i = 0; i < metaballs.size(); i++) {
+ Metaball k = metaballs[i];
+
+ GLuint modelLoc = glGetUniformLocation(bbProg, "model");
+
+ // Place the billboard at the center of the corresponding metaball n.
+ mat4 model = scale(translate(mat4(1), k.pos), vec3(k.r) * 2.f);
+ // Rotate the billboard so that its normal is oriented to the viewpoint.
+ faceView(model);
+
+ glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
+
+ // Set the billboard color as C[n].
+ fprintf(stderr, "bbColors[i]: ");
+ dump(bbColors[i]);
+ /* bbColors[i] = {0,0,0,0.5}; */
+ glUniform4fv(glGetUniformLocation(bbProg, "color"), 1,
+ glm::value_ptr(bbColors[i]));
+
+ // Map the billboard texture.
+ glActiveTexture(GL_TEXTURE0);
+ glBindTexture(GL_TEXTURE_2D, bbTexIds[0]);
+ glUniform1i(glGetUniformLocation(bbProg, "tex"), 0);
+
+ // Render the billboard with the blending function.
+ glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
+ }
+}
+
+void display() {
+ view = glm::lookAt(sunPos, viewPos, {0, 1, 0});
+ proj = glm::ortho(1.f * aspect, -1.f * aspect, -1.f, 1.f, znear, zfar);
+ setProjectionAndViewUniforms(bbProg);
+
+ glClearColor(1, 1, 1, 1);
+ glClear(GL_COLOR_BUFFER_BIT);
+ shadeClouds();
+
+ view = glm::lookAt(viewPos, lookPos, {0, 1, 0});
+ proj = glm::perspective(60.f, aspect, znear, zfar);
+ setProjectionAndViewUniforms(bbProg);
+
+ glClearColor(0.73,1,1,1); // background color
+ glClear(GL_COLOR_BUFFER_BIT);
+ renderObject(); // render things that aren't clouds
+ renderClouds();
+
+ glutSwapBuffers();
+}
+
+int main(int argc, char **argv) {
+ glutInit(&argc, argv);
+ glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB |
+ GLUT_3_2_CORE_PROFILE);
+ glutInitWindowSize(width, height);
+ glutCreateWindow("Clouds");
+ glutDisplayFunc(display);
+
+ glewInit();
+
+ Program prog("billboardvert.glsl", "billboardfrag.glsl");
+
+ bbProg = prog.progId;
+ glUseProgram(bbProg);
+
+ glGenVertexArrays(1, &bbVao);
+ glBindVertexArray(bbVao);
+ GLuint vbos[2];
+ glGenBuffers(2, vbos);
+
+ vector<vec3> poss = {{-1, -1, 0}, {-1, 1, 0}, {1, 1, 0}, {1, -1, 0}};
+ vector<GLuint> indices = {2, 1, 0, 3, 2, 0};
+
+ GLuint posLoc = glGetAttribLocation(bbProg, "vPosition");
+ glBindBuffer(GL_ARRAY_BUFFER, vbos[0]);
+ glBufferData(GL_ARRAY_BUFFER, poss.size() * sizeof(glm::vec3), &poss[0],
+ GL_STATIC_DRAW);
+ glEnableVertexAttribArray(posLoc);
+ glVertexAttribPointer(posLoc, 3, GL_FLOAT, GL_FALSE, 0, 0);
+
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbos[1]);
+ glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLuint),
+ &indices[0], GL_STATIC_DRAW);
+
+ prog.validate();
+
+ precalculateBillboardTextures();
+
+ calculateMetaballs();
+
+ glGenTextures(1, &attenuationTex);
+
+ /* glutTimerFunc(16, timer, 0); */
+
+ // set up billboard prog
+
+ glutMainLoop();
+
+ return 0;
+}