gls_serial_morph_mesh.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsSerialMorphMesh 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_SERIAL_MORPH_MESH_H
#define INCLUDED_GLS_SERIAL_MORPH_MESH_H

#ifdef _WIN32
#    include <windows.h>
#endif

#include "gls_geometry_resource.h"
#include "gls_resource_file_mgr.h"
#include "group.h"

#include "gls_advanced_mesh.h"
#include "gls_cpp_lang_support.h"

//////////////////// 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_GlsSerialMorphMesh_EXPORT __declspec( dllexport )
#    else
#        define GLSGEN_GlsSerialMorphMesh_EXPORT __declspec( dllimport )
#    endif
#else
#    define GLSGEN_GlsSerialMorphMesh_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////

#define LIB_BASE_NAME "gls_advanced_mesh"
#include "gls_auto_lib.h"
#undef LIB_BASE_NAME

namespace disti
{
#ifdef GLES
// Forward Declaration
class GlsGloFileAttribute;
#endif

/** 
    The GlsSerialMorphMesh contains a series of morph targets (keyframes) that make up an animation.
*/
class GlsSerialMorphMesh : public GlsGeometryResourceMesh
{
public:
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef GlsGeometryResourceMesh _BaseClass;
    typedef GlsGeometryResourceMesh BaseClass;
    friend class GlsSerialMorphMeshEditor;

    /** Create a new GlsSerialMorphMesh. */
    GLSGEN_GlsSerialMorphMesh_EXPORT GlsSerialMorphMesh( void );

    GLSGEN_GlsSerialMorphMesh_EXPORT GlsSerialMorphMesh( const GlsSerialMorphMesh& that, const bool generateNames );

    /** Destructs a GlsSerialMorphMesh object */
    virtual GLSGEN_GlsSerialMorphMesh_EXPORT ~GlsSerialMorphMesh();

    static GLSGEN_GlsSerialMorphMesh_EXPORT DisplayObject* CreateInstance();

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

    /* See base class */
    virtual GLSGEN_GlsSerialMorphMesh_EXPORT void SetAvailableAttributes( unsigned int value ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsSerialMorphMesh_EXPORT DisplayObject* CloneObject( bool generateNames = false ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsSerialMorphMesh_EXPORT void           CopyProperties( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GlsSerialMorphMesh_EXPORT void           CopyGeometry( DisplayObject* src ) DISTI_METHOD_OVERRIDE;

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

    virtual GLSGEN_GlsSerialMorphMesh_EXPORT void PreDraw( const OpenGLMatrices& parentMatrices, Culler& culler ) DISTI_METHOD_OVERRIDE;
    //virtual GLSGEN_GlsSerialMorphMesh_EXPORT void Draw(void);

    //virtual GLSGEN_GlsSerialMorphMesh_EXPORT void UpdateBoundingVolume(void);

    //////////////////////////////////////////////////
    // GlsSerialMorphMesh specific operations
    //////////////////////////////////////////////////

    /** Set the number of keyframes in the mesh
        If this is less than the current number of keyframes, then keyframes >=NumKeyframes() will be released
        The initial Geometry and Values for new keyframes are undefined, be sure to fill them in before you
        try to draw/pick/etc.
        \param count the new number of keyframes
        */
    GLSGEN_GlsSerialMorphMesh_EXPORT void SetNumKeyframes( unsigned int count );

    /** Get the number of keyframes in the mesh
        \returns the number of keyframes
        */
    GLSGEN_GlsSerialMorphMesh_EXPORT unsigned int NumKeyframes();

    /** Set the geometry for the given keyframe.
      */
    GLSGEN_GlsSerialMorphMesh_EXPORT GlsGeometry_Generic* GetKeyframeGeometry( unsigned int index );

    /** Set the geometry for the given keyframe.
      * Note that the render geometry Type() is derived from keyframe 0.
      * If you modify the Type() of the keyframe geometry you must call this method to update the render mesh.
      * \param keyframeIndex
      * \param newKeyframeGeometry Pointer to the new geometry to use
      */
    GLSGEN_GlsSerialMorphMesh_EXPORT void SetKeyframeGeometry( unsigned int keyframeIndex, GlsGeometry_Generic* newKeyframeGeometry );

    /** Set the value for the given animation keyframe
      */
    GLSGEN_GlsSerialMorphMesh_EXPORT void SetKeyframePercent( unsigned int index, const float& value );

    /** Get the value for the given animation keyframe
      * \param index keyframe index
      * \returns percent 
      */
    GLSGEN_GlsSerialMorphMesh_EXPORT float GetKeyframePercent( unsigned int index );

    /** Set the mesh to the given animation value
      */
    GLSGEN_GlsSerialMorphMesh_EXPORT void SetMorphPercent( const float& value );

    /** Get the current animation value
      * \returns percent animation value
      */
    GLSGEN_GlsSerialMorphMesh_EXPORT float GetMorphPercent();

    /** Set the tension parameter.
      * Tension affects how the mesh is interpolated between targets.
      * \param value value to determine what interpolation is used
      * 0.0 is linear interpolation
      * higher values use spline interpolation to smooth out the transitions at each target.
      * Recommended values are 0.0 and 0.5.  Other values result in "special effects".
      */
    GLSGEN_GlsSerialMorphMesh_EXPORT void SetTension( const float& value );

    /** Get the current 'tension' value
      * \returns tension value
      */
    GLSGEN_GlsSerialMorphMesh_EXPORT float GetTension();

    /** Flag the render mesh as dirty so that it will be updated before it is drawn
      */
    inline void InvalidateRenderMesh() { _renderMeshIsValid = false; }

    /** Update the render mesh immeadiately
      * This is normally done as needed automatically
      */
    GLSGEN_GlsSerialMorphMesh_EXPORT void UpdateRenderMesh();

protected:
    /** GlsGeometryResourceMesh override
      */
    virtual GLSGEN_GlsSerialMorphMesh_EXPORT GlsGeometryResource* GetRenderMesh() DISTI_METHOD_OVERRIDE;

#ifdef GLES
    /** Set a single attribute from the GLO file.
     * \param data The attribute to set and its associated data.
     */
    virtual GLSGEN_GlsSerialMorphMesh_EXPORT void SetFromGloData( GlsGloFileAttribute& data ) DISTI_METHOD_OVERRIDE;
#endif

    class Keyframe_Data
    {
    protected:
        DistiAttribDict* _attribDict;

        void SetupAttribDict();

    public:
        GlsGeometry_Generic* _geometry;
        float                _value;

        GLSGEN_GlsSerialMorphMesh_EXPORT Keyframe_Data();
        GLSGEN_GlsSerialMorphMesh_EXPORT Keyframe_Data( const Keyframe_Data& );
        GLSGEN_GlsSerialMorphMesh_EXPORT ~Keyframe_Data();
        GLSGEN_GlsSerialMorphMesh_EXPORT const Keyframe_Data& operator=( const Keyframe_Data& );

        GLSGEN_GlsSerialMorphMesh_EXPORT void SetGeometry( GlsGeometry_Generic* geom );
        GLSGEN_GlsSerialMorphMesh_EXPORT GlsGeometry_Generic* GetGeometry();

        GLSGEN_GlsSerialMorphMesh_EXPORT DistiAttribDict& Attributes();
    };

    class KeyframeDataArray
    {
    public:
        GlsSerialMorphMesh* _parentMesh;

        GLSGEN_GlsSerialMorphMesh_EXPORT KeyframeDataArray()
            : _parentMesh( NULL )
        {}

        static void element_read_func( int index, KeyframeDataArray& array, std::istream& instr );
        static void element_write_func( int index, KeyframeDataArray& array, std::ostream& outstr );

        void     Count( unsigned count ) { _keyframes.Count( count ); }
        unsigned Count() const { return _keyframes.Count(); }

        void Clear() { _keyframes.Clear(); }

        Keyframe_Data&       operator[]( const std::size_t index ) { return _keyframes[ static_cast<unsigned>( index ) ]; }
        const Keyframe_Data& operator[]( const std::size_t index ) const { return _keyframes[ static_cast<unsigned>( index ) ]; }

    private:
        DynamicArray<Keyframe_Data> _keyframes;
    };

    KeyframeDataArray _keyframes;

    // The current position in the animation
    float _currentValue;

    // The interpolation tension value
    float _tension;

    unsigned int _last_keyframe_index;  // The first keyframe where _value <= _currentValue
    unsigned int _next_keyframe_index;  // The next keyframe after last_keyframe_index where _value > _currentValue. If _value matches _currentValue exactly, then last_keyframe_index == next_keyframe_index
    float        _last_keyframe_weight; // The blend weight for the first keyframe [0,1]
    float        _next_keyframe_weight; // The blend weight for the next keyframe [0,1]

    bool                 _renderMeshIsValid;
    GlsGeometry_Generic* _renderMesh;

    // Update the _last_keyframe_index, _next_keyframe_index, _last_keyframe_weight and _next_keyframe_weight
    GLSGEN_GlsSerialMorphMesh_EXPORT void RecalculateKeyframeIndicesAndWeights();

    // Called by the KeyframeData class when the geometry changes.
    GLSGEN_GlsSerialMorphMesh_EXPORT void KeyframeGeometryChanged( Keyframe_Data* );

private:
#ifdef GLES
    int _gloKeyframeIndex;
#endif

    void CalculateBSplineInterpolation() const;

    // Used by constructors
    GLSGEN_GlsSerialMorphMesh_EXPORT void InitializeMembers();

    // Disable implicit generated Members
    GlsSerialMorphMesh& operator=( const GlsSerialMorphMesh& rhs ) DISTI_SPECIAL_MEM_FUN_DELETE;
    GlsSerialMorphMesh( const GlsSerialMorphMesh& src ) DISTI_SPECIAL_MEM_FUN_DELETE;
};

} // namespace disti

#endif