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, b, 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:
    void DrawSolidMesh( unsigned int faceOffset, unsigned int faceCount, bool textureObject, bool gouraudShading, bool perVertexLighting );
    void DrawOutlineMesh();
    //void DrawPointsMesh();

public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef GLPolygon _BaseClass;
    typedef GLPolygon BaseClass;
    friend class GLTriMeshEditor;

#ifdef GLES
    GlsIndexArray _indices;
#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( void ) 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;

    /** Gets a vector of material indices. */
    GLS_EXPORT DynamicArray<int>& MaterialIndices() DISTI_METHOD_OVERRIDE;

    /* Override base class since a mesh can have multiple materials */
    GLS_EXPORT void MaterialIndex( unsigned int index );

    /* Override base class since a mesh can have multiple materials */
    GLS_EXPORT int MaterialIndex() DISTI_METHOD_OVERRIDE;

    /** Provides access to the faces stored in this mesh */
    GLS_EXPORT GLMeshFace* Faces( void ) { return _faces; }

    /* See base class */
    virtual GLS_EXPORT void CopyGeometry( DisplayObject* src ) DISTI_METHOD_OVERRIDE;

    /* See base class */
    virtual GLS_EXPORT DisplayObject* CloneObject( bool generateNames = false ) DISTI_METHOD_OVERRIDE;

    /* See base class */
    virtual GLS_EXPORT void CopyProperties( DisplayObject* src ) DISTI_METHOD_OVERRIDE;

    /* See base class*/
    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( void ) { 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( void );

    GLS_EXPORT GLTriMesh( const GLTriMesh& that, const bool generateNames );

    /** Destroy a GLTriMesh object */
    virtual GLS_EXPORT ~GLTriMesh( void );

    static GLS_EXPORT DisplayObject* CreateInstance();

    virtual GLS_EXPORT void SetAvailableAttributes( unsigned int value ) DISTI_METHOD_OVERRIDE;

#ifdef GLES
    /* See base class */
    virtual GLS_EXPORT void PreDraw( const OpenGLMatrices& current, Culler& culler ) DISTI_METHOD_OVERRIDE;
#endif

    /* See base class */
    virtual GLS_EXPORT void Draw( void ) DISTI_METHOD_OVERRIDE;

    /* See base class */
    virtual GLS_EXPORT bool Hit( float x, float y, float z, float scale, const Vector& directionVector, Vector* collisionPoint ) DISTI_METHOD_OVERRIDE;

#ifndef GLES
    /* See base class */
    virtual GLS_EXPORT InterfaceListType* GetCppInterfaceDescription( InterfaceListType* addToThisList = NULL ) DISTI_METHOD_OVERRIDE;

    /* See base class */
    virtual GLS_EXPORT void GetCppInterfaceDescriptionFree( InterfaceListType* array ) DISTI_METHOD_OVERRIDE;

    virtual GLS_EXPORT void UseDisplayList( const bool& flag );
    virtual GLS_EXPORT bool UseDisplayList( void );
#endif

    /** Causes the display list for this object to be recomputed */
    GLS_EXPORT void InvalidateGeometry( void )
    {
#ifndef GLES
        _displayList.Invalidate();
#endif
    }

#ifdef GLES
    GLS_EXPORT void DirtyTextureData( void );
#endif

protected:
#ifndef GLES
    /** Contains the actual OpenGL drawing commands to draw the object */
    virtual GLS_EXPORT void DrawGeometry( void );
#endif
    /* A mesh can have multiple textures */
    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;
    unsigned int* _numFaces;
    bool          _inRuntimeMode;

public:
    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;

    virtual GLS_EXPORT std::ostream& WriteValue( std::ostream& );
    virtual GLS_EXPORT std::istream& ReadValue( std::istream& );
};

} // namespace disti

#endif