[laserbrain_demo] / src / blob_exhibit.cc

#include "blob_exhibit.h"
#include "blobs/metasurf.h"
#include "app.h"
#include <imago2.h>

struct Metaball {
        Vec3 pos;
        float energy;
        Vec3 path_scale, path_offset;
        float phase_offset, speed;
};
#define NUM_MBALLS      8

static Metaball def_mball_data[] = {
        {Vec3(0, 0, 0), 2.18038,  Vec3(1.09157, 1.69766, 1),   Vec3(0.622818, 0.905624, 0), 1.24125, 0.835223},
        {Vec3(0, 0, 0), 2.03646,  Vec3(0.916662, 1.2161, 1),   Vec3(0.118734, 0.283516, 0), 2.29201, 1.0134},
        {Vec3(0, 0, 0), 2.40446,  Vec3(1.87429, 1.57595, 1),   Vec3(0.298566, -0.788474, 0), 3.8137, 0.516301},
        {Vec3(0, 0, 0), 0.985774, Vec3(0.705847, 0.735019, 1), Vec3(0.669189, -0.217922, 0), 0.815497, 0.608809},
        {Vec3(0, 0, 0), 2.49785,  Vec3(0.827385, 1.75867, 1),  Vec3(0.0284513, 0.247808, 0), 1.86002, 1.13755},
        {Vec3(0, 0, 0), 1.54857,  Vec3(1.24037, 0.938775, 1),  Vec3(1.04011, 0.596987, 0), 3.30964, 1.26991},
        {Vec3(0, 0, 0), 1.30046,  Vec3(1.83729, 1.02869, 1),   Vec3(-0.476708, 0.676994, 0), 5.77441, 0.569755},
        {Vec3(0, 0, 0), 2.39865,  Vec3(1.28899, 0.788321, 1),  Vec3(-0.910677, 0.359099, 0), 5.5935, 0.848893}
};

struct BlobPriv {
        metasurface *msurf;
        Metaball mballs[NUM_MBALLS];
        Texture *tex;
};

BlobExhibit::BlobExhibit()
{
        priv = new BlobPriv;
        for(int i=0; i<NUM_MBALLS; i++) {
                priv->mballs[i] = def_mball_data[i];
        }
}

BlobExhibit::~BlobExhibit()
{
        destroy();
        delete priv;
}

bool BlobExhibit::init()
{
        if(!(priv->msurf = msurf_create())) {
                return false;
        }
        msurf_set_threshold(priv->msurf, 8);
        msurf_set_inside(priv->msurf, MSURF_GREATER);
        msurf_set_bounds(priv->msurf, -3.5, -3.5, -3.5, 3.5, 3.5, 3.5);
        msurf_enable(priv->msurf, MSURF_NORMALIZE);

        priv->tex = texman.get_texture("data/sphmap.jpg");

        return true;
}

void BlobExhibit::destroy()
{
        if(priv->msurf) {
                msurf_free(priv->msurf);
                priv->msurf = 0;
        }
}

void BlobExhibit::update(float dt)
{
        double sec = time_msec / 1000.0;

        float xmin, xmax, ymin, ymax, zmin, zmax;
        int xres, yres, zres;

        msurf_get_bounds(priv->msurf, &xmin, &ymin, &zmin, &xmax, &ymax, &zmax);
        msurf_get_resolution(priv->msurf, &xres, &yres, &zres);

        float xstep = (xmax - xmin) / xres;
        float ystep = (ymax - ymin) / yres;
        float zstep = (zmax - zmin) / zres;

        for(int i=0; i<NUM_MBALLS; i++) {
                float t = fmod(sec * priv->mballs[i].speed + priv->mballs[i].phase_offset, M_PI * 2.0);
                priv->mballs[i].pos.x = cos(t) * priv->mballs[i].path_scale.x + priv->mballs[i].path_offset.x;
                priv->mballs[i].pos.y = sin(t) * priv->mballs[i].path_scale.y + priv->mballs[i].path_offset.y;
                priv->mballs[i].pos.z = -cos(t) * priv->mballs[i].path_scale.z + priv->mballs[i].path_offset.z;
        }

        if(!msurf_voxels(priv->msurf)) {
                return;
        }

        float max_energy = 0.0f;

#pragma omp parallel for
        for(int i=0; i<zres; i++) {
                float z = zmin + i * zstep;
                float *voxptr = msurf_slice(priv->msurf, i);

                for(int j=0; j<yres; j++) {
                        float y = ymin + j * ystep;

                        for(int k=0; k<xres; k++) {
                                float x = xmin + k * xstep;

                                float sum = 0.0f;
                                for(int n=0; n<NUM_MBALLS; n++) {
                                        float dx = x - priv->mballs[n].pos.x;
                                        float dy = y - priv->mballs[n].pos.y;
                                        float dz = z - priv->mballs[n].pos.z;
                                        float dsq = dx * dx + dy * dy + dz * dz;

                                        sum += priv->mballs[n].energy / dsq;
                                }
                                *voxptr++ = sum;
                                if(sum > max_energy) max_energy = sum;
                        }
                }
        }

        msurf_polygonize(priv->msurf);
}

void BlobExhibit::draw() const
{
        glPushAttrib(GL_ENABLE_BIT);

        glUseProgram(0);

        glDisable(GL_LIGHTING);
        glEnable(GL_TEXTURE_2D);
        glEnable(GL_NORMALIZE);
        priv->tex->bind();

        glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
        glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
        glEnable(GL_TEXTURE_GEN_S);
        glEnable(GL_TEXTURE_GEN_T);

        glMatrixMode(GL_TEXTURE);
        glLoadIdentity();
        glScalef(1, -1, 1);

        int nverts = msurf_vertex_count(priv->msurf);
        float *varr = msurf_vertices(priv->msurf);
        float *narr = msurf_normals(priv->msurf);

        glColor3f(1, 1, 1);

        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glEnableClientState(GL_VERTEX_ARRAY);
        glEnableClientState(GL_NORMAL_ARRAY);
        glVertexPointer(3, GL_FLOAT, 0, varr);
        glNormalPointer(GL_FLOAT, 0, narr);

        glDrawArrays(GL_TRIANGLES, 0, nverts);

        glDisableClientState(GL_VERTEX_ARRAY);
        glDisableClientState(GL_NORMAL_ARRAY);

        /*
        glDisable(GL_TEXTURE_2D);
        glDisable(GL_LIGHTING);

        varr = msurf_vertices(priv->msurf);
        narr = msurf_normals(priv->msurf);

        glBegin(GL_LINES);
        glColor3f(0, 1, 0);

        float nscale = 0.2;
        for(int i=0; i<nverts; i++) {
                glVertex3f(varr[0], varr[1], varr[2]);
                glVertex3f(varr[0] + narr[0] * nscale, varr[1] + narr[1] * nscale, varr[2] + narr[2] * nscale);
                varr += 3;
                narr += 3;
        }
        glEnd();
        */

        glLoadIdentity();
        glMatrixMode(GL_MODELVIEW);

        glPopAttrib();
}