gls_mutex_group.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::GlsMutexGroup 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 _GLS_MUTEX_GROUP_H
#define _GLS_MUTEX_GROUP_H
 
#include "gls_cpp_lang_support.h"
#include "group.h"
 
/// Provides support for creating DLLs.
#if( defined( GLSGEN_EXPORT_GLSMUTEXGROUP ) || defined( GLSGEN_IMPORT_GLSMUTEXGROUP ) || defined( GLS_EXPORT_GENERATED ) || defined( GLS_IMPORT_GENERATED ) ) \
    && defined( _MSC_VER )
#    if defined( GLSGEN_EXPORT_GLSMUTEXGROUP ) || defined( GLS_EXPORT_GENERATED )
#        define GLSGEN_GLSMUTEXGROUP_EXPORT __declspec( dllexport )
#    else
#        define GLSGEN_GLSMUTEXGROUP_EXPORT __declspec( dllimport )
#    endif
#else
#    define GLSGEN_GLSMUTEXGROUP_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////
 
/// Automatically link the runtime library plugin (on Windows).
#define LIB_BASE_NAME "gls_mutex_group"
#include "gls_auto_lib.h"
#undef LIB_BASE_NAME
 
namespace disti
{
// These are specific to GlsMutexGroup
static AttributeName MetaMutexState( "MutexState" );
static AttributeName MetaState( "State" );
static AttributeName MetaCalculateInvisibleStates( "CalculateInvisibleStates" );
static AttributeName MetaPickInvisibleStates( "PickInvisibleStates" );
static AttributeName MetaPredrawInvisibleStates( "PreDrawInvisibleStates" );
static AttributeName MetaInputDeviceBehavior( "InputDeviceBehavior" );
 
// SetValue enumerations
enum
{
    GLS_MUTEX_GROUP_STATE = GLS_LAST_INITIALIZER + 1,
    GLS_MUTEX_GROUP_CALC_INVISIBLE_STATES,
    GLS_MUTEX_GROUP_PICK_INVISIBLE_STATES,
    GLS_MUTEX_GROUP_PREDRAW_INVISIBLE_STATES,
    GLS_MUTEX_GROUP_INPUT_DEVICE_BEHAVIOR
};
 
#ifdef GLES
class GlsGloFileAttribute;
#endif
 
/** Runtime implementation of a GlsMutexGroup */
class GlsMutexGroup : public Group
{
private:
    GlsMutexGroup& operator=( const GlsMutexGroup& ) DISTI_SPECIAL_MEM_FUN_DELETE;
    GlsMutexGroup( const GlsMutexGroup& ) DISTI_SPECIAL_MEM_FUN_DELETE;
 
public:
    friend class GlsMutexGroupEditor;
    DISTI_DEPRECATED( "This identifier is forbidden by the C++ standard. Use BaseClass instead." )
    typedef Group _BaseClass; ///< Deprecated typedef for the base class.
    typedef Group BaseClass;  ///< Typedef for the base class.
 
    /** Create a new GlsMutexGroup.
      * \param generateInstance  Whether or not to generate an instance name
      * for this mutex group */
    GLSGEN_GLSMUTEXGROUP_EXPORT GlsMutexGroup( bool generateInstance = false );
 
    /// Copy constructor
    /// \param that The object to copy from.
    /// \param generateNames Whether or not to generate an instance name.
    GLSGEN_GLSMUTEXGROUP_EXPORT GlsMutexGroup( const GlsMutexGroup& that, const bool generateNames );
 
    /** Destructs a GlsMutexGroup object */
    virtual GLSGEN_GLSMUTEXGROUP_EXPORT ~GlsMutexGroup();
 
    /// \return A pointer to a new GlsMutexGroup object.
    static GLSGEN_GLSMUTEXGROUP_EXPORT DisplayObject* CreateInstance();
 
