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:
    typedef DisplayObject _BaseClass;
    friend class GlsGeometryResourceMeshEditor;

    /** Create a new GlsGeometryResourceMesh */
    GLSGEN_GlsAdvancedMesh_EXPORT GlsGeometryResourceMesh( void );

    /** 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( void );

    //////////////////////////////////////////////////
    // Overridden base class methods
    //////////////////////////////////////////////////

    /* Callback for when a resource could invalidate the scene */
    virtual void OnGeometryResourceChanged()
    {
        InvalidatePainter();
    }

    /* See base class */
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void SetAvailableAttributes( unsigned int value );
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void CopyProperties( DisplayObject* src );
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void CopyGeometry( DisplayObject* src );
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void UpdateBoundingVolume( void );

#ifndef GLES
    virtual GLSGEN_GlsAdvancedMesh_EXPORT InterfaceListType* GetCppInterfaceDescription( InterfaceListType* addToThisList = NULL );
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void               GetCppInterfaceDescriptionFree( InterfaceListType* array );
#endif

    virtual GLSGEN_GlsAdvancedMesh_EXPORT void PreDraw( const OpenGLMatrices& parentMatrices, Culler& culler );
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void Draw( void );

    virtual GLSGEN_GlsAdvancedMesh_EXPORT void GetTransformedExtents( Vector& min, Vector& max, const GlsMatrixType& matrix, bool resetMinMax = true );
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void GetExtents( float& minx, float& miny, float& minz, float& maxx, float& maxy, float& maxz );

    virtual GLSGEN_GlsAdvancedMesh_EXPORT DisplayObject* Pick3D( const Vector& winLoc, const Vector& logicalCoords, float scale, const Vector& directionVector, Vector& collisionWinLoc, const OpenGLMatrices& drawnMatrices );

    virtual GLSGEN_GlsAdvancedMesh_EXPORT bool Hit( float x, float y, float z, float scale, const Vector& directionVector, Vector* collisionPoint );

    virtual GLSGEN_GlsAdvancedMesh_EXPORT void Scale( float px, float py, float pz, Vertex* anchor, int handleBar = 0 );
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void Rotate( const Vector& orig, float angle, const Vector& axis );
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void TranslateVertices( float x, float y, float z );

    /** Override base class since a mesh can have multiple textures.
      * \returns -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( void );

    /* Override base class since a mesh can have multiple textures */
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void TextureIndex( int index );

    /* Override base class since a mesh can have multiple textures */
    virtual GLSGEN_GlsAdvancedMesh_EXPORT bool SetupTexture( void );

    /** Override base class since a mesh can have multiple materials
      * \returns the first index in the _materialIndices array. */
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void MaterialIndex( unsigned int index );

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

    /** \returns the _materialIndices array for this object.
    */
    virtual GLSGEN_GlsAdvancedMesh_EXPORT void MaterialIndices( DynamicArray<int> indices );

    /* Override base class since a mesh can have multiple materials */
    virtual GLSGEN_GlsAdvancedMesh_EXPORT DynamicArray<int>& MaterialIndices();

    //////////////////////////////////////////////////
    // GlsGeometryResourceMesh specific operations
    //////////////////////////////////////////////////

    /**
        Set the matrix that is applied before the geometry resource is drawn.
    */
    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();
    }

    /**
     * \returns The 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
     */
    void ReorderAtWill( bool reorderAtWill )
    {
        _reorderAtWill = reorderAtWill;
    }

    /**
     * Set the size of the IndexBufferEffects array
     * This will release any effects that are no longer referenced.
     */
    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.InternalArray()[ 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();
        }
    }

    // Returns the mesh that should be rendered / picked
    // Implemented by the derived class
    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 );
#endif

protected:
    GlsMatrixType _geometryTransform;

    DynamicArray<int> _newMaterialIndices; /** Intermediate data storage to make the setting of new material indices through the Faces simpler. */

    /* Determines whether or not the draw order of this mesh can be modified to increase performance */
    bool _reorderAtWill;

    typedef DynamicArray<GlsRenderEffect*, true> IndexBufferEffectArrayT;
    IndexBufferEffectArrayT                      _indexBufferEffects; ///< The effect to use for each index buffer

    class DistiAttributeIndexBufferEffectArray;

#if !defined( GLES )
    typedef DynamicArray<GlsSortedDrawable*, true> SortedDrawableArrayT;
    SortedDrawableArrayT                           _indexBufferDrawables; ///< GlsSortedDrawable for each index buffer
#endif

    GLSGEN_GlsAdvancedMesh_EXPORT void DrawIndexBuffers( GlsGeometryResource* renderMesh );
    GLSGEN_GlsAdvancedMesh_EXPORT void SetupDefaultEffect();

    GLSGEN_GlsAdvancedMesh_EXPORT void CleanupDefaultEffect();

    GLSGEN_GlsAdvancedMesh_EXPORT void DrawGeometry();

#ifdef GLES
    // Used by SetFromGloData().
    bool                 SetGloIndexBufferEffect( GlsGloFileAttribute& data );
    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 */
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 );

} // namespace disti

#endif