test/sphere.cpp

Go to the documentation of this file.

/*
 * sphere.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 * Attempt at a funky sphere.
 */

// includes --------------------------------------------------------------------
#include <iostream>
#include <fstream>

#include "glut-demo/glut-demo.h"
#include "opengl-effects/opengl-effects.h"
#include "perf/perf.h"
#include "wave-glut/frustum.h"
#include "wave-glut/texture.h"



static const float s_bounds     = 20.0;

static const int s_nRings       = 7;


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static float
randomX
(
IN float x
)
{
        return (x * rand()) / RAND_MAX;
}



static void
jitter
(
IO point3d_t& p,
IN float dx
)
throw()
{
        p.x += randomX(dx) - 0.5 * dx;
        p.y += randomX(dx) - 0.5 * dx;
        p.z += randomX(dx) - 0.5 * dx;
}



static void
checkLimit
(
IN float& x,
IN float& v
)
throw()
{
        if (x < -s_bounds) {
                x = -s_bounds;
                if (v < 0) {
                        v = -v;
                }
        } else if (x > s_bounds) {
                x = s_bounds;
                if (v > 0) {
                        v = -v;
                }
        }
}



struct ring_t {
        ring_t(void) throw() {
                        gamma = 1.01 + randomX(0.06);

                        axis.x = -1.0 + randomX(2.0);
                        axis.y = -1.0 + randomX(2.0);
                        axis.z = -1.0 + randomX(2.0);
                        normalize(axis);

                        phi = randomX(2.0 * M_PI);
                        dPhi = 5 + randomX(10);
                }

        void tick(void) throw() {
                        phi += dPhi;
                }

        // data fields
        float           gamma;
        point3d_t       axis;
        float           phi;
        float           dPhi;
};


static void
drawLightningRing
(
IN const point3d_t& center,
IN float radius,
IN const point3d_t& axis,
IN float phi,
IN const glut_color_t& color
)
throw()
{
        ASSERT(radius > 0, "bad radius: %f", radius);
        int nPoints = 16;
        ASSERT(nPoints > 1, "need at least 2!");

        // translate to center, and rotate by specified axis
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glTranslatef(center.x, center.y, center.z);
        glRotatef(phi, axis.x, axis.y, axis.z);

        float theta = 0;
        float dTheta = 2.0 * M_PI / (nPoints - 1);

        const float dJitter = 0.4;

        glDisable(GL_LIGHTING);
        glColor4fv(&color.red);
        glBegin(GL_LINE_LOOP);
        for (int i = 0; i < nPoints; ++i) {
                float mu = theta + randomX(dJitter) - 0.5 * dJitter;
                float nu = randomX(dJitter) - 0.5 * dJitter;
                point3d_t p(cos(mu) * cos(nu), sin(nu), sin(mu) * cos(nu));
                p *= radius;
                glVertex3fv(&p.x);
                theta += dTheta;
        }
        glEnd();
        glEnable(GL_LIGHTING);

        glPopMatrix();
}



struct cool_sphere_t {
        cool_sphere_t(void) throw() {
                        radius = 0.5 + randomX(0.5);

                        position.x = -10 + randomX(20);
                        position.y = -10 + randomX(20);
                        position.z = -10 + randomX(20);

                        const float vMax = 0.2;
                        velocity.x = -vMax + randomX(2.0 * vMax);
                        velocity.y = -vMax + randomX(2.0 * vMax);
                        velocity.z = -vMax + randomX(2.0 * vMax);

                        phi = randomX(2.0 * M_PI);
                        dPhi = -5 + randomX(10);

                        img_color_t c;
                        c.red =   (byte_t) (20 + randomX(235));
                        c.green = (byte_t) (20 + randomX(235));
                        c.blue =  (byte_t) (20 + randomX(235));
                        c.alpha = 128;

//                      lineColor.red   = c.red / img_color_t::eMaxComponent;
//                      lineColor.green = c.green / img_color_t::eMaxComponent;
//                      lineColor.blue  = c.blue / img_color_t::eMaxComponent;
//                      lineColor.alpha = 1.0;

                        // create density map
                        media::image_t img;
                        glut::createSphericalDensityMap(40, c, img);

                        // create texture
                        textureId = glut::createTextureFromImage(img);
                        DPRINTF("Texture ID: %d", textureId);
                }

        ~cool_sphere_t(void) throw() {
                        if (textureId) {
                                glDeleteTextures(1, &textureId);
                        }
                }

        bool isValid(void) const throw() {
                        return (radius > 0 && textureId);
                }

        void reset(void) throw() {
                        position.clear();
                        velocity.clear();
                }

        void tick(void) throw() {
                        // update with velocity
                        position += velocity;
                        phi += dPhi;

                        // check limits
                        checkLimit(position.x, velocity.x);
                        checkLimit(position.y, velocity.y);
                        checkLimit(position.z, velocity.z);

                        // update rings
                        for (int i = 0; i < s_nRings; ++i) {
                                rings[i].tick();
                        }
                }

        // data fields
        float           radius;
        float           phi;
        float           dPhi;
        point3d_t       position;
        point3d_t       velocity;
        ring_t          rings[s_nRings];
        GLuint          textureId;
};



struct sort_entry_t {
        cool_sphere_t * sphere;
        float           d2;     // distance^2 from viewer
};



static int
compareSpheres
(
IN const void * p1,
IN const void * p2
)
throw()
{
        const sort_entry_t * se1 = (const sort_entry_t *) p1;
        const sort_entry_t * se2 = (const sort_entry_t *) p2;
        ASSERT(se1 && se2, "null");

        if (se1->d2 < se2->d2)
                return -1;      // first sphere is closer
        if (se1->d2 > se2->d2)
                return +1;      // first sphere is farther
        return 0;       // equidistant!
}



static void
drawCoolSphere
(
IN const cool_sphere_t& sphere,
IN const glut::render_context_t& rc,
IN glut::RenderQueue * rq
)
throw()
{
        ASSERT(sphere.isValid(), "sphere is invalid?");
        ASSERT(rq, "null");

        // first, render a standard sphere at position
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glTranslatef(sphere.position.x, sphere.position.y, sphere.position.z);
        glRotatef(sphere.phi, 0, 1, 0);
        glutSolidSphere(sphere.radius, 16, 16);
        glPopMatrix();

        // now draw lightning rings
        for (int i = 0; i < s_nRings; ++i) {
                const ring_t& r = sphere.rings[i];
                drawLightningRing(sphere.position, r.gamma * sphere.radius,
                    r.axis, r.phi, glut_color_t(1, 1, 1, 1));
        }

        // ray from viewer to center of sphere
        point3d_t to = sphere.position - rc.viewer.getPosition();
        float z2 = dotProduct(to, to);
        if (z2 < 1.0e-4)
                return;         // too close!
        float z = sqrt(z2);
        to = (1.0 / z) * to;

        // we can choose an arbitrary "up" direction
        point3d_t up = rc.viewer.getUp();
        point3d_t right = crossProduct(to, up);
        normalize(right);

        // get a proper "up" direction now
        point3d_t realUp = -crossProduct(to, right);
        normalize(realUp);

        // queue request
        glut::poly_request_t * pr = rq->grabRequestSlot();
        if (!pr) {
                DPRINTF("No available request slots?");
                return;
        }

        matrix4_t T;
        glut::getModelViewMatrix(T);

        // regardless of how far away (or how close) the viewer is, we want the
        // "glow" effect to appear to be a constant radius
        // we perform some simple geometry calculations so that, even though the
        //      glow plane is closer to the viewer and therefore more sensitive
        //      to perspective effects, the overall glow always looks like it is
        //      an enclosing sphere of constant radius
        float beta = 1.25;      // desired radius scaling
        float gamma = 1.1;      // distance from sphere center to glow plane
        float alpha = beta * (z - gamma * sphere.radius) / z;
//      DPRINTF("z=%f  beta=%f  gamma=%f  -->  alpha=%f", z, beta, gamma, alpha);

        // midpoint of new polygon
        float scale = alpha * sphere.radius;    // half width/height of glow plane
        point3d_t mid = sphere.position - gamma * sphere.radius * to;

        // set up
        pr->nVertices = 4;
        pr->textureId = sphere.textureId;
        pr->normal = -to;

        pr->vertex[0] = T * (mid + scale * (-up + right));
        pr->u[0] = 0;
        pr->v[0] = 0;

        pr->vertex[1] = T * (mid + scale * ( up + right));
        pr->u[1] = 0;
        pr->v[1] = 1;

        pr->vertex[2] = T * (mid + scale * ( up - right));
        pr->u[2] = 1;
        pr->v[2] = 1;

        pr->vertex[3] = T * (mid + scale * (-up - right));
        pr->u[3] = 1;
        pr->v[3] = 0;
}



class Drawer : public glut::DemoHost {
public:
        Drawer(IN int nSpheres) throw() : m_nSpheres(nSpheres) { }
        ~Drawer(void) throw() { }

        // glut::Host class interface methods ----------------------------------
        void onInit(void) {
                        m_spheres.reserve(m_nSpheres);
                        m_sorting.reserve(m_nSpheres);
                        for (int i = 0; i < m_nSpheres; ++i) {
                                smart_ptr<cool_sphere_t> sphere =
                                    new cool_sphere_t;
                                ASSERT(sphere, "out of memory");

                                // sphere->reset();
                                m_spheres.push_back(sphere);

                                // push an empty sort entry
                                sort_entry_t se;
                                m_sorting.push_back(se);
                        }
                }

        void display3D(IN const glut::render_context_t& rc,
                                IN glut::RenderQueue * rq) {
                        ASSERT(rq, "null");

                        ASSERT(m_nSpheres == (int) m_spheres.size(),
                            "size mismatch!");
                        ASSERT(m_nSpheres == (int) m_sorting.size(),
                            "size mismatch!");

                        // get view frustum
                        frustum_t f;
                        glut::getViewFrustum(rc.camera, rc.viewer, f);

                        // first pass: put all in array for depth sorting!
                        int nVisible = 0;
                        const point3d_t& viewPosition = rc.viewer.getPosition();
                        for (int i = 0; i < m_nSpheres; ++i) {
                                cool_sphere_t * sphere = m_spheres[i];
                                ASSERT(sphere, "null sphere in array");
                                sphere->tick();

                                rect3d_t r;
                                r.getBoundingRectForSphere(sphere->position,
                                    sphere->radius);
                                if (!(eContains_HitMask & f.containsRect(r))) {
                                        // this sphere isn't in the view
                                        // frustum!
                                        continue;
                                }

                                sort_entry_t& se = m_sorting[nVisible];
                                point3d_t diff = sphere->position - viewPosition;
                                se.sphere = sphere;
                                se.d2 = dotProduct(diff, diff);
                                nVisible++;
                        }
                        ASSERT(nVisible <= m_nSpheres, "mismatch");

                        // sort the array
                        qsort(&m_sorting[0], nVisible,
                            sizeof(sort_entry_t), compareSpheres);

                        // now walk from closest to farthest and draw
                        for (int i = 0; i < nVisible; ++i) {
                                sort_entry_t& se = m_sorting[i];
                                ASSERT(se.sphere, "null");

                                drawCoolSphere(*se.sphere, rc, rq);
                        }
                }

private:
        // private typedefs ----------------------------------------------------
        typedef std::vector<smart_ptr<cool_sphere_t> > vec_sphere_t;
        typedef std::vector<sort_entry_t> vec_sort_t;

        // private member data -------------------------------------------------
        int                     m_nSpheres;
        vec_sphere_t            m_spheres;
        vec_sort_t              m_sorting;
};



////////////////////////////////////////////////////////////////////////////////
//
//      entry point
//
////////////////////////////////////////////////////////////////////////////////

int
main
(
IN int argc,
IN const char * argv[]
)
{
        ASSERT(2 == argc, "Usage: opengl-effects-sphere <nSpheres>\n");
        int nSpheres = atoi(argv[1]);
        ASSERT(nSpheres > 0, "Bad sphere count: %d", nSpheres);

        try {
                // title
                std::string title = "OpenGL Effects Test -- Spheres";

                // main loop
                smart_ptr<glut::DemoHost> host = new Drawer(nSpheres);
                ASSERT(host, "out of memory");
                glut::startDemo(argc, argv, title.c_str(), host);

        } catch (std::exception& e) {
                DPRINTF("Exception: %s", e.what());
        }

        // only reach here on error
        return -1;
}