using namespace std;
using namespace glm;
-const float metaballR = 2.f * 1.f / 16.f;
+const float metaballR = 1.f / 16.f;
inline float metaballField(float r) {
- if (r > metaballR)
+ if (r > 1)
return 0;
- const float a = r / metaballR;
+ const float a = r / (1);
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;
+const float normalizationFactor = (748.f / 405.f) * M_PI;
void checkError() {
if (GLenum e = glGetError()) {
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)) / 32;
+ float r = distance(vec2(i, j), vec2(16, 16)) / 16;
float density = (float)d / NQ;
data[i + j * 32] =
- 1 - (density * 0.01 * metaballField(r * metaballR) / normalizationFactor);
+ 1 - (density * 0.7 * (metaballField(r) / normalizationFactor));
}
}
saveGrayscale(data, 32, 32, path);
glBindTexture(GL_TEXTURE_2D, bbTexIds[d]);
- checkError();
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();
fprintf(stderr, "\r%i out of %i densities calculated%s", d + 1, NQ,
d == NQ - 1 ? "\n" : "");
array<Metaball, CLOUD_DIM_X * CLOUD_DIM_Y * CLOUD_DIM_Z> metaballs;
+const float cloudScale = metaballR;
+const float metaballScale = metaballR * 3.f;
Clouds cs;
void calculateMetaballs() {
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 = {
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];
+ /* m.d = 0; */
metaballs[i * CLOUD_DIM_Y * CLOUD_DIM_Z + j * CLOUD_DIM_Z + k] = m;
}
}
}
+ /* for (int z = 0; z < CLOUD_DIM_Z; z++) */
+ /* metaballs[32 * CLOUD_DIM_Y * CLOUD_DIM_Z + 32 * CLOUD_DIM_Z + z].d = 1; */
}
-vec3 sunPos = {0, 5, 5}, sunDir = {0, -1, -1};
-/* vec4 sunColor = {1,0,0.429,1}; */
-vec4 sunColor = {1,1,1,1};
+vec3 sunPos = {0, 10, 0}, sunDir = {0, -1, 0};
+size_t sunColorIdx = 0;
+std::array<vec4, 2> sunColors = {
+ vec4(1,1,1,1),
+ vec4(0.988,0.309,0.677,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
GLuint modelLoc = glGetUniformLocation(bbProg, "model");
glUniform1i(glGetUniformLocation(bbProg, "debug"), 0);
+ /* GLuint pboBuf; */
+ /* glGenBuffers(1, &pboBuf); */
+ /* glBindBuffer(GL_PIXEL_PACK_BUFFER, pboBuf); */
+
+ /* glViewport(0, 0, shadeWidth, shadeHeight); */
+
+
+ size_t i = 0;
for (auto &k : metaballs) {
+ fprintf(stderr, "\rShading cloud %lu/%lu...", i++, metaballs.size());
// place the billboard at the center of k
mat4 model = translate(mat4(1), k.pos);
value_ptr(pixel));
// Multiply the pixel value by the sunlight color.
- pixel *= sunColor;
+ pixel *= sunColors[sunColorIdx % sunColors.size()];
// Store the color into an array C[k] as the color of the billboard.
k.col = pixel;
}
+ fprintf(stderr, "\n");
saveFBO();
checkError();
+ /* glViewport(0, 0, width, height); */
}
void renderObject() {
// shaderOutput * 1 + buffer * shader alpha
glBlendFunc(GL_ONE, GL_SRC_ALPHA);
+ /* glBlendColor(1.f,1.f,1.f,1.f); */
+ /* glBlendFuncSeparate(GL_ONE, GL_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_SRC_ALPHA); */
+
glActiveTexture(GL_TEXTURE0);
glUniform1i(glGetUniformLocation(bbProg, "tex"), 0);
glm::value_ptr(k.col));
// Map the billboard texture.
- int dIdx = k.d * NQ;
+ int dIdx = k.d * (NQ - 1);
glBindTexture(GL_TEXTURE_2D, bbTexIds[dIdx]);
// Don't modulate it -- blend it
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);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
model = scale(model, vec3(0.2));
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
}
void display() {
if (needsReshading) {
// TODO: find a way to make sure there's no clipping
- view = glm::lookAt(sunPos + sunDir * vec3(20), sunPos, {0, 1, 0});
- proj = glm::ortho(1.f * aspect, -1.f * aspect, -1.f, 1.f, znear, zfar);
+ view = glm::lookAt(sunPos + sunDir * vec3(100.f), sunPos, {0, 0, 1});
+ // TODO: calculate bounds so everything is covered
+ proj = glm::ortho(2.5f, -2.5f, -2.5f, 2.5f, znear, 10000.f);
+ glUseProgram(bbProg);
setProjectionAndViewUniforms(bbProg);
glClearColor(1, 1, 1, 1);
needsReshading = curMode == render;
}
if (key == '0') {
+ needsReshading = curMode != render;
curMode = render;
needsRedisplay = true;
}
curMode = debugProbExt;
needsRedisplay = true;
}
+ if (key == 's') {
+ sunColorIdx++;
+ needsRedisplay = true;
+ needsReshading = true;
+ }
}
int prevMouseX, prevMouseY;