gltrimesh.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GLTriMesh class.  Implements Triangle Meshes.
 
  \par Copyright Information
 
  Copyright (c) 2017 by The DiSTI Corporation.<br>
  11301 Corporate Blvd; Suite 100<br>
  Orlando, Florida 32817<br>
  USA<br>
  <br>
  All rights reserved.<br>
 
  This Software contains proprietary trade secrets of DiSTI and may not be
reproduced, in whole or part, in any form, or by any means of electronic,
mechanical, or otherwise, without the written permission of DiSTI.  Said
permission may be derived through the purchase of applicable DiSTI product
licenses which detail the distribution rights of this content and any
Derivative Works based on this or other copyrighted DiSTI Software.
 
  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.
 
  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
EXCEED FIVE DOLLARS (US$5.00).
 
  The aforementioned terms and restrictions are governed by the laws of the
State of Florida and the United States of America.
 
*/
 
#ifndef _GL_TRI_MESH_H
#define _GL_TRI_MESH_H
 
#include "display.h"
#include "gls_cpp_lang_support.h"
#ifndef GLES
#    include "gls_display_list.h"
#endif
#include "disti_metadata.h"
#include "glpolygon.h"
#ifdef GLES
#    include "dynamic_array.h"
#    include "gls_index_array.h"
#endif
 
namespace disti
{
// Forward Declaration
class GlsGloFileAttribute;
 
// SetValue enumerations
enum
{
    GLS_TRIMESH_FIRST_VALUE = GLS_LAST_INITIALIZER + 1,
    GLS_TRIMESH_USE_DISPLAY_LIST, // whether or not to use a display list
    GLS_TRIMESH_FACES
};
 
/**
  \brief Structure for holding mesh vertex indices
  */
typedef struct
{
    int          a;        ///< Vertex indices of the face.
    int          b;        ///< Vertex indices of the face.
    int          c;        ///< Vertex indices of the face.
    int          texture;  ///< Texture index of face.
    unsigned int material; ///< Material index of face.
} GLMeshFace;
 
/** The GLMeshVertex structure.  Defines all of the attributes of a TriMesh vertex.  Used in generated code.
  */
typedef struct
{
    float         vertex[ 3 ];   /**< The vertex coordinate */
    unsigned char color[ 4 ];    /**< The vertex color */
    float         texCoord[ 2 ]; /**< The texture coordinate */
    float         normal[ 3 ];   /**< The vertex normal */
} GLMeshVertex;
 
/**
  \brief  The glTriMesh class.  Implements Triangle Meshes
*/
class GLTriMesh : public GLPolygon
{
protected:
    /// Helper function for underlying solid mesh drawing.
    /// \note Not normally called by users.
    /// \param faceOffset Index offset into the face array.
    /// \param faceCount The number of faces to draw.
    /// \param textureObject If true, draw with texture.
    /// \param gouraudShading If true, draw with smooth shading.
    /// \param perVertexLighting If true, use per vertex lighting.
    void DrawSolidMesh( unsigned int faceOffset, unsigned int faceCount, bool textureObject, bool gouraudShading, bool perVertexLighting );
 
    /// Helper function for underlying outline mesh drawing.
    /// \note Not normally called by users.
    void DrawOutlineMesh();
 
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef GLPolygon _BaseClass; ///< Deprecated typedef for the base class.
    typedef GLPolygon BaseClass;  ///< Typedef for the base class.
    friend class GLTriMeshEditor;
 
#ifdef GLES
    GlsIndexArray _indices; ///< The index array for this mesh.
#else
    /** Stores object in display list for faster drawing */
    GlsDisplayList _displayList;
#endif
 
    /* Override base class since a mesh can have multiple textures */
    GLS_EXPORT int TextureIndex() DISTI_METHOD_OVERRIDE;
 
    /* Override base class since a mesh can have multiple textures */
    GLS_EXPORT void TextureIndex( int index ) DISTI_METHOD_OVERRIDE;
 
    /* Override base class since a mesh can have multiple materials */
    GLS_EXPORT void MaterialIndices( DynamicArray<int> index ) DISTI_METHOD_OVERRIDE;
 
    GLS_EXPORT DynamicArray<int>& MaterialIndices() DISTI_METHOD_OVERRIDE;
 
    /// Override base class since a mesh can have multiple materials.
    /// \note This is technically not an override, GLS-11064.
    /// \param index The new material index to set on all faces.
    GLS_EXPORT void MaterialIndex( unsigned int index );
 
    /* Override base class since a mesh can have multiple materials */
    GLS_EXPORT int MaterialIndex() DISTI_METHOD_OVERRIDE;
 
    /// \return Access to the faces stored in this mesh.
    GLS_EXPORT GLMeshFace* Faces() { return _faces; }
 
    virtual GLS_EXPORT void CopyGeometry( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT DisplayObject* CloneObject( bool generateNames = false ) DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT void           CopyProperties( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT void           SetValue( int spec, va_list& args ) DISTI_METHOD_OVERRIDE;
 
    /// Copies the attributes from an object (possibly a group) to this one. Used by the
    /// mesh creator to copy properties from the objectrs that were converted into this mesh.
    /// \param src The object to copy properties from.
    GLS_EXPORT void AssignPropertiesFromGroup( DisplayObject* src );
 
    /** Sets the number of faces in the mesh and allocates the face array 
      * \param n  The new number of faces for the mesh
      */
    GLS_EXPORT void NumberOfFaces( unsigned int n );
 
    /** \return The number of faces in this mesh */
    GLS_EXPORT unsigned int NumberOfFaces() { return _nFaces; }
 
    /** For all faces of the mesh that have the old material, replace that material 
      * with the new material.
      * \param oldIndex  Old material index
      * \param newIndex  New material index
      */
    GLS_EXPORT void ReplaceMaterial( unsigned int oldIndex, unsigned int newIndex );
 
    /** Sets the vertices and texture index of a specific face 
      * \param face
      * \param a  The vertex index for the first vertex of the triangle
      * \param b  The vertex index for the second vertex of the triangle
      * \param c  The vertex index for the third vertex of the triangle
      * \param tindex  The texture index for triangle
      * \param materialIndex  The material index for triangle
      */
    GLS_EXPORT void SetFace( unsigned int face, int a, int b, int c, int tindex, unsigned int materialIndex = 0 );
 
    /** Sets all the faces of the mesh. Used in runtime. 
      * \param numFaces  The number of faces that will be passed in
      * \param ... A variable argument field which will be numFaces instances of a,b,c,tindex,materialIndex 
      */
    GLS_EXPORT void VaSetFaces( unsigned int numFaces, ... );
 
    /** Sets all the faces of the mesh. Used in parser
      * \param nFaces  The number of faces that will be set
      * \param faces  An array of GLMeshFaces with nFaces elements
      */
    GLS_EXPORT void SetFaces( unsigned int nFaces, GLMeshFace* faces );
 
    /** Sets all the faces and vertices of the mesh.  Used in generated code
      * \param nVertices  Number of vertices
      * \param vertices   Array of initialized vertices
      * \param nFaces      Number of faces
      * \param faces      Array of initialized faces
      */
    GLS_EXPORT void SetVerticesAndFaces( unsigned int nVertices, const GLMeshVertex* vertices, unsigned int nFaces, const GLMeshFace* faces );
 
    /** Creates a GLTriMesh with the vertices specified
      * \param nVertices   The number of vertices in the new polygon
      * \param vertices  The array of vertices for the polygon
      */
    GLS_EXPORT GLTriMesh( unsigned int nVertices, Vertex* vertices );
 
    /// Creates a GLTriMesh with the vertices specified.
    /// \param nVertices The number of vertices in the new polygon.
    /// \param vertices The array of vertices for the polygon.
    /// \param location The location point of the object.
    GLS_EXPORT GLTriMesh( unsigned int nVertices, Vertex* vertices, Vertex& location );
 
    /** Allocate a (blank) GLTriMesh object */
    GLS_EXPORT GLTriMesh();
 
    /// Copy constructor
    /// \param that The object to copy from.
    /// \param generateNames Whether or not an instance name should be generated for this object.
    GLS_EXPORT GLTriMesh( const GLTriMesh& that, const bool generateNames );
 
    /** Destroy a GLTriMesh object */
    virtual GLS_EXPORT ~GLTriMesh();
 
    /// \return A pointer to a new GLTriMesh object.
    static GLS_EXPORT DisplayObject* CreateInstance();
 
    virtual GLS_EXPORT void SetAvailableAttributes( unsigned int value ) DISTI_METHOD_OVERRIDE;
 
#ifdef GLES
    virtual GLS_EXPORT void PreDraw( const OpenGLMatrices& current, Culler& culler ) DISTI_METHOD_OVERRIDE;
#endif
 
    virtual GLS_EXPORT void Draw() DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT bool Hit( float x, float y, float z, float scale, const Vector& directionVector, Vector* collisionPoint ) DISTI_METHOD_OVERRIDE;
 
#ifndef GLES
    virtual GLS_EXPORT InterfaceListType* GetCppInterfaceDescription( InterfaceListType* addToThisList = NULL ) DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT void               GetCppInterfaceDescriptionFree( InterfaceListType* array ) DISTI_METHOD_OVERRIDE;
 
    /// Set whether or not the mesh will use a display list, rather than immediate mode.
    /// \param flag The new display list mode to set.
    virtual GLS_EXPORT void UseDisplayList( const bool& flag );
 
    /// \return Whether or not the mesh will use a display list, rather than immediate mode.
    virtual GLS_EXPORT bool UseDisplayList();
#endif
 
    /** Causes the display list for this object to be recomputed */
    GLS_EXPORT void InvalidateGeometry()
    {
#ifndef GLES
        _displayList.Invalidate();
#endif
    }
 
#ifdef GLES
    GLS_EXPORT void DirtyTextureData();
#endif
 
protected:
#ifndef GLES
    /** Contains the actual OpenGL drawing commands to draw the object */
    virtual GLS_EXPORT void DrawGeometry();
#endif
    /// Set up the OpenGL state for texturing.
    /// \note A mesh can have multiple textures.
    /// \param textureIndex The first texture to use.
    /// \return Whether or not the OpenGL state was changed.
    virtual GLS_EXPORT bool SetupTexture( const int textureIndex );
 
#ifdef GLES
    /** Set a single attribute from the GLO file.
     * \param data The attribute to set and its associated data.
     */
    virtual GLS_EXPORT void SetFromGloData( GlsGloFileAttribute& data ) DISTI_METHOD_OVERRIDE;
#endif
 
private:
    unsigned int _nFaces; /** Number of faces (triangles) in this mesh */
 
    GLMeshFace* _faces; /** Array of vertex indices for triangles */
 
    DynamicArray<int> _newMaterialIndices; /** Intermediate data storage to make the setting of new material indices through the Faces simpler. */
 
#ifdef GLES
    /* Resizable array of indices into the faces array where the active texture is different from
     * the previous face.
     */
    DynamicArray<unsigned int> _textureChangeIndices;
    bool                       _textureChangesDirty; /** true if _textureSwitchIndices needs to be recomputed */
 
    /* Utility routine used by Draw. Should only be called when _textureSwitchDirty is true.
     * Rebuilds the _textureSwitchIndices array by scanning the data in the face array
     * and taking note when the texture index changes between faces.
     */
    void RecalculateTextureChanges();
#endif
    /* Utility routine used by Hit.  Performs a "FirstHit" test, which performs a hit test on the object
     * but does not guarantee that the collision point returned by Hit is the closest collision point
     * to the observer
     * \param point            The logical coordinate of the click, relative to the object
     * \param directionVector  The direction of the pick vector
     * \param collisionPoint   Set to the point on the object hit by directionVector
     * \return boolean indicating if the object was hit by the mouse
     */
    bool FirstHit( const Vector& point, const Vector& directionVector, Vector* collisionPoint );
 
    /* Utility routine used by Hit.  Performs a "BestHit" test, which performs a hit test on the object
      * and guarantees that the collision point returned by Hit is the closest collision point to the observer.
      * \param point            The logical coordinate of the click, relative to the object
      * \param directionVector  The direction of the pick vector
      * \param collisionPoint   Set to the point on the object hit by directionVector
      * \return boolean indicating if the object was hit by the mouse
      */
    bool BestHit( const Vector& point, const Vector& directionVector, Vector* collisionPoint );
 
    /* Utility routines used to detect when the material indices has changed */
    void OnMatChanged();
    void OnMatChanged( DynamicArray<int>& a, DynamicArray<int>& b );
 
    GLTriMesh& operator=( const GLTriMesh& ) DISTI_SPECIAL_MEM_FUN_DELETE;
    GLTriMesh( const GLTriMesh& ) DISTI_SPECIAL_MEM_FUN_DELETE;
 
    void CopyGeometryInternal( GLTriMesh* src );
    void CopyPropertiesInternal( GLTriMesh* src );
};
 
/** The DistiAttributeMeshFaceArray class.  Defines metadata for the GlMeshFace type.
  */
class DistiAttributeMeshFaceArray : public DistiAttributeBase
{
    GLMeshFace**  _attribPtr;     ///< Observing pointer to the underlying mesh data.
    unsigned int* _numFaces;      ///< Observing pointer to the underlying mesh face count.
    bool          _inRuntimeMode; ///< Governs the attribute parsing behavior.
 
public:
    /// Constructor
    /// \param callback The callback to call when the attribute changes.
    /// \param name The name of the new attribute.
    /// \param attribPtr A pointer to the underlying mesh data.
    /// \param numFaces A pointer to the underlying mesh face count.
    /// \param inRuntimeMode Mode for attribute parsing behavior.
    GLS_EXPORT DistiAttributeMeshFaceArray( CallbackMethodCallerBase* callback, const AttributeName& name, GLMeshFace** attribPtr, unsigned int* numFaces, bool inRuntimeMode );
 
    virtual GLS_EXPORT ~DistiAttributeMeshFaceArray();
 
    virtual GLS_EXPORT bool OkToWrite() const DISTI_METHOD_OVERRIDE;
 
    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& ) DISTI_METHOD_OVERRIDE;
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& ) DISTI_METHOD_OVERRIDE;
};
 
} // namespace disti
 
#endif