    virtual GLSGEN_GLSMUTEXGROUP_EXPORT void SetAvailableAttributes( unsigned int value ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSMUTEXGROUP_EXPORT DisplayObject* CloneObject( bool generateNames = false ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSMUTEXGROUP_EXPORT void           CopyProperties( DisplayObject* src ) DISTI_METHOD_OVERRIDE;
 
#ifndef GLES
    virtual GLSGEN_GLSMUTEXGROUP_EXPORT InterfaceListType* GetCppInterfaceDescription( InterfaceListType* addToThisList = NULL ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSMUTEXGROUP_EXPORT void               GetCppInterfaceDescriptionFree( InterfaceListType* array ) DISTI_METHOD_OVERRIDE;
#endif
 
    virtual GLSGEN_GLSMUTEXGROUP_EXPORT void Calculate( double time ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSMUTEXGROUP_EXPORT void PreDraw( const OpenGLMatrices& parentMatrices, Culler& culler ) DISTI_METHOD_OVERRIDE;
    virtual GLSGEN_GLSMUTEXGROUP_EXPORT void Draw() DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GLSMUTEXGROUP_EXPORT DisplayObject* Pick3D( const Vector& winLoc,
        const Vector&                                                        logicalCoords,
        float                                                                scale,
        const Vector&                                                        directionVector,
        Vector&                                                              collisionWinLoc /*Returned*/,
        const OpenGLMatrices&                                                drawnMatrices ) DISTI_METHOD_OVERRIDE;
 
    virtual GLSGEN_GLSMUTEXGROUP_EXPORT void SetValue( int spec, va_list& args ) DISTI_METHOD_OVERRIDE;
    GLSGEN_GLSMUTEXGROUP_EXPORT bool         IsVisibleInScene( const DisplayObject* obj = NULL ) const DISTI_METHOD_OVERRIDE;
 
    //////////////////////////////////////////////////
    // GlsMutexGroup specific operations
    //////////////////////////////////////////////////
 
    /** \return The mutex state of this group, -1 = none */
    GLSGEN_GLSMUTEXGROUP_EXPORT int MutexState() const { return _state; }
 
    /** Sets the mutex state of this group, -1 = none
      * \param state The new mutex state
      */
    GLSGEN_GLSMUTEXGROUP_EXPORT void MutexState( int state );
 
    // For legacy InputDevices
    /** \return The InputDevice state of this group, 1 to N */
    GLSGEN_GLSMUTEXGROUP_EXPORT int State() { return _state; }
 
    // For legacy InputDevices
    /** Sets the InputDevice state of this group, 1 to N.
      * \param state The new InputDevice state
      */
    GLSGEN_GLSMUTEXGROUP_EXPORT void State( int state );
 
    /** \return The calculate option of this group, true = calculate all objects, false = calculate active object only */
    GLSGEN_GLSMUTEXGROUP_EXPORT bool CalculateInvisibleStates() { return _calculateInvisibleStates; }
 
    /** Sets the calculate option of this group
      * \param value The new calculate option, true = calculate all objects, false = calculate active object only
      */
    GLSGEN_GLSMUTEXGROUP_EXPORT void CalculateInvisibleStates( bool value );
 
    /** \return The picking option of this group, true = pick all objects, false = pick active object only */
    GLSGEN_GLSMUTEXGROUP_EXPORT bool PickInvisibleStates() { return _pickInvisibleStates; }
 
    /** Sets the picking option of this group
      * \param value The new picking option, true = pick all objects, false = pick active object only
      */
    GLSGEN_GLSMUTEXGROUP_EXPORT void PickInvisibleStates( bool value );
 
    /** \return The predraw option of this group, true = predraw all objects, false = predraw active object only */
    GLSGEN_GLSMUTEXGROUP_EXPORT bool PreDrawInvisibleStates() { return _predrawInvisibleStates; }
 
    /** Sets the predraw option of this group
      * \param value The new predraw option, true = predraw all objects, false = predraw active object only
      */
    GLSGEN_GLSMUTEXGROUP_EXPORT void PreDrawInvisibleStates( bool value );
 
    /** \return Simulate the legacy InputDevice behavior, where state 0 is always shown and the state is one-based. */
    GLSGEN_GLSMUTEXGROUP_EXPORT bool InputDeviceBehavior() { return _inputDevice; }
 
    /** Sets the simulation of legacy InputDevice behavior, where state 0 is always shown
      * \param value True = InputDevice, False = MutexGroup
      */
    GLSGEN_GLSMUTEXGROUP_EXPORT void InputDeviceBehavior( bool value );
 
protected:
    /// \return True if the incoming state index is valid for this mutex group.
    /// \param state The index to test.
    bool ValidMutexState( const int state ) const
    {
        return ( state >= 0 && state < (int)( _objects.Count() ) );
    }
 
    /// \return True if the incoming legacy input device state index is valid for this mutex group.
    /// \param state The index to test.
    bool ValidInputDeviceState( const int state ) const
    {
        // 0 is not a valid state
        return ( state > 0 && state < (int)( _objects.Count() ) );
    }
 
    /// Helper routine for Pick3D, \see Pick3D
    /// \note Not normally called by users.
    /// \param winLoc          Device coordinates for the mouse click.  Z value should be set to 0 to ensure pick ray starts at near clip plane.
    /// \param logicalCoords   The start of the pick ray in logical coordinates.  Should be calculated from the winLoc using this->WindowToLogical(winLoc, logicalCoords, &directionVector).
    /// \param scale           Current window scale. Affects picking radius of outlines.  Initial value should typically be 1.0.
    /// \param directionVector The direction of the pick ray in logical coordinates.  Should be calculated from the winLoc using this->WindowToLogical(winLoc, logicalCoords, &directionVector).
    /// \param collisionWinLoc  Returns where the pick vector intersects the object that is hit in device coordinates.
    /// \param drawnMatrices   The matrices used to draw the object, including matrices set by parents that may have
    ///                        dynamically rotated, translated or scaled this object.  Initial value should typically be a default OpenGLMatrices() object.
    /// \return  The object that was hit, or NULL if no object hit.
    DisplayObject* Pick3DUtil( const Vector& winLoc,
        const Vector&                        logicalCoords,
        float                                scale,
        const Vector&                        directionVector,
        Vector&                              collisionWinLoc /*Returned*/,
        const OpenGLMatrices&                drawnMatrices );
 
#ifdef GLES
    /** Set a single attribute from the GLO file.
      * \param data The attribute to set and its associated data.
      */
    virtual GLSGEN_GLSMUTEXGROUP_EXPORT void SetFromGloData( GlsGloFileAttribute& data ) DISTI_METHOD_OVERRIDE;
#endif
 
    bool _inputDevice; ///< True = InputDevice functionality (state 0 always showing)
                       ///< False = MutexGroup functionality
 
    int _state; ///< The index of the currently active object in the group, 0 to N, anything else = none
 
    bool _calculateInvisibleStates; ///< Whether or not to call calculate on invisible states.
    bool _pickInvisibleStates;      ///< Whether or not to call pick on invisible states.
    bool _predrawInvisibleStates;   ///< Whether or not to call predraw on invisible states.
};
 
} // namespace disti
 
#endif