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
///////////////////////////////////////////////////////////////////////////////
 
/// Automatically link the runtime library plugin (on Windows).
#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; ///< Deprecated typedef for the base class.
    typedef GlsGeometryResourceMesh BaseClass;  ///< Typedef for the base class.
    friend class GlsSerialMorphMeshEditor;
 
    /** Create a new GlsSerialMorphMesh. */
    GLSGEN_GlsSerialMorphMesh_EXPORT GlsSerialMorphMesh();
 
    /// Copy constructor
    /// \param that The object to copy from.
    /// \param generateNames Whether or not an instance name should be generated for this object.
    GLSGEN_GlsSerialMorphMesh_EXPORT GlsSerialMorphMesh( const GlsSerialMorphMesh& that, const bool generateNames );
 
    /** Destructs a GlsSerialMorphMesh object */
    virtual GLSGEN_GlsSerialMorphMesh_EXPORT ~GlsSerialMorphMesh();
 
    /// \return A pointer to a new GlsSerialMorphMesh object.
    static GLSGEN_GlsSerialMorphMesh_EXPORT DisplayObject* CreateInstance();
 
    //////////////////////////////////////////////////
    // Overridden base class methods
    //////////////////////////////////////////////////
 
    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;
 
    //////////////////////////////////////////////////
    // 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();
 
    /// \return The geometry for the given keyframe.
    /// \param index The index whose geometry is to be returned.
    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.
    /// \param index The keyframe index whose value is to be set.
    /// \param value The new value to set.
    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.
    /// \param value The new animation value to set.
    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:
    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
 
    /// \details The Keyframe_Data class. Stores data for one keyframe of animation.
    class Keyframe_Data
    {
    protected:
        DistiAttribDict* _attribDict; ///< The attribute dictionary for this object's members.
 
        /// Populates the attribute dictionary.
        void SetupAttribDict();
 
    public:
        GlsGeometry_Generic* _geometry; ///< An observing pointer to the mesh data values for this keyframe.
        float                _value;    ///< The key value for this keyframe.
 
        GLSGEN_GlsSerialMorphMesh_EXPORT Keyframe_Data();
 
        /// Copy constructor
        GLSGEN_GlsSerialMorphMesh_EXPORT Keyframe_Data( const Keyframe_Data& );
 
        GLSGEN_GlsSerialMorphMesh_EXPORT ~Keyframe_Data();
 
        /// Assignment operator
        /// \return The resulting object (this).
        GLSGEN_GlsSerialMorphMesh_EXPORT const Keyframe_Data& operator=( const Keyframe_Data& );
 
        /// Set the pointer to the mesh data values for this keyframe.
        /// \param geom The new mesh pointer to set.
        GLSGEN_GlsSerialMorphMesh_EXPORT void SetGeometry( GlsGeometry_Generic* geom );
 
        /// \return The pointer to the mesh data values for this keyframe.
        GLSGEN_GlsSerialMorphMesh_EXPORT GlsGeometry_Generic* GetGeometry();
 
        /// \return A reference to the attribute dictionary for this object.
        GLSGEN_GlsSerialMorphMesh_EXPORT DistiAttribDict& Attributes();
    };
 
    /// \details The KeyframeDataArray class. Holds multiple Keyframe_Data instances.
    class KeyframeDataArray
    {
    public:
        GlsSerialMorphMesh* _parentMesh; ///< Observing pointer to the GlsSerialMorphMesh object.
 
        GLSGEN_GlsSerialMorphMesh_EXPORT KeyframeDataArray()
            : _parentMesh( NULL )
        {}
 
        /// Read an item from the stream into a KeyFrame.
        /// \param index The index to write into.
        /// \param array The array to write into.
        /// \param instr The stream to read from.
        static void element_read_func( int index, KeyframeDataArray& array, std::istream& instr );
 
        /// Write an item from a KeyFrame into the stream.
        /// \param index The index to read from.
        /// \param array The array to read from.
        /// \param outstr The stream to write to.
        static void element_write_func( int index, KeyframeDataArray& array, std::ostream& outstr );
 
        /// Set the number of elements in the array, it will resize accordingly.
        /// \param count The new number of elements to resize to.
        void Count( unsigned count ) { _keyframes.Count( count ); }
 
        /// \return The number of elements in the array.
        unsigned Count() const { return _keyframes.Count(); }
 
        /// Clear all elements in the array.
        void Clear() { _keyframes.Clear(); }
 
        /// Index operator
        /// \param index The index of the item to return.
        /// \return A modifiable reference to the desired item.
        Keyframe_Data& operator[]( const std::size_t index ) { return _keyframes[ static_cast<unsigned>( index ) ]; }
 
        /// Index operator
        /// \param index The index of the item to return.
        /// \return A const reference to the desired item.
        const Keyframe_Data& operator[]( const std::size_t index ) const { return _keyframes[ static_cast<unsigned>( index ) ]; }
 
    private:
        DynamicArray<Keyframe_Data> _keyframes;
    };
 
    KeyframeDataArray _keyframes; ///< The list of animation keyframes.
 
    float _currentValue; ///< The current position in the animation.
    float _tension;      ///< The interpolation tension value.
 
    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; ///< If false, the mesh will be recalculated prior to next draw.
    GlsGeometry_Generic* _renderMesh;        ///< The mesh being morphed.
 
    /// 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