renderable.h

Go to the documentation of this file.

/*
 * renderable.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.
 *
 *
 */

#ifndef WAVE_GLUT_GLUT_RENDERABLE_H__
#define WAVE_GLUT_GLUT_RENDERABLE_H__

// includes --------------------------------------------------------------------
#include "wave-glut.h"
#include "camera.h"

#include "geometry/geometry_2d.h"
#include "geometry/geometry_3d.h"
#include "geometry/placement.h"


namespace glut {

/// \ingroup glut
/*@{*/

typedef rect2d_t<int> recti_t;


/// rendering context 
struct render_context_t {
        // constructor, manipulators
        render_context_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        viewport.clear();
                        placement.clear();
                        viewer.clear();
                        camera.clear();
                }

        // data fields
        recti_t         viewport;       ///< where we draw on screen
        placement_t     placement;      ///< object position and orientation
        Viewer          viewer;         ///< viewer position and orientation
        camera_t        camera;         ///< camera information
};



/// stores information necessary to render a polygon later
struct poly_request_t {
        // public enums
        enum eContants {
                eMaxVertices    = 8
        };

        // constructor, manipulators
        void clear(void) throw() {
                        textureId = 0;
                        nVertices = 0;
                }

        // data fields
        int             textureId;      ///< OpenGL texture ID to use
        point3d_t       normal;         ///< normal to polygon
        int             nVertices;      ///< number of vertices for this poly
        float           u[eMaxVertices];///< texture u-coordinate
        float           v[eMaxVertices];///< texture v-coordinate
        point3d_t       vertex[eMaxVertices];///< texture coordinates
};



/// queue of requests
class RenderQueue {
public:
        // virtual destructor --------------------------------------------------
        virtual ~RenderQueue(void) throw();

        // glut::RenderQueue class interface methods ---------------------------

        /// grabs the next available request slot.  Returns NULL if there are
        ///     no more slots available.  This effectively pushes a new request
        ///     slot on the queue, and the client can fill it in using the
        ///     poly_request_t pointer.
        virtual poly_request_t * grabRequestSlot(void) throw() = 0;

        /// pops a request off the queue.  Returns NULL if there are no more
        ///     requests (slots) in the queue.
        virtual poly_request_t * popRequest(void) throw() = 0;

        // static factory methods ----------------------------------------------
        static smart_ptr<RenderQueue> create(IN int nSlots);
};



/// rendering interface -- anything that wants to draw has to implement this
///  interface!
class Renderable {
public:
        // virtual destructor --------------------------------------------------
        virtual ~Renderable(void) throw();

        // glut::Render class interface methods --------------------------------

        /// this method is called to actually draw the object.  The object can
        ///     assume that all necessary transforms (translation, rotation,
        ///     scaling, etc.) have already been applied.  There is no default
        ///     implementation since this method is the whole point of the
        ///     interface!
        virtual void render(IN const render_context_t& rc,
                                IN RenderQueue * rq) = 0;

        /// here the object must provide a bounding box.  This is a bounding
        ///     box in model-relative coordinates, not world coordinates.  So
        ///     this bounding box does <b>not</b> depend on where the model is
        ///     positioned or how it is rotated, for instance.  There is no
        ///     default implementation since an accurate bounding box is
        ///     critical for performance when rendering.
        virtual rect3d_t getBoundingBox(void) const throw() = 0;


        /// does this object support animations?  Default answer is false.
        ///     (random aside: did you know "animateable" is not a word?)
        virtual bool isAnimateable(void) const throw();


        /// the object must provide current animation state.  Default
        ///     implementation returns empty state string.
        virtual void getAnimationState(OUT std::string& state);


        /// the object should update its animation state.  Returns false if
        ///     the object doesn't understand the provided state.  Default
        ///     implementation returns false.
        virtual bool setAnimationState(IN const char * state);

        /// the object should return the full list of animation verbs it
        ///     supports.  The default implementation returns an empty list.
        virtual void getAnimationVerbs(OUT VecString& verbs);


        /// please update animations based on requested verb.  Returns false
        ///     if verb is not supported.  Default implementation returns false.
        virtual bool setAnimation(IN const char * verb);
};



};      // glut namespace

#endif  // WAVE_GLUT_GLUT_RENDERABLE_H__