tex-sphere.cpp

Go to the documentation of this file.

/*
 * tex-sphere.cpp
 *
 * Copyright (C) 2011  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.
 *
 *
 * Texture-mapped sphere code
 *
 * This code adapted from the excellent tutorial here:
 *      http://www.swiftless.com/tutorials/opengl/sphere.html
 */

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

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


#include <GL/glut.h>
#include <stdio.h>
#include <math.h>


namespace glut {


// sphere coordinates: lists the xyz coordinate on the surface of the (unit)
//      sphere, plus the texture uv coordinates there.
struct sphere_vertex_t {
        // data fields
        float   x;
        float   y;
        float   z;
        float   u;
        float   v;
};


// how finely do we slice the sphere?  Want something that divides 90 evenly
static const int s_degreesPerSlice = 9;

static const float s_radiansPerDegree = M_PI / 180.0;

// we have a map for a quarter-rotation (90 degrees), with 4 points per
// basically a map of the northern hemisphere, which is easy to flip for the
//      south
static const int s_vertexCount =
                4 * (90 / s_degreesPerSlice) * (360 / s_degreesPerSlice);



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

static const sphere_vertex_t *
getSphereVertices
(
void
)
{
        // this is the static map that describes how to render (and map) a
        //      (hemi)sphere
        static sphere_vertex_t s_vertices[s_vertexCount];

        // caller is asking for the struct that maps from sphere xyz coordinates
        //      to texture UV coordinates.  We calculate this once, and return
        //      the cached (static) result from then on.
        static bool s_haveVertices = false;
        if (s_haveVertices) {
                return s_vertices;
        }

        perf::Timer timer("construct-sphere-map");

        // first time this has been called: construct vertex array
        // note that we create this array for a sphere of radius = 1, with no
        //      translations.  Callers can scale and translate as needed
        sphere_vertex_t * psv = s_vertices;
        const float inv360 = 1.0 / 360.0;
        const float inv180 = 1.0 / 180.0;
//      const float inv360 = 1.0 / 720.0;
//      const float inv180 = 1.0 / 360.0;
        float sinBplus = 0.0;   // sin(0)
        float cosBplus = 1.0;   // cos(0)

        // loop through northern latitudes (90 degrees only)
        for (int b = 0; b < 90; b += s_degreesPerSlice) {
                float sinB = sinBplus;
                float cosB = cosBplus;

                //DPRINTF("b=%02d degrees, sinB=%5.3f  cosB=%5.3f", b, sinB, cosB);
                sinBplus = sin((b + s_degreesPerSlice) * s_radiansPerDegree);
                cosBplus = cos((b + s_degreesPerSlice) * s_radiansPerDegree);

                float sinAplus = 0.0;   // sin(0)
                float cosAplus = 1.0;   // cos(0)

                // loop through longitudes (full 360)
                for (int a = 0; a < 360; a += s_degreesPerSlice) {

                        float sinA = sinAplus;
                        float cosA = cosAplus;

                        sinAplus = sin((a + s_degreesPerSlice) * s_radiansPerDegree);
                        cosAplus = cos((a + s_degreesPerSlice) * s_radiansPerDegree);

                        // calculate the sphere at this point, plus 3 adjacent
                        //      points (one slice advanced in each direction)
                        psv->x = sinA * sinB;
                        psv->y = cosA * sinB;
                        psv->z = cosB;
                        psv->u = a * inv360;
                        psv->v = b * inv180;
        //              DPRINTF("a=%02d,b=%02d  u=%5.3f,v=%5.3f", a, b, psv->u, psv->v);
                        ++psv;

                        psv->x = sinA * sinBplus;
                        psv->y = cosA * sinBplus;
                        psv->z = cosBplus;
                        psv->u = a * inv360;
                        psv->v = (b + s_degreesPerSlice) * inv180;
                        ++psv;

                        psv->x = sinAplus * sinB;
                        psv->y = cosAplus * sinB;
                        psv->z = cosB;
                        psv->u = (a + s_degreesPerSlice) * inv360;
                        psv->v = b * inv180;
                        ++psv;

                        psv->x = sinAplus * sinBplus;
                        psv->y = cosAplus * sinBplus;
                        psv->z = cosBplus;
                        psv->u = (a + s_degreesPerSlice) * inv360;
                        psv->v = (b + s_degreesPerSlice) * inv180;
                        ++psv;
                }
        }

        // verify we counted correctly
        ASSERT(psv - s_vertices == s_vertexCount,
           "Incorrect vertex count?");

        // all done!
        s_haveVertices = true;
        return s_vertices;
}



class TexSphere : public Renderable {
public:
        // constructor, destructor ---------------------------------------------
        ~TexSphere(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN const tex_sphere_t& ts);

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


void
TexSphere::initialize
(
IN const tex_sphere_t& ts
)
{
        ASSERT(ts.radius > 0, "bad sphere radius: %f", ts.radius);
        ASSERT(ts.textureId > -1, "bad texture id: %d", ts.textureId);

        m_radius = ts.radius;
        m_textureId = ts.textureId;
}



void
TexSphere::render
(
IN const render_context_t& rc,
IN RenderQueue * rq
)
{
        perf::Timer timer("TexSphere::render");
        ASSERT(m_radius > 0, "bad radius");

        // set up texture
        glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, m_textureId);

//      glDisable(GL_CULL_FACE);

        // update modelview matrix for radius
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
//      glRotatef(90, 1, 0, 0);
        glScalef(m_radius, m_radius, m_radius);

        const sphere_vertex_t * v0 = getSphereVertices();

        // render the top and bottom hemispheres as triangle strips
        glBegin(GL_TRIANGLE_STRIP);
        const sphere_vertex_t * psv = v0;
        for (int b = 0; b < s_vertexCount; ++b, ++psv) {
                glTexCoord2f(psv->u, 1.0 - psv->v);
                glVertex3f(psv->x, psv->z, psv->y);
        }
        glEnd();

        // reset for second hemisphere
        glBegin(GL_TRIANGLE_STRIP);
        psv = v0;
        for (int b = 0; b < s_vertexCount; ++b, ++psv) {
                glTexCoord2f(-psv->u, psv->v);
                glVertex3f(-psv->x, -psv->z, psv->y);
        }    
        glEnd();

        // clean up OpenGL context
        glPopMatrix();
        glDisable(GL_TEXTURE_2D);
}



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



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

smart_ptr<Renderable>
createMappedSphere
(
IN const tex_sphere_t& ts
)
{
        smart_ptr<TexSphere> local = new TexSphere;
        ASSERT(local, "out of memory");

        local->initialize(ts);

        return local;
}



};      // glut namespace