model-draw.cpp

Go to the documentation of this file.

/*
 * model-draw.cpp
 *
 * Copyright (C) 2008-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.
 *
 * Routines to draw GLUT 3D models.
 */

// includes --------------------------------------------------------------------
#include "glut-model.h"         // always include our own header first

#include "common/wave_ex.h"
#include "geometry/matrix_4.h"
#include "perf/perf.h"
#include "wave-glut/wave-glut.h"


namespace glut {



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

static void
renderColorPolygon
(
IN const polygon_t& p
)
throw()
{
        float material[] = {
            p.material->color.red,
            p.material->color.green,
            p.material->color.blue,
            1.0 };

//      DPRINTF("matl: [%f %f %f %f]",
//          material[0], material[1], material[2], material[3]);

        glColor4f(material[0], material[1], material[2], material[3]);
//      glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, material);

        glNormal3fv(&p.normal.x);

        glDrawElements(GL_POLYGON, p.nVertices, GL_UNSIGNED_INT, p.indices);
}



static void
queuePolygon
(
IN const point3d_t * vertex_array,
IN const polygon_t& p,
IO poly_request_t& pr
)
throw()
{
        ASSERT(vertex_array, "null");

        if (p.nVertices > poly_request_t::eMaxVertices) {
                DPRINTF("Too many vertices for queuing");
                return;
        }

        // stash high-level details
        pr.nVertices = p.nVertices;
        pr.textureId = p.material->texture_id;
        pr.normal = p.normal;

        // transform all points
        matrix4_t M;
        glGetFloatv(GL_MODELVIEW_MATRIX, M.m);
        M.transpose();
        const int * pi = p.indices;
        for (int i = 0; i < p.nVertices; ++i, ++pi) {
                const point3d_t& pModel = vertex_array[*pi];
                pr.u[i] = p.u[i];
                pr.v[i] = p.v[i];
                pr.vertex[i] = M * pModel;
        }
}



static void
renderTexturePolygon
(
IN const point3d_t * vertex_array,
IN const polygon_t& p
)
throw()
{
        ASSERT(vertex_array, "null");

        glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, p.material->texture_id);
        glNormal3fv(&p.normal.x);

        //DPRINTF("  Drawing polygon");

        // loop through all vertices
        const int *pi = p.indices;
        const float * pu = p.u;
        const float * pv = p.v;
        glBegin(GL_POLYGON);
        for (int i = 0; i < p.nVertices; ++i, ++pu, ++pv, ++pi) {
                const point3d_t& vtx = vertex_array[*pi];
                glTexCoord2f(*pu, *pv);
                glVertex3f(vtx.x, vtx.y, vtx.z);

        //      DPRINTF("    Vertex: (%f, %f, %f) - (%f, %f)",
        //          vtx.x, vtx.y, vtx.z, *pu, *pv);
        }
        glEnd();
        glDisable(GL_TEXTURE_2D);
}



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

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

//      position.dump("drawing here");

        // set up all vertices
        glEnable(GL_VERTEX_ARRAY);
        glVertexPointer(3, GL_FLOAT, 0, vertices);

//      DPRINTF("Drawing object");

        // render all polygons
        for (int i = 0; i < nPolygons; ++i) {
                const polygon_t& p = polygons[i];
                ASSERT(p.material, "null");     // should always have material!

                if (p.material->texture_id) {
                        if (p.material->isTransparent) {
                                poly_request_t * pr = rq->grabRequestSlot();
                                if (pr) {
                                        queuePolygon(vertices, p, *pr);
                                } else {
                                //      DPRINTF("No more request slots!");
                                }
                        } else {
                                renderTexturePolygon(vertices, p);
                        }
                } else {
                        renderColorPolygon(p);
                }
        }

        // clean up
        glDisable(GL_VERTEX_ARRAY);
}



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

        // for now, just draw first model!
        if (nEntries < 1) {
                return;         // empty!
        }

        entries[0].model.render(rc, rq);
}



};      // glut namespace