sphere.cpp

Go to the documentation of this file.

/*
 * sphere.cpp
 *
 * Copyright (C) 2010  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * A glowing colored sphere with lightning.  Oooohhh.
 */

// includes --------------------------------------------------------------------
#include "opengl-effects.h"             // always include our own header first!

#include "perf/perf.h"
#include "wave-glut/texture.h"


namespace glut {



////////////////////////////////////////////////////////////////////////////////
//
//      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;
}



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 = 0.2 * (5 + randomX(10));
                }

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

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



static void
drawLightningRing
(
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 = 32;
        ASSERT(nPoints > 1, "need at least 2!");

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

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

        const float dJitter = 0.3;

        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();
}



class Sphere : public Renderable {
public:
        // constructor, destructor ---------------------------------------------
        ~Sphere(void) throw();

        // public class methods ------------------------------------------------
        void initialize(IN const sphere_init_t& si);

        // glut::Renderable class interface methods ----------------------------
        void render(IN const render_context_t& rc,
                                IN RenderQueue * rq);
        rect3d_t getBoundingBox(void) const throw();

private:
        // private typedefs ----------------------------------------------------
        // private helper methods ----------------------------------------------
        // private member data -------------------------------------------------
        float           m_radius;
        float           m_phi;
        float           m_dPhi;
        int             m_nRings;
        ring_t          m_rings[sphere_init_t::eMaxRings];
        GLuint          m_textureId;
};



Sphere::~Sphere(void)
throw()
{
        if (m_textureId) {
                glDeleteTextures(1, &m_textureId);
        }
}



void
Sphere::initialize
(
IN const sphere_init_t& si
)
{
        ASSERT(si.isValid(), "invalid sphere initialization data");

        // copy from input
        m_radius = si.radius;
        m_nRings = si.nRings;

        // set random parameters
        m_phi = randomX(2.0 * M_PI);
        m_dPhi = 5 * (5 + randomX(10));
        if (randomX(10) < 5) {
                m_dPhi = -m_dPhi;
        }

        // create density map
        media::image_t img;
        //createSphericalDensityMap(40, si.color, img);
        createCircularDensityMap(64, si.color, img);

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



void
Sphere::render
(
IN const render_context_t& rc,
IN RenderQueue * rq
)
{
        perf::Timer timer("Sphere::render");
        ASSERT(rq, "null");

        m_phi += m_dPhi;

        // first, render a standard sphere at position
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glRotatef(m_phi, 0, 1, 0);
        glutSolidSphere(m_radius, 12, 12);
        glPopMatrix();

        // now draw lightning rings
        for (int i = 0; i < m_nRings; ++i) {
                ring_t& r = m_rings[i];
                r.tick();
                drawLightningRing(r.gamma * m_radius,
                    r.axis, r.phi, glut_color_t(1, 1, 1, 1));
        }

        // ray from viewer to center of sphere
        point3d_t to = rc.placement.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 bogusUp = rc.viewer.getUp();
        point3d_t right = crossProduct(to, bogusUp);
        normalize(right);

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

        // 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.17;      // desired radius scaling
        float gamma = 1.1;      // distance from sphere center to glow plane
        float alpha = beta * (z - gamma * m_radius) / z;
//      DPRINTF("z=%f  beta=%f  gamma=%f  -->  alpha=%f", z, beta, gamma, alpha);

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

        // set up
        pr->nVertices = 4;
        pr->textureId = m_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;
}



rect3d_t
Sphere::getBoundingBox
(
void
)
const
throw()
{
        rect3d_t r;
        r.clear();
        r.inflate(m_radius);
        return r;
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<Renderable>
createCoolSphere
(
IN const sphere_init_t& si
)
{
        ASSERT(si.isValid(), "invalid sphere initializer");

        smart_ptr<Sphere> local = new Sphere;
        ASSERT(local, "out of memory");

        local->initialize(si);

        return local;
}



};      // end of glut namespace