gls_geometry_resource_mesh.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsGeometryResourceMesh class.
 
  \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 INCLUDED_GLS_GEOMETRY_RESOURCE_MESH_H
#define INCLUDED_GLS_GEOMETRY_RESOURCE_MESH_H
 
#include "display.h"
#include "gls_cpp_lang_support.h"
#include "gls_geometry_resource.h"
#include "gls_render_effect.h"
#include <cstddef>
 
/// Provides support for creating DLLs.
#if( defined( GLSGEN_EXPORT_GLSADVANCEDMESH ) || defined( GLSGEN_IMPORT_GLSADVANCEDMESH ) || defined( GLS_EXPORT_GENERATED ) || defined( GLS_IMPORT_GENERATED ) ) \
    && defined( _MSC_VER )
#    if defined( GLSGEN_EXPORT_GLSADVANCEDMESH ) || defined( GLS_EXPORT_GENERATED )
#        define GLSGEN_GlsAdvancedMesh_EXPORT __declspec( dllexport )
#    else
#        define GLSGEN_GlsAdvancedMesh_EXPORT __declspec( dllimport )
#    endif
#else
#    define GLSGEN_GlsAdvancedMesh_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////
 
namespace disti
{
// Forward Declaration
class GlsSortedDrawable;
 
#ifdef GLES
// Forward Declaration
class GlsGloFileAttribute;
#endif
 
/** 
    This is an abstrace base class for objects that use a GlsGeometryResource for rendering (e.g. GlsAdvancedMesh)
    This class implements Draw / Pick routines that use a RenderMesh provided by the derived classes.  The appearance of the mesh is affected by the IndexBufferEffectsArray.
    This class also implements Translate, Rotate, and Scale through a GeometryTransform matrix.
*/
class GlsGeometryResourceMesh : public DisplayObject
    , public GlsGeometryResource::Observer
{
#if !defined( GLES )
    friend class GlsGeometryResourceMesh_SortedDrawable;
#endif
 
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef DisplayObject _BaseClass; ///< Deprecated typedef for the base class.
    typedef DisplayObject BaseClass;  ///< Typedef for the base class.
    friend class GlsGeometryResourceMeshEditor;
 
    /** Create a new GlsGeometryResourceMesh */
    GLSGEN_GlsAdvancedMesh_EXPORT GlsGeometryResourceMesh();
 
    /** Create a copy of a GlsGeometryResourceMesh
      * \param that     The GlsGeometryResourceMesh to copy from
      * \param generateNames    Whether or not to generate a new instance name for the copy
      */
    GLSGEN_GlsAdvancedMesh_EXPORT GlsGeometryResourceMesh( const GlsGeometryResourceMesh& that, const bool generateNames );
 
    /** GlsGeometryResourceMesh destructor */
    GLSGEN_GlsAdvancedMesh_EXPORT ~GlsGeometryResourceMesh();
 
    //////////////////////////////////////////////////
    // Overridden base class methods
    //////////////////////////////////////////////////
 
    /* Callback for when a resource could invalidate the scene */
    virtual void OnGeometryResourceChanged() DISTI_METHOD_OVERRIDE
    {
        InvalidatePainter();
    }
 
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void SetAvailableAttributes( unsigned int value ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void CopyProperties( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void CopyGeometry( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void UpdateBoundingVolume() DISTI_METHOD_OVERRIDE;
 
#ifndef GLES
    virtual GLSGEN_GlsAdvancedMesh_EXPORT InterfaceListType* GetCppInterfaceDescription( InterfaceListType* addToThisList = NULL ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void               GetCppInterfaceDescriptionFree( InterfaceListType* array ) DISTI_METHOD_OVERRIDE;
#endif
 
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void PreDraw( const OpenGLMatrices& parentMatrices, Culler& culler ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void Draw() DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void GetTransformedExtents( Vector& min, Vector& max, const GlsMatrixType& matrix, bool resetMinMax = true ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void GetExtents( float& minx, float& miny, float& minz, float& maxx, float& maxy, float& maxz ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GlsAdvancedMesh_EXPORT DisplayObject* Pick3D( const Vector& winLoc, const Vector& logicalCoords, float scale, const Vector& directionVector, Vector& collisionWinLoc, const OpenGLMatrices& drawnMatrices ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GlsAdvancedMesh_EXPORT bool Hit( float x, float y, float z, float scale, const Vector& directionVector, Vector* collisionPoint ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void Scale( float px, float py, float pz, Vertex* anchor, int handleBar = 0 ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void Rotate( const Vector& orig, float angle, const Vector& axis ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void TranslateVertices( float x, float y, float z ) DISTI_METHOD_OVERRIDE;
 
    /// Override base class since a mesh can have multiple textures.
    /// \return -2 if multiple textures applied to object, -1 if no texture
    ///         otherwise if all faces use same texture, returns the texture
    ///         index that is shared by the faces.
    virtual GLSGEN_GlsAdvancedMesh_EXPORT int TextureIndex() DISTI_METHOD_OVERRIDE;
 
    /* Override base class since a mesh can have multiple textures */
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void TextureIndex( int index ) DISTI_METHOD_OVERRIDE;
 
    /// Override base class since a mesh can have multiple textures.
    /// \return Whether or not the OpenGL state changed.
    virtual GLSGEN_GlsAdvancedMesh_EXPORT bool SetupTexture();
 
    /// Override base class since a mesh can have multiple materials.
    /// \param index The material index to set.
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void MaterialIndex( unsigned int index );
 
    /// Override base class since a mesh can have multiple materials.
    /// \return The first index in the _materialIndices array.
    virtual GLSGEN_GlsAdvancedMesh_EXPORT int MaterialIndex() DISTI_METHOD_OVERRIDE;
 
    /// Set the _materialIndices array for this object.
    /// \param indices The new indices to set.
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void MaterialIndices( DynamicArray<int> indices ) DISTI_METHOD_OVERRIDE;
 
    /* Override base class since a mesh can have multiple materials */
    virtual GLSGEN_GlsAdvancedMesh_EXPORT DynamicArray<int>& MaterialIndices() DISTI_METHOD_OVERRIDE;
 
    //////////////////////////////////////////////////
    // GlsGeometryResourceMesh specific operations
    //////////////////////////////////////////////////
 
    /// Set the matrix that is applied before the geometry resource is drawn.
    /// \param value The transform value to set.
    GLSGEN_GlsAdvancedMesh_EXPORT void SetGeometryTransform( const GlsMatrixType& value );
 
    /// Set the matrix that is applied before the geometry resource is drawn.
    /// \param matrix Array of 16 doubles that make up the new transform matrix.
    GLSGEN_GlsAdvancedMesh_EXPORT void SetGeometryTransform( const double* matrix );
 
    /**
      * \returns The matrix that is applied before the geometry resource is drawn.
      * Lifetime is guaranteed to coincide with the GlsGeometryResourceMesh's lifetime.
    */
    const GlsMatrixType& GetGeometryTransform() { return _geometryTransform; }
 
    /**
     * \returns The number of IndexBuffers in the current render mesh
     */
    unsigned int NumIndexBuffers()
    {
        return GetRenderMesh()->NumIndexBuffers();
    }
 
    /**
     * \returns The size of the IndexBufferEffects array
     */
    unsigned int NumIndexBufferEffects()
    {
        return _indexBufferEffects.Count();
    }
 
    /// \return Whether or not the draw order of the mesh can be modified for performance.
    bool ReorderAtWill() { return _reorderAtWill; }
 
    /// Sets whether or not the draw order of the mesh can be modified for performance.
    /// \param reorderAtWill The new reorder flag.
    void ReorderAtWill( bool reorderAtWill ) { _reorderAtWill = reorderAtWill; }
 
    /// Set the size of the IndexBufferEffects array.
    /// This will release any effects that are no longer referenced.
    /// \param newSize The new number of effects to set.
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void ResizeIndexBufferEffectsArray( unsigned int newSize );
 
    /** Access the GlsRenderEffect that is used to render the specified index buffer (may be NULL)
     * \param bufferNum The IndexBuffer to get the effect for. Must be between 0 and NumIndexBuffers().
     * \returns Pointer to the index buffer effect used when rendering the specified GlsGeometryResource IndexBuffer 
     */
    GlsRenderEffect* GetIndexBufferEffect( unsigned int bufferNum )
    {
        if( bufferNum >= _indexBufferEffects.Count() )
        {
            return NULL;
        }
 
        return _indexBufferEffects[ bufferNum ];
    }
 
    /** Set the GlsRenderEffect to use when rendering the given index buffer.
     * If this value is NULL, the geometry will be rendered with a default effect.
     * Note: the GlsGeometryResourceMesh will increment the reference count on the new effect and release any effect that was previously referenced.
     * \param bufferNum The IndexBuffer to get the effect for. Should be between 0 and NumIndexBuffers().
     * \param newEffect [out] Pointer to the index buffer effect to use when rendering the specified GlsGeometryResource IndexBuffer.
     */
    void SetIndexBufferEffect( unsigned int bufferNum, GlsRenderEffect* newEffect )
    {
        if( bufferNum >= _indexBufferEffects.Count() )
        {
            ResizeIndexBufferEffectsArray( bufferNum + 1 );
        }
 
        GlsRenderEffect* oldEffect       = _indexBufferEffects[ bufferNum ];
        _indexBufferEffects[ bufferNum ] = newEffect;
 
        if( newEffect )
        {
            newEffect->AddRef();
        }
        if( oldEffect )
        {
            oldEffect->Release();
        }
    }
 
    /// Implemented by the derived class.
    /// \return The mesh that should be rendered / picked.
    virtual GlsGeometryResource* GetRenderMesh() = 0;
 
#ifdef GLES
    /** Set a single attribute from the GLO file.
     * \param data The attribute to set and its associated data.
     */
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void SetFromGloData( GlsGloFileAttribute& data ) DISTI_METHOD_OVERRIDE;
#endif
 
protected:
    GlsMatrixType _geometryTransform; ///< Transformation matrix to be applied to all geometry in this mesh.
 
    DynamicArray<int> _newMaterialIndices; ///< Intermediate data storage to make the setting of new material indices through the Faces simpler.
 
    bool _reorderAtWill; ///< Determines whether or not the draw order of this mesh can be modified to increase performance.
 
    typedef DynamicArray<GlsRenderEffect*> IndexBufferEffectArrayT; ///< Typedef for a list of effects (shaders).
    IndexBufferEffectArrayT                _indexBufferEffects;     ///< The effect to use for each index buffer.
 
    class DistiAttributeIndexBufferEffectArray;
 
#if !defined( GLES )
    typedef DynamicArray<GlsSortedDrawable*> SortedDrawableArrayT;  ///< Typedef for a list of sorted drawables.
    SortedDrawableArrayT                     _indexBufferDrawables; ///< GlsSortedDrawable for each index buffer.
#endif
 
    /// Draw the given mesh object, used by internal draw code.
    /// \note Not normally called by users.
    /// \param renderMesh The mesh to draw.
    GLSGEN_GlsAdvancedMesh_EXPORT void DrawIndexBuffers( GlsGeometryResource* renderMesh );
 
    /// Sets up the default shader program for mesh drawing.
    /// \note Not normally called by users.
    GLSGEN_GlsAdvancedMesh_EXPORT void SetupDefaultEffect();
 
    /// Resets the shader program state after mesh drawing.
    /// \note Not normally called by users.
    GLSGEN_GlsAdvancedMesh_EXPORT void CleanupDefaultEffect();
 
    /// Draw all underlying mesh objects, used by internal draw code.
    /// \note Not normally called by users.
    GLSGEN_GlsAdvancedMesh_EXPORT void DrawGeometry();
 
#ifdef GLES
    /// Creates or updates an effect where the effect's properties apply based on what the data provides. Used by SetFromGloData.
    /// \param data File that contains binary data about the buffer effect.
    /// \return True if it successfully applied the index buffer effect. Returns false on error.
    bool                 SetGloIndexBufferEffect( GlsGloFileAttribute& data );
 
    /// Reads in the given file data to create and initialize the geometry data such as its vertices, normals, and bounding volume.
    /// \param data File that contains binary data about this object's geometry.
    /// \return The resulting geometry resource that has its vertices, normals, colors, and bounding volume initialized. Returns null if there's an error.
    GlsGeometry_Generic* LoadGloGeometryResourceData( GlsGloFileAttribute& data );
#endif
 
private:
    // Cache for the extents to prevent re-calculation when nothing has changed.
    struct LastExtents
    {
        unsigned int  id;
        GlsMatrixType transformMatrix;
        Vector        min;
        Vector        max;
 
        LastExtents()
            : id( GlsGeometryResource::s_invalidDataChangedCounter )
        {}
    } _lastExtents;
 
    // Disable implicit generated Members
    GlsGeometryResourceMesh& operator=( const GlsGeometryResourceMesh& rhs ) DISTI_SPECIAL_MEM_FUN_DELETE;
    GlsGeometryResourceMesh( const GlsGeometryResourceMesh& src ) DISTI_SPECIAL_MEM_FUN_DELETE;
 
    void CopyGeometryInternal( const GlsGeometryResourceMesh& src );
    /* Utility routines used to detect when the material indices has changed */
    void OnMatChanged();
    void OnMatChanged( DynamicArray<int>& a, DynamicArray<int>& b );
    void ReplaceMaterial( unsigned int oldIndex, unsigned int newIndex );
};
 
// Used by code generator.
/// \cond INTERNAL
GLSGEN_GlsAdvancedMesh_EXPORT GlsRenderEffect* CreateRenderEffect_DiffNormSpecRefl(
    unsigned int material_index,
    int          diffuse_texture_index,
    int          normal_texture_index,
    int          specular_texture_index,
    int          reflection_texture_index,
    float        diffuse_amount,
    float        normal_amount,
    float        specular_amount,
    float        reflection_amount,
    bool         useVertexColors,
    bool         normalFlipGreen,
    float        diff_map_offset_v = 0.0f,
    float        diff_map_offset_u = 0.0f,
    float        diff_map_tiling_u = 1.0f,
    float        diff_map_tiling_v = 1.0f,
    float        diff_map_angle_w  = 0.0f,
    float        norm_map_offset_v = 0.0f,
    float        norm_map_offset_u = 0.0f,
    float        norm_map_tiling_u = 1.0f,
    float        norm_map_tiling_v = 1.0f,
    float        norm_map_angle_w  = 0.0f,
    float        spec_map_offset_v = 0.0f,
    float        spec_map_offset_u = 0.0f,
    float        spec_map_tiling_u = 1.0f,
    float        spec_map_tiling_v = 1.0f,
    float        spec_map_angle_w  = 0.0f );
/// \endcond
} // namespace disti
 
#endif