enum Mode {
render,
debugContDist,
+ debugColor,
debugProbExt,
debugProbAct
};
using namespace std;
using namespace glm;
-const float metaballR = 1.5f;
+const float metaballR = 2.f * 1.f / 16.f;
inline float metaballField(float r) {
if (r > metaballR)
return 0;
}
}
-GLuint bbProg;
+GLuint bbProg, sunProg;
GLuint bbVao;
// Here we need to generate n_q textures for different densities of metaballs
for (int j = 0; j < 32; j++) {
for (int i = 0; i < 32; i++) {
// TODO: properly calculate this instead of whatever this is
- float r = distance(vec2(i, j), vec2(16, 16)) / 16;
+ float r = distance(vec2(i, j), vec2(16, 16)) / 32;
float density = (float)d / NQ;
data[i + j * 32] =
- 1 - (density * metaballField(r) / normalizationFactor);
+ 1 - (density * 0.01 * metaballField(r * metaballR) / normalizationFactor);
}
}
struct Metaball {
vec3 pos;
ivec3 coords;
- /** Radius, density */
- float r, d;
+ /** Density */
+ float d;
vec4 col;
};
-array<Metaball, CLOUD_DIM * CLOUD_DIM * CLOUD_DIM> metaballs;
+array<Metaball, CLOUD_DIM_X * CLOUD_DIM_Y * CLOUD_DIM_Z> metaballs;
Clouds cs;
/* Metaball m = {{x,y,z}, r}; */
/* metaballs.push_back(m); */
/* } */
- for (int i = 0; i < CLOUD_DIM; i++) {
- for (int j = 0; j < CLOUD_DIM; j++) {
- for (int k = 0; k < CLOUD_DIM; k++) {
+ for (int i = 0; i < CLOUD_DIM_X; i++) {
+ for (int j = 0; j < CLOUD_DIM_Y; j++) {
+ for (int k = 0; k < CLOUD_DIM_Z; k++) {
+ const float cloudScale = 1.f / 16;
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);
+ vec3(i, j, k) * vec3(cloudScale),
+ {i, j, k} };
+ /* m.pos = (m.pos * vec3(2)) - (cloudScale / 2); */
+ m.pos -= vec3(CLOUD_DIM_X, CLOUD_DIM_Y, CLOUD_DIM_Z) * cloudScale / 2.f;
m.d = cs.q[i][j][k];
- metaballs[i * CLOUD_DIM * CLOUD_DIM + j * CLOUD_DIM + k] = m;
+ metaballs[i * CLOUD_DIM_Y * CLOUD_DIM_Z + j * CLOUD_DIM_Z + k] = m;
}
}
}
}
-vec3 sunPos = {0, 2, 2}, sunDir = {0, -1, -1};
+vec3 sunPos = {0, 5, 5}, sunDir = {0, -1, -1};
+/* vec4 sunColor = {1,0,0.429,1}; */
+vec4 sunColor = {1,1,1,1};
vec3 camPos = {0, 0, -5}, viewPos = {0, 0, 0};
mat4 proj; // projection matrix
mat4 view; // view matrix
GLuint attenuationTex;
+const float metaballScale = metaballR * 1.4f;
+
void shadeClouds() {
glDisable(GL_DEPTH_TEST);
// shaderOutput * 0 + buffer * shader alpha
glUniform1i(glGetUniformLocation(bbProg, "tex"), 0);
GLuint modelLoc = glGetUniformLocation(bbProg, "model");
+ glUniform1i(glGetUniformLocation(bbProg, "debug"), 0);
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);
+ mat4 model = translate(mat4(1), k.pos);
// rotate the billboard so that its normal is oriented to the sun
model = faceView(model);
+ model = scale(model, vec3(metaballScale));
+
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
// Set the billboard color as RGBA = (1.0, 1.0, 1.0, 1.0).
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.
checkError();
}
-void renderObject() {}
+void renderObject() {
+ glDisable(GL_BLEND);
+ // render the sun
+ glUseProgram(sunProg);
+ mat4 model = translate(mat4(1), sunPos);
+ /* model = lookAt(sunPos, sunPos + sunDir, {0, 1, 0}) * model; */
+ model = translate(scale(translate(model, -sunPos), vec3(0.3)), sunPos);
+ glUniformMatrix4fv(glGetUniformLocation(sunProg, "model"), 1, GL_FALSE, glm::value_ptr(model));
+ glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
+}
void renderClouds() {
+ glUseProgram(bbProg);
+
// Sort metaballs in descending order from the viewpoint
sort(metaballs.begin(), metaballs.end(), [](Metaball &a, Metaball &b) {
return distance(camPos, a.pos) > distance(camPos, b.pos);
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);
+ mat4 model = translate(mat4(1), k.pos);
// Rotate the billboard so that its normal is oriented to the viewpoint.
model = faceView(model);
+ model = scale(model, vec3(metaballScale));
+
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
// Set the billboard color as C[n].
// Don't modulate it -- blend it
glUniform1i(glGetUniformLocation(bbProg, "modulate"), 0);
+ glUniform1f(glGetUniformLocation(bbProg, "debugColor"), curMode == debugColor);
if (curMode != render) {
float debugVal = 0;
if (curMode == debugContDist) debugVal = k.d;
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));
+ model = scale(model, vec3(0.2));
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
}
view = glm::lookAt(camPos, viewPos, {0, 1, 0});
proj = glm::perspective(45.f, aspect, znear, zfar);
+ glUseProgram(sunProg);
+ setProjectionAndViewUniforms(sunProg);
+ glUseProgram(bbProg);
setProjectionAndViewUniforms(bbProg);
glClearColor(0.83, 1, 1, 1); // background color
if (key == ' ') {
calculateMetaballs();
needsRedisplay = true;
- needsReshading = true;
+ needsReshading = curMode == render;
}
if (key == '0') {
curMode = render;
needsRedisplay = true;
}
if (key == '2') {
- curMode = debugProbAct;
+ curMode = debugColor;
needsRedisplay = true;
}
if (key == '3') {
+ curMode = debugProbAct;
+ needsRedisplay = true;
+ }
+ if (key == '4') {
curMode = debugProbExt;
needsRedisplay = true;
}
float dx = x - prevMouseX, dy = y - prevMouseY;
prevMouseX = x;
prevMouseY = y;
- const vec3 origin(0, 18, 0);
+ const vec3 origin(0, 0, 0);
const float sensitivity = 0.003f;
auto camMat = translate(mat4(1), origin + camPos);
auto rotation = rotate(rotate(mat4(1), -dx * sensitivity, {0, 1, 0}),
glewInit();
Program prog("billboardvert.glsl", "billboardfrag.glsl");
-
bbProg = prog.progId;
- glUseProgram(bbProg);
+ Program sProg("sunvert.glsl", "sunfrag.glsl");
+ sunProg = sProg.progId;
glGenVertexArrays(1, &bbVao);
+ glUseProgram(sunProg);
+ glBindVertexArray(bbVao);
+ glUseProgram(bbProg);
glBindVertexArray(bbVao);
GLuint vbos[2];
glGenBuffers(2, vbos);
}
// Helper to account for bounds
-inline void set(float x[CLOUD_DIM][CLOUD_DIM][CLOUD_DIM], int i, int j, int k, float y) {
- if (i < 0 || i >= CLOUD_DIM ||
- j < 0 || j >= CLOUD_DIM ||
- k < 0 || k >= CLOUD_DIM)
+inline void set(float x[CLOUD_DIM_X][CLOUD_DIM_Y][CLOUD_DIM_Z], int i, int j, int k, float y) {
+ if (i < 0 || i >= CLOUD_DIM_X ||
+ j < 0 || j >= CLOUD_DIM_Y ||
+ k < 0 || k >= CLOUD_DIM_Z)
return;
x[i][j][k] = y;
}
#define P_ACT 0.001
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++) {
+ for (int i = 0; i < CLOUD_DIM_X; i++) {
+ for (int j = 0; j < CLOUD_DIM_Y; j++) {
+ for (int k = 0; k < CLOUD_DIM_Z; k++) {
cs->act[i][j][k] = randf() < 0.01;
cs->cld[i][j][k] = false;
- cs->hum[i][j][k] = randf() < 0.01;
+ cs->hum[i][j][k] = randf() < 0.1;
cs->p_ext[i][j][k] = 0.f;
cs->p_hum[i][j][k] = 0.f;
cs->p_act[i][j][k] = 0.f;
}
}
- for (int i = 0; i < CLOUD_DIM; i++) {
- for (int j = 0; j < CLOUD_DIM; j++) {
- for (int k = 0; k < CLOUD_DIM; k++) {
+ for (int i = 0; i < CLOUD_DIM_X; i++) {
+ for (int j = 0; j < CLOUD_DIM_Y; j++) {
+ for (int k = 0; k < CLOUD_DIM_Z; 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);
}
}
}
+ for (int k = 0; k < CLOUD_DIM_Z; k++)
+ cs->vz[k] = floor(randf() * 3);
// generate ellipsoids of probability
- for (int n = 0; n < 6; n++) {
+ const int numEllipsoids = CLOUD_DIM_X * CLOUD_DIM_Y * CLOUD_DIM_Z * 0.002;
+ for (int n = 0; n < numEllipsoids; n++) {
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;
+ int x = randf() * CLOUD_DIM_X, y = randf() * CLOUD_DIM_Y, z = randf() * CLOUD_DIM_Z;
glm::vec3 center(x + width / 2, y + height / 2, z + depth / 2);
for (int i = x; i < x + width; i++) {
}
// Helper to account for bounds
-inline bool get(bool x[CLOUD_DIM][CLOUD_DIM][CLOUD_DIM], int i, int j, int k) {
- if (i < 0 || i >= CLOUD_DIM ||
- j < 0 || j >= CLOUD_DIM ||
- k < 0 || k >= CLOUD_DIM)
+inline bool get(bool x[CLOUD_DIM_X][CLOUD_DIM_Y][CLOUD_DIM_Z], int i, int j, int k) {
+ if (i < 0 || i >= CLOUD_DIM_X ||
+ j < 0 || j >= CLOUD_DIM_Y ||
+ k < 0 || k >= CLOUD_DIM_Z)
return false;
return x[i][j][k];
}
void growth(Clouds *cs) {
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++) {
+ for (int i = 0; i < CLOUD_DIM_X; i++) {
+ for (int j = 0; j < CLOUD_DIM_Y; j++) {
+ for (int k = 0; k < CLOUD_DIM_Z; k++) {
ncs.hum[i][j][k] = cs->hum[i][j][k] && !cs->act[i][j][k];
ncs.cld[i][j][k] = cs->cld[i][j][k] || cs->act[i][j][k];
ncs.act[i][j][k] = !cs->act[i][j][k] && cs->hum[i][j][k] && f_act(cs, i, j, k);
void extinction(Clouds *cs) {
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++) {
+ for (int i = 0; i < CLOUD_DIM_X; i++) {
+ for (int j = 0; j < CLOUD_DIM_Y; j++) {
+ for (int k = 0; k < CLOUD_DIM_Z; k++) {
ncs.cld[i][j][k] = cs->cld[i][j][k] && (randf() > cs->p_ext[i][j][k]);
ncs.hum[i][j][k] = cs->hum[i][j][k] || (randf() < cs->p_hum[i][j][k]);
ncs.act[i][j][k] = cs->act[i][j][k] || (randf() < cs->p_act[i][j][k]);
*cs = ncs;
}
+void advection(Clouds *cs) {
+ Clouds ncs = *cs;
+
+ for (int i = 0; i < CLOUD_DIM_X; i++) {
+ for (int j = 0; j < CLOUD_DIM_Y; j++) {
+ for (int k = 0; k < CLOUD_DIM_Z; k++) {
+ int v = cs->vz[k];
+ ncs.hum[i][j][k] = i - v > 0 ? cs->hum[i - v][j][k] : 0;
+ ncs.cld[i][j][k] = i - v > 0 ? cs->cld[i - v][j][k] : 0;
+ ncs.act[i][j][k] = i - v > 0 ? cs->act[i - v][j][k] : 0;
+ }
+ }
+ }
+
+ *cs = ncs;
+}
+
/** Weighting function */
+// TODO: fill this out
float w(int ip, int jp, int kp) { return 1; }
void calcContDist(Clouds *cls) {
const int i0 = 2, j0 = 2, k0 = 2, t0 = 0;
const float divisor =
1.f / ((2 * t0 + 1) * (2 * k0 + 1) * (2 * j0 + 1) * (2 * i0 + 1));
- for (int i = 0; i < CLOUD_DIM; i++) {
- for (int j = 0; j < CLOUD_DIM; j++) {
- for (int k = 0; k < CLOUD_DIM; k++) {
+ for (int i = 0; i < CLOUD_DIM_X; i++) {
+ for (int j = 0; j < CLOUD_DIM_Y; j++) {
+ for (int k = 0; k < CLOUD_DIM_Z; k++) {
float sum = 0;
// sum
for (int ip = -i0; ip <= i0; ip++) {
for (int jp = -j0; jp <= j0; jp++) {
for (int kp = -k0; kp <= k0; kp++) {
- if (i + ip < 0 || i + ip >= CLOUD_DIM ||
- j + jp < 0 || j + jp >= CLOUD_DIM ||
- k + kp < 0 || k + kp >= CLOUD_DIM)
+ if (i + ip < 0 || i + ip >= CLOUD_DIM_X ||
+ j + jp < 0 || j + jp >= CLOUD_DIM_Y ||
+ k + kp < 0 || k + kp >= CLOUD_DIM_Z)
continue;
sum += w(ip, jp, kp) * (float)cls->cld[i + ip][j + jp][k + kp];
void stepClouds(Clouds *cs) {
growth(cs);
extinction(cs);
+ advection(cs);
calcContDist(cs);
}