gls_triangle_mesh.h

Go to the documentation of this file.

#ifndef _GLS_TRIANGLE_MESH_H
#define _GLS_TRIANGLE_MESH_H
 
/*! \file gls_triangle_mesh.h
 
\brief  This header defines the GlsTriangleMesh class
        in the GL Studio DO-178B Runtime Library.
 
\par Copyright Information
Copyright (C) 1999-2012 The DiSTI Corporation<br>
Orlando, FL USA<br>
All rights reserved.<br>
 
  This file is copyrighted software and contains proprietary trade secrets of
DiSTI, and embodies substantial creative efforts as well as confidential
information, ideas, and expressions.
 
  Permission to use, and copy this software and its documentation for any
purpose is hereby granted per the Distribution Agreement and/or the Licensing
Agreement signed with DiSTI. This permission is granted provided that:
    1.  The above copyright notice appears in all copies.
    2.  That both the copyright notice and this permission notice appear in
        the supporting documentation.
    3.  That the names DiSTI and GL Studio not be used in advertising or
        publicity pertaining to distribution of the software without specific,
        written prior permission of DiSTI.
 
  Permission to modify the software is granted, but not the right to
distribute the source code whether modified, or non-modified.  Modifying the
software might invalidate the DO-178B certification package.
 
  Permission to distribute binaries produced by compiling source code, or
modified source code is granted, provided you:
    1.  Provide your name and address as the primary contact for the support
        of your modified version.
    2.  Retain our contact information in regard to use of the base software. 
 
   DiSTI does not provide warranty for this software or guarantee that it
satisfies any specification or requirement unless otherwise stated in a
specific contractual arrangement between the customer and DiSTI.
 
*/
 
#include "gls_include.h"
#include "gls_render_object.h"
#include "gls_vertex.h"
#include "gls_texture_vertex_array.h"
#include "gls_state_manager.h"
#include "gls_class_invariant.h"
 
/** This class encapsulates a mesh of triangle faces.
  * \invariant base class invariant holds,
  *            GLS_NULL != _faces, _numFaces > 0u,
  *            _vertices invariant holds,
  *            for each element in _faces:
  *                v1,v2,v3 < _vertices.GetSize(),
  *                textureIndex < _texturePalette.GetSize()
  */
class GlsTriangleMesh : public GlsRenderObject
{
public:
    GLS_CLASS_INVARIANT_DECLARATION( GlsTriangleMesh )
 
    /** describes a single triangle face in the mesh */
    struct TriangleFace
    {
        GlsUInt32 v1;           /**< index of first vertex in triangle face */
        GlsUInt32 v2;           /**< index of second vertex in triangle face */
        GlsUInt32 v3;           /**< index of third vertex in triangle face */
        GlsUInt32 textureIndex; /**< index of texture for face else GlsTexturePalette::NO_TEXTURE */
    };
 
    /** Initialization parameters for a GlsTriangleMesh */
    struct InitParameters
    {
        const GlsRenderObject::InitParameters       renderInitParameters;   /**< base class init parameters */
 
        const GlsTextureVertexArray::InitParameters verticesInitParameters; /**< vertices */
        const GlsUInt32                             numFaces;               /**< number of faces in triangle mesh
                                                                              * ( >= 1 ) */
        const TriangleFace* const                   faces;                  /**< array of faces in triangle mesh */
 
        #if defined( GLS_DEBUG )
            /** Determine if the initialization parameters are vaild ( GLS_DEBUG only )
              * \return GLS_TRUE if valid else GLS_FALSE
              * \pre none
              * \post none
              */
            GlsBool IsValid( void ) const;
        #endif // GLS_DEBUG
    };
        
    /** Constructor - create an instance
      * \param initParameters initialization parameters
      * \param eventDispatcher event dispatcher for this object else GLS_NULL
      * \pre initParameters.isValid()
      * \post instance is created
      */
    GlsTriangleMesh( const InitParameters &initParameters, GlsEventDispatcher* const eventDispatcher );
 
    /** Draws the triangle mesh
      * \param gl GL State manager for OpenGL into which object is drawn
      * \param time the elaspsed time in seconds since program start
      * \pre time >= 0.0
      * \post object is drawn to OpenGL if visible and not blinked off
      */
    virtual void Draw( GlsStateManager &gl, const GlsFloat64 time );
 
    /** Set the desired texture index
      * \param textureIndex desired texture index into palette else GlsTexturePalette::NO_TEXTURE
      * \pre textureIndex is less than the size of the texture palette, else GlsTexturePalette::NO_TEXTURE,
      *      object's texture palette must have a valid texture (not an empty palette entry) at textureIndex
      *      if textureIndex != GlsTexturePalette::NO_TEXTURE
      * \post object has new texture index or is untextured if textureIndex == GlsTexturePalette::NO_TEXTURE
      */
    virtual void SetTextureIndex( const GlsUInt32 textureIndex );
 
    /** Offset the texture on the object
      * \param offset x, y offset for texture
      * \pre offset.IsValid()
      * \post offset is added to the texture coordinates
      */
    virtual void OffsetTexture( const GlsVector2D &offset );
 
protected:
    const GlsUInt32              _numFaces; /**< number of faces in faces array */
    TriangleFace* const          _faces;    /**< array of faces in triangle mesh */
    GlsTextureVertexArray        _vertices; /**< vertices in triangle mesh */
 
    /** Destructor - shall never be called
      * \pre none
      * \post none
      */
    virtual ~GlsTriangleMesh();
 
private:
    typedef GlsRenderObject _BaseClass;
 
    // Disable implicit generated Members
    GlsTriangleMesh& operator=( const GlsTriangleMesh &rhs );
    GlsTriangleMesh( const GlsTriangleMesh &src );
};
 
#endif // _GLS_TRIANGLE_MESH_H