map-drawer.cpp

Go to the documentation of this file.

/*
 * map-drawer.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.
 *
 *
 * Implementation of a aesop terminal.  Manages display in particular.
 */

// includes --------------------------------------------------------------------
#include "map-kdtree.h"                 // always list our own header first!

#include "glut/frustum.h"
#include "perf/perf.h"



namespace aesop {


//
//      static helper methods
//

static void
drawObject
(
IN glut::Renderable * model,
IN const glut::render_context_t& rc,
IN glut::RenderQueue * rq,
IN void * context
)
{
        ASSERT(model, "null");
        map_draw_stats_t * stats = (map_draw_stats_t *) context;
        ASSERT(stats, "null context");
        ASSERT(rq, "null");

//      DPRINTF("Drawing instance of type '%s'", instance->getTypeId());
//      instance->getPlacement().position.dump("  at");

        // update model view to correspond to placement
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glut::setPlacement(rc.placement);

        // increment count, and render
        stats->nObjects++;
        model->render(rc, rq);

        // clean up
        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();
}



static void
setLights
(
void
)
{
        // basic enabling
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
        glShadeModel(GL_SMOOTH);

        // direction
        float lightDir[] = { 1, 0.5, -0.2, 0 };
        glLightfv(GL_LIGHT0, GL_POSITION, lightDir);

        // ambient white light
        float lightAmbient[] = { 0.4, 0.4, 0.4, 1.0 };
        glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lightAmbient);

        // set light parameters
        float lightOn[] = { 1, 1, 1, 1 };
        float lightOff[] = { 0, 0, 0, 1 };

        glLightfv(GL_LIGHT0, GL_DIFFUSE, lightOn);
        glLightfv(GL_LIGHT0, GL_AMBIENT, lightOff);
        glLightfv(GL_LIGHT0, GL_SPECULAR, lightOn);
}



//
//      public API
//

void
drawMap
(
IN MapKdTree * mapKdTree,
IN const glut::render_context_t& rc,
IN glut::RenderQueue * rq,
OUT map_draw_stats_t& stats
)
{
        perf::Timer timer("drawMap");
        ASSERT(mapKdTree, "null");
        ASSERT(rq, "null");
        stats.clear();

        // enable global glut capabilities
        glEnable(GL_DEPTH_TEST);
        glEnable(GL_CULL_FACE);
        glDisable(GL_BLEND);
//      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

        // polygon mode
        int wire = 0;
        if (wire) {
                glPolygonMode(GL_FRONT, GL_LINE);
        } else {
                glPolygonMode(GL_FRONT, GL_FILL);
        }

        // clear buffers
        {
//              perf::Timer timer("map-draw:clear"); - on the order of 0.13ms per buffer
                if (wire) {
                        glClearColor(0.0, 0.0, 0.9, 1.0);
                        glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
                } else {
                        glClear(GL_DEPTH_BUFFER_BIT);
                }
        }

        // ambient lighting
        // TODO: map should specify this!
        setLights();

        glColor4f(1.0, 1.0, 1.0, 1.0);

        // set up camera and projection matrices
        glut::setOpenGLProjection(rc.camera);
        glut::setOpenGLViewer(rc.viewer);

        // okay, draw everything in regular leaf zones
        mapKdTree->walkFrontToBack(rc, rq, drawObject, &stats);

        // now handle transparencies etc
        glEnable(GL_BLEND);
        glEnable(GL_TEXTURE_2D);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        // reset modelview matrix (queued polygons should be transformed
        // already)
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glLoadIdentity();
        {
                perf::Timer timer("map-drawer:transparent");
                while (glut::poly_request_t * pr = rq->popRequest()) {
                        if (pr->nVertices < 3 || pr->textureId < 1)
                                continue;       // skip these

                        // bind texture and normal
                        glBindTexture(GL_TEXTURE_2D, pr->textureId);
                        glNormal3fv((GLfloat *) &pr->normal.x);

                        // send vertices
                        glBegin(GL_POLYGON);
                        for (int i = 0; i < pr->nVertices; ++i) {
                                glTexCoord2f(pr->u[i], pr->v[i]);
                                glVertex3fv((GLfloat *) &pr->vertex[i].x);
                        }
                        glEnd();
                }
        }
        glPopMatrix();

        // disable everything we enabled
        glDisable(GL_BLEND);
        glDisable(GL_TEXTURE_2D);
        glDisable(GL_CULL_FACE);
        glDisable(GL_LIGHT0);
//      glDisable(GL_LIGHT1);
        glDisable(GL_LIGHTING);
        glDisable(GL_DEPTH_TEST);

        // quickly draw frustum
//      frustum_t f;
//      glut::getViewFrustum(rc.camera, rc.viewer, f);
//      glut::drawFrustumEdges(f, glut_color_t(.9, .9, .9));
}


};              // aesop namespace