glut-model.h

Go to the documentation of this file.

/*
 * glut-model.h
 *
 * Copyright (C) 2008,2009  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.
 *
 * Basic 3D models built on glut
 */

#ifndef WAVE_GLUT_GLUT_MODEL_H__
#define WAVE_GLUT_GLUT_MODEL_H__

// includes --------------------------------------------------------------------
#include "common/common.h"

#include "geometry/geometry_3d.h"
#include "threadsafe/smart_ptr.h"
#include "wave-glut/camera.h"
#include "wave-glut/renderable.h"


namespace glut {


////////////////////////////////////////////////////////////////////////////////
///
/// \ingroup models
/// \defgroup glut_model Glut 3D Model Library
///
/// A homegrown 3D model format.  This is a simple reference implementation of
/// OpenGL-enabled 3D models.
///
////////////////////////////////////////////////////////////////////////////////

/*@{*/


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

/// material (used for rendering polygons)
struct material_t {
        // constructor, manipulators
        material_t(void) throw() : texture_id(0) { this->clear(); }
        ~material_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        isTransparent = false;
                        if (texture_id) {
                                glDeleteTextures(1, (GLuint *) &texture_id);
                                texture_id = 0;
                        }
                }

        // data fields
        int             texture_id;     ///< openGL texture if nonzero
        bool            isTransparent;  ///< does texture contain non-1 alpha?
        glut_color_t    color;          ///< use color if no texture ID
};



/// Clients of the parsing APIs must implement this interface themselves.
/// Typically, this is an object that can load materials as needed, and keep
/// them in a map.  Needs to be threadsafe!
class MaterialRegistry {
public:
        // virtual destructor --------------------------------------------------
        virtual ~MaterialRegistry(void) throw();

        // glut::MaterialRegistry class interface methods ----------------------
        virtual smart_ptr<material_t> getMaterial(IN const char * id) = 0;
};



/// polygon object.  There is a single normal for the entire polygon,
/// and an arbitrary number of points (vertices)
struct polygon_t {
        // constructor, manipulators
        polygon_t(void) throw() {
                                nVertices = 0;
                                indices = NULL;
                                u = v = NULL;
                        }
        ~polygon_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        nVertices = 0;
                        if (indices) {
                                delete[] indices;
                                indices = NULL;
                        }
                        if (u) {
                                delete[] u;
                                u = NULL;
                        }
                        if (v) {
                                delete[] v;
                                v = NULL;
                        }
                        material = NULL;
                }

        // data fields
        int             nVertices;      ///< number of vertices in the polygon
        int *           indices;        ///< array of vertex indices
        float *         u;              ///< array of vertex texture u-coords
        float *         v;              ///< array of vertex texture v-coords
        smart_ptr<material_t> material; ///< material (texture etc)
        point3d_t       normal;         ///< polygon normal
};



/// model object.  This contains all of the vertices in a single flat
/// list, and then a list of polygons that use the vertices.
class model_t : public Renderable {
public:
        // constructor, manipulators
        model_t(void) throw() : nVertices(0), vertices(NULL),
                                nPolygons(0), polygons(NULL) { }
        ~model_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        nVertices = nPolygons = 0;
                        if (vertices) {
                                delete[] vertices;
                                vertices = NULL;
                        }
                        if (polygons) {
                                delete[] polygons;
                                polygons = NULL;
                        }
                        boundingBox.clear();
                }

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

        // data fields
        int             nVertices;      ///< number of vertices in model
        point3d_t *     vertices;       ///< array of vertices
        int             nPolygons;      ///< number of polygons in model
        polygon_t *     polygons;       ///< array of polygons
        rect3d_t        boundingBox;    ///< bounding box
};



/// level-of-detail entry.  contains a model and distance information
struct lod_entry_t {
        void clear(void) throw() {
                        distance = 0.0;
                        model.clear();
                }

        // data fields
        model_t         model;          ///< model to use for this entry
        float           distance;       ///< distance at which to use model
};



/// level-of-detail model.  Contains multiple level-of-detail entries (models)
struct lod_model_t : public Renderable {
public:
        // constructor, manipulators
        lod_model_t(void) throw() : nEntries(0), entries(NULL) { }
        ~lod_model_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        nEntries = 0;
                        if (entries) {
                                delete[] entries;
                                entries = NULL;
                        }
                        boundingBox.clear();
                }

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

        // data fields
        int             nEntries;       ///< number of level-of-detail entries
        lod_entry_t *   entries;        ///< array of level-of-detail entries
        rect3d_t        boundingBox;    ///< bounding box
};



////////////////////////////////////////////////////////////////////////////////
//
//      parsing (loading) methods
//
////////////////////////////////////////////////////////////////////////////////

void parseColor(IO std::istream& stream,
                                OUT img_color_t& color);

void parseMaterial(IO std::istream& stream,
                                IN const char * parentDir,
                                OUT material_t& material);

void parsePolygon(IN MaterialRegistry * mreg,
                                IO std::istream& stream,
                                OUT polygon_t& polygon);

void parseModel(IN MaterialRegistry * mreg,
                                IO std::istream& stream,
                                OUT model_t& model);

void parseLodEntry(IN MaterialRegistry * mreg,
                                IO std::istream& stream,
                                OUT lod_entry_t& entry);

void parseLodModel(IN MaterialRegistry * mreg,
                                IO std::istream& stream,
                                OUT lod_model_t& lod_model);


/// get a simple implementation of a material registry.  Intended for testing
/// only.  Caller must provide root of material directory tree.
smart_ptr<MaterialRegistry> getSimpleRegistry(IN const char * materialDir);


/// load a model from a Wavepacket Glut Model file (.wgm extension, normally)
smart_ptr<Renderable> loadModel(IN const char * filename,
                                IN MaterialRegistry * reg);


////////////////////////////////////////////////////////////////////////////////
//
//      writing methods
//
////////////////////////////////////////////////////////////////////////////////

/// assumes you have already written the key name, this will write
///   the opening and closing brackets
void writeModelToStream(IO std::ostream& stream,
                                IN const model_t& model);



};      // glut namespace


#endif  // WAVE_GLUT_GLUT_MODEL_H__