Fix ellipsoids in simulation

diff --git a/billboardfrag.glsl b/billboardfrag.glsl
index 046b7bd3bca6e335cd847e6e6dc4151f4edf03fa..16e074e616aae9ea8101b38a11564982e249c894 100644 (file)
--- a/billboardfrag.glsl
+++ b/billboardfrag.glsl
@@ -4,11 +4,11 @@ uniform sampler2D tex;
 in vec2 texCoord;
 out vec4 FragColor;
 uniform bool modulate;
-uniform bool debugContDist;
-uniform float density;
+uniform bool debug;
+uniform float debugVal;
 void main() {
-  if (debugContDist) {
-    FragColor = mix(vec4(1, 1, 1, 1), vec4(1, 0, 0, 1), density);
+  if (debug) {
+    FragColor = mix(vec4(1, 1, 1, 1), vec4(1, 0, 0, 1), debugVal);
     return;
   }
        // Cf = color from fragment, Ct = color from texture

diff --git a/clouds.cpp b/clouds.cpp
index 52b3053812d8f16416361e519270e8df1bd23dfa..baabcba703d4aca0e44e80f142e7eb97a82ed1c7 100644 (file)
--- a/clouds.cpp
+++ b/clouds.cpp
@@ -14,7 +14,13 @@
 
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 
-bool debugContDist = false;
+enum Mode {
+  render,
+  debugContDist,
+  debugProbExt,
+  debugProbAct
+};
+Mode curMode = render;
 
 using namespace std;
 using namespace glm;
@@ -85,6 +91,7 @@ void precalculateBillboardTextures() {
 
 struct Metaball {
   vec3 pos;
+  ivec3 coords;
   /** Radius, density */
   float r, d;
   vec4 col;
@@ -109,6 +116,7 @@ void calculateMetaballs() {
       for (int k = 0; k < CLOUD_DIM; k++) {
         Metaball m = {
             {i / (float)CLOUD_DIM, j / (float)CLOUD_DIM, k / (float)CLOUD_DIM},
+            {i, j, k},
             1.f / (float)CLOUD_DIM};
         m.pos = (m.pos * vec3(2)) - vec3(1);
         m.d = cs.q[i][j][k];
@@ -224,7 +232,7 @@ void renderClouds() {
     return distance(camPos, a.pos) > distance(camPos, b.pos);
   });
 
-  glUniform1i(glGetUniformLocation(bbProg, "debugContDist"), debugContDist);
+  glUniform1i(glGetUniformLocation(bbProg, "debug"), curMode != render);
 
   glDisable(GL_DEPTH_TEST);
   glEnable(GL_BLEND);
@@ -258,8 +266,12 @@ void renderClouds() {
     // Don't modulate it -- blend it
     glUniform1i(glGetUniformLocation(bbProg, "modulate"), 0);
 
-    if (debugContDist) {
-      glUniform1f(glGetUniformLocation(bbProg, "density"), k.d);
+    if (curMode != render) {
+      float debugVal = 0;
+      if (curMode == debugContDist) debugVal = k.d;
+      else if (curMode == debugProbAct) debugVal = cs.p_act[k.coords.x][k.coords.y][k.coords.z];
+      else if (curMode == debugProbExt) debugVal = cs.p_ext[k.coords.x][k.coords.y][k.coords.z];
+      glUniform1f(glGetUniformLocation(bbProg, "debugVal"), debugVal);
       glDisable(GL_BLEND);
       model = scale(model, vec3(0.02));
       glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
@@ -301,8 +313,8 @@ void timer(int _) {
   /* calculateMetaballs(); */
   if (needsRedisplay) {
     glutPostRedisplay();
-    needsRedisplay = false;
   }
+  needsRedisplay = false;
   glutTimerFunc(16, timer, 0);
 }
 
@@ -312,8 +324,20 @@ void keyboard(unsigned char key, int x, int y) {
     needsRedisplay = true;
     needsReshading = true;
   }
-  if (key == 'd') {
-    debugContDist = !debugContDist;
+  if (key == '0') {
+    curMode = render;
+    needsRedisplay = true;
+  }
+  if (key == '1') {
+    curMode = debugContDist;
+    needsRedisplay = true;
+  }
+  if (key == '2') {
+    curMode = debugProbAct;
+    needsRedisplay = true;
+  }
+  if (key == '3') {
+    curMode = debugProbExt;
     needsRedisplay = true;
   }
 }

diff --git a/simulation.cpp b/simulation.cpp
index e022d12b1b921901b42dcceaa50466a0e96b439f..360fb07481a2702188c6afd63ea9d34b72c27846 100644 (file)
--- a/simulation.cpp
+++ b/simulation.cpp
@@ -23,9 +23,9 @@ void initClouds(Clouds *cs) {
   for (int i = 0; i < CLOUD_DIM; i++) {
     for (int j = 0; j < CLOUD_DIM; j++) {
       for (int k = 0; k < CLOUD_DIM; k++) {
-        cs->act[i][j][k] = rand() % 8 == 0;
+        cs->act[i][j][k] = randf() < 0.01;
         cs->cld[i][j][k] = false;
-        cs->hum[i][j][k] = rand() % 9 == 0;
+        cs->hum[i][j][k] = randf() < 0.01;
         cs->p_ext[i][j][k] = 0.f;
         cs->p_hum[i][j][k] = 0.f;
         cs->p_act[i][j][k] = 0.f;
@@ -33,19 +33,31 @@ void initClouds(Clouds *cs) {
     }
   }
 
+  for (int i = 0; i < CLOUD_DIM; i++) {
+    for (int j = 0; j < CLOUD_DIM; j++) {
+      for (int k = 0; k < CLOUD_DIM; k++) {
+        assert(cs->p_act[i][j][k] == 0.f);
+        assert(cs->p_ext[i][j][k] == 0.f);
+        assert(cs->p_hum[i][j][k] == 0.f);
+      }
+    }
+  }
+
   // generate ellipsoids of probability
   for (int n = 0; n < 6; n++) {
-    const float maxSize = 5;
-    int width = randf() * maxSize, height = randf() * maxSize, depth = randf() * maxSize;
+    const float maxSize = 8, minSize = 4;
+    float delta = maxSize - minSize;
+    int width = minSize + randf() * delta, height = minSize + randf() * delta, depth = minSize + randf() * delta;
     int x = randf() * CLOUD_DIM, y = randf() * CLOUD_DIM, z = randf() * CLOUD_DIM;
     glm::vec3 center(x + width / 2, y + height / 2, z + depth / 2);
 
     for (int i = x; i < x + width; i++) {
       for (int j = y; j < y + height; j++) {
         for (int k = z; k < z + depth; k++) {
-          set(cs->p_ext, x, y, z, P_EXT * glm::distance(glm::vec3(x,y,z), center) / maxSize);
-          set(cs->p_hum, x, y, z, P_HUM * (1.f - glm::distance(glm::vec3(x,y,z), center) / maxSize));
-          set(cs->p_act, x, y, z, P_ACT * (1.f - glm::distance(glm::vec3(x,y,z), center) / maxSize));
+          float dist = glm::distance(glm::vec3(i,j,k), center) / maxSize;
+          set(cs->p_ext, i, j, k, P_EXT * dist);
+          set(cs->p_hum, i, j, k, P_HUM * (1.f - dist));
+          set(cs->p_act, i, j, k, P_ACT * (1.f - dist));
         }
       }
     }
@@ -69,7 +81,7 @@ inline bool f_act(Clouds *cs, int i, int j, int k) {
 }
 
 void growth(Clouds *cs) {
-  Clouds ncs;
+  Clouds ncs = *cs;
 
   for (int i = 0; i < CLOUD_DIM; i++) {
     for (int j = 0; j < CLOUD_DIM; j++) {
@@ -85,7 +97,7 @@ void growth(Clouds *cs) {
 }
 
 void extinction(Clouds *cs) {
-  Clouds ncs;
+  Clouds ncs = *cs;
   for (int i = 0; i < CLOUD_DIM; i++) {
     for (int j = 0; j < CLOUD_DIM; j++) {
       for (int k = 0; k < CLOUD_DIM; k++) {