gls_rso_interface_impl.h

Go to the documentation of this file.

/*! \file
  \brief  Standard GL Studio implementation of the safe interface to version 2 RSOs (component side).
 
  \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_RSO_INTERFACE_IMPL_H
#define INCLUDED_GLS_RSO_INTERFACE_IMPL_H
 
#include "events.h"
#include "gls_include.h"
#include "gls_resources.h"
#ifdef GLES
#    include "rso_interface_es_2.h"
typedef disti::RSOInterfaceES2             RsoImplBaseClass;           ///< Typedef for the current RSO interface.
typedef disti::RSOInterfaceES1             RsoImplBaseInterface;       ///< Typedef for the original RSO interface.
typedef disti::RSOInterfaceES1             RsoImplMultiTouchInterface; ///< Typedef for the RSO interface version that introduced multitouch support.
typedef disti::RSOInterfaceES1::MatrixF    RSOMatrixT;                 ///< Typedef for the RSO interface matrix type.
typedef disti::RSOInterfaceES2::RSOPainter RSOPainterT;                ///< Typedef for the RSO interface painter type.
#else
#    include "rso_interface_5.h"
typedef disti::RSOInterface5             RsoImplBaseClass;           ///< Typedef for the current RSO interface.
typedef disti::RSOInterface1             RsoImplBaseInterface;       ///< Typedef for the original RSO interface.
typedef disti::RSOInterface3             RsoImplMultiTouchInterface; ///< Typedef for the RSO interface version that introduced multitouch support.
typedef disti::RSOInterface1::MatrixD    RSOMatrixT;                 ///< Typedef for the RSO interface matrix type.
typedef disti::RSOInterface5::RSOPainter RSOPainterT;                ///< Typedef for the RSO interface painter type.
#endif
 
namespace disti
{
class ComponentBase;
 
/** Wraps a GlsResourceFilter so it can be passed to the RSO Interface's GetResources call */
class RSOResourceFilterImpl : public RsoImplBaseInterface::ResourceFilter
{
private:
    GlsResourceFilter* _filter; ///< The underlying (runtime) filter wrapped by this interface.
 
public:
    /// Constructor
    /// \param filter The filter to wrap.
    GLS_EDITOR RSOResourceFilterImpl( GlsResourceFilter* filter ) { _filter = filter; }
 
    GLS_EDITOR ~RSOResourceFilterImpl() {}
 
    /// \return The current qualification level.
    int LevelsUp() const DISTI_METHOD_OVERRIDE { return _filter->LevelsUp(); }
 
    /// How many levels of qualification to show in the name.
    /// -1 means full qualification.
    /// Default: -1
    /// \param value The new qualification level to set.
    void LevelsUp( int value ) DISTI_METHOD_OVERRIDE { _filter->LevelsUp( value ); }
 
    /// \return The current levels of children to show.
    int GroupLevelsDown() const DISTI_METHOD_OVERRIDE { return _filter->GroupLevelsDown(); }
 
    /// How many levels of children to show.
    ///  0 means don't show any children properties
    /// -1 means all the way down.
    /// Default: -1
    /// \param value The new levels of children to show.
    void GroupLevelsDown( int value ) DISTI_METHOD_OVERRIDE { _filter->GroupLevelsDown( value ); }
 
    /// \return Whether or not names, or names and values should be returned.
    bool NamesOnly() const DISTI_METHOD_OVERRIDE { return _filter->NamesOnly(); }
 
    /// If true, only a list of names will be returned.
    /// Values will not be returned.
    /// The format changes to not include the ":".
    /// Default: false
    /// \param value The new name display flag to set.
    void NamesOnly( bool value ) DISTI_METHOD_OVERRIDE { _filter->NamesOnly( value ); }
 
    /// Manage the list of excluded attributes. Takes precedence over includes.
    /// \param str The new name to add to the exclude list.
    void AddExclude( const char* str ) DISTI_METHOD_OVERRIDE { _filter->AddExclude( str ); }
 
    /// Default: 0
    /// \return The number of entries in the exclude list.
    int ExcludeCount() const DISTI_METHOD_OVERRIDE { return _filter->ExcludeCount(); }
 
    /// \note Returns NULL if index >= ExcludeCount() or index < -1.
    /// \return The exclude name associated with the incoming index.
    /// \param index The index of the exclusion item to return.
    const char* GetExclude( int index ) const DISTI_METHOD_OVERRIDE { return _filter->GetExclude( index ); }
 
    /// Manage the list of included attributes.
    /// \param str The new name to add to the include list.
    void AddInclude( const char* str ) DISTI_METHOD_OVERRIDE { _filter->AddInclude( str ); }
 
    /// Default: 0
    /// \return The number of entries in the include list.
    int IncludeCount() const DISTI_METHOD_OVERRIDE { return _filter->IncludeCount(); }
 
    /// \note Returns NULL if index >= IncludeCount() or index < -1
    /// \return The include name associated with the incoming index.
    /// \param index The index of the inclusion item to return.
    const char* GetInclude( int index ) const DISTI_METHOD_OVERRIDE { return _filter->GetInclude( index ); }
 
    /// Check a name against the filters.
    /// Exclude list takes precedence.
    /// \param name The name of the item to test.
    /// \return Whether or not the name passes the filter (to be included in the returned results).
    bool PassFilter( const char* name ) const DISTI_METHOD_OVERRIDE { return _filter->PassFilter( name ); }
 
    /// Manage the stack of parent object names.
    /// \param parent The name of the item to add to the stack.
    void PushParentName( const char* parent ) { _filter->PushParentName( parent ); }
 
    /// Pop the parent object name stack.
    void PopParentName() { _filter->PopParentName(); }
 
    /// \return The number of entries in the parent name stack.
    unsigned int ParentNameCount() const { return _filter->ParentNameCount(); }
 
    /// \note Returns NULL if index >= ParentNameCount() or index < -1.
    /// \return The parent name associated with the incoming index.
    /// \param index The index of the parent name to return.
    const char* GetParentName( unsigned int index ) const { return _filter->GetParentName( index ); }
};
 
/** Implementation of RSOInterface. */
class GlsRSOInterfaceImpl : public RsoImplBaseClass
    , virtual public GlsPainter
{
protected:
    /// Reference to the component being wrapped.
    /// GlsRSOInterface1Impl will delete this object.
    ComponentBase* _component;
 
    /// The container's event handler.
    RsoImplBaseInterface::EmittedEventHandler* _emittedEventHandler;
 
    /// String to return from Resources methods.
    std::string _resourcesRetVal;
 
    // RSOInterface2 implementation
 
    typedef std::map<ResourceHandle, DistiAttributeBase*> ResourceHandleMap; ///< Typedef to associate external ids (ResourceHandle) with runtime attributes.
 
    ResourceHandleMap _resourceHandleMap;  ///< Mapping of external RSO interface resource ids with runtime attributes.
    ResourceHandle    _nextResourceHandle; ///< Used to track the highest id, to assign as the next resource handle.
    bool              _firstDraw;          ///< If true, this RSO has not been drawn yet.
 
    RSOPainterT* _painter; ///< Painter object that tracks the conditional rendering state.
    bool         _redraw;  ///< If true, this RSO should redraw itself on the next frame.
 
    /// \return The runtime attribute associated with the external handle.
    /// \param handle The external id for the desired runtime attribute.
    DistiAttributeBase& GetAttribute( ResourceHandle handle );
 
    /// Protected constructor - Call CreateInstance instead
    /// \param component The component object to wrap.
    GLS_EXPORT GlsRSOInterfaceImpl( ComponentBase* component );
 
    // Protected destructor - Call DeleteInstance instead
    virtual GLS_EXPORT ~GlsRSOInterfaceImpl();
 
public:
    /// \return An RSO interface wrapper for the incoming component object.
    /// \param component The component object to wrap.
    static GLS_EXPORT GlsRSOInterfaceImpl* CreateInstance( ComponentBase* component );
 
    /// Pass an event that was emitted from the component to the container.
    /// \param ev The event to pass into the container.
    /// \return Zero if the event was not handled, otherwise not zero.
    GLS_EXPORT int LiveComponentEventHandlerCb( ComponentBase*, disti::DisplayEvent* ev );
 
    // RSOInterface1 overrides
 
    GLS_EXPORT void Calculate( double time ) DISTI_METHOD_OVERRIDE;
    GLS_EXPORT RsoImplBaseInterface* CloneObject() DISTI_METHOD_OVERRIDE;
    GLS_EXPORT void                  DeleteInstance() DISTI_METHOD_OVERRIDE;
    GLS_EXPORT void                  Draw() DISTI_METHOD_OVERRIDE;
    GLS_EXPORT bool                  SetEmittedEventHandler( RsoImplBaseInterface::EmittedEventHandler* handler ) DISTI_METHOD_OVERRIDE;
    GLS_EXPORT bool                  GetBoundingSphere( RsoImplBaseInterface::Vector* center, float* radius ) DISTI_METHOD_OVERRIDE;
    GLS_EXPORT bool                  GetBoundingBox( RsoImplBaseInterface::Vector* min, RsoImplBaseInterface::Vector* max, const RSOMatrixT* transform = NULL ) DISTI_METHOD_OVERRIDE;
    GLS_EXPORT bool                  HandleInput( RsoImplBaseInterface::Event* lci1_ev ) DISTI_METHOD_OVERRIDE;
    GLS_EXPORT bool                  HandleMultiTouchInput( RsoImplMultiTouchInterface::MouseMultiTouchEvent* lci3_ev ) DISTI_METHOD_OVERRIDE;
 
    GLS_EXPORT bool Pick3D( const RsoImplBaseInterface::Vector& winLoc,
        const RsoImplBaseInterface::Vector&                     logicalCoords,
        float                                                   scale,
        const RsoImplBaseInterface::Vector&                     directionVector,
        RsoImplBaseInterface::Vector&                           collisionWinLoc,
        const RsoImplBaseInterface::OpenGLMatrices&             drawnMatrices ) DISTI_METHOD_OVERRIDE;
 
    GLS_EXPORT void        PreDraw( const RsoImplBaseInterface::OpenGLMatrices& parentMatrices, RsoImplBaseInterface::Culler& culler ) DISTI_METHOD_OVERRIDE;
    GLS_EXPORT void        SetResource( const char* resourceName, const char* resourceVal ) DISTI_METHOD_OVERRIDE;
    GLS_EXPORT const char* GetResource( const char* resourceName ) DISTI_METHOD_OVERRIDE;
    GLS_EXPORT const char* GetResources( RsoImplBaseInterface::ResourceFilter* filter = NULL ) DISTI_METHOD_OVERRIDE;
 
    // RSOInterface2 implementation
 
    ResourceHandle CreateResourceHandle( const char* resourceName ) DISTI_METHOD_OVERRIDE;
    void           ReleaseResourceHandle( ResourceHandle resourceHandle ) DISTI_METHOD_OVERRIDE;
    bool           IsResourceHandleValid( ResourceHandle resourceHandle ) DISTI_METHOD_OVERRIDE;
    void           SetResource( ResourceHandle resourceHandle, const char* resourceVal ) DISTI_METHOD_OVERRIDE;
    const char*    GetResource( ResourceHandle resourceHandle ) DISTI_METHOD_OVERRIDE;
    void           SetIntResource( const char* resourceName, long resourceVal ) DISTI_METHOD_OVERRIDE;
    long           GetIntResource( const char* resourceName ) DISTI_METHOD_OVERRIDE;
    void           SetIntResource( ResourceHandle resourceHandle, long resourceVal ) DISTI_METHOD_OVERRIDE;
    long           GetIntResource( ResourceHandle resourceHandle ) DISTI_METHOD_OVERRIDE;
    void           SetFloatResource( const char* resourceName, double resourceVal ) DISTI_METHOD_OVERRIDE;
    double         GetFloatResource( const char* resourceName ) DISTI_METHOD_OVERRIDE;
    void           SetFloatResource( ResourceHandle resourceHandle, double resourceVal ) DISTI_METHOD_OVERRIDE;
    double         GetFloatResource( ResourceHandle resourceHandle ) DISTI_METHOD_OVERRIDE;
    CallbackID     RegisterResourceObserver( ResourceHandle resourceHandle, ResourceObserver* obs ) DISTI_METHOD_OVERRIDE;
    void           UnregisterResourceObserver( ResourceHandle resourceHandle, CallbackID id ) DISTI_METHOD_OVERRIDE;
 
#ifdef GLES
    unsigned int GetMaxNumLights() DISTI_METHOD_OVERRIDE;
    void         SetLightData( unsigned int numLights, LightData* lightData ) DISTI_METHOD_OVERRIDE;
    unsigned int GetMaxClipPlanes() DISTI_METHOD_OVERRIDE;
    void         SetClipPlaneData( unsigned int numClipPlanes, float** equations ) DISTI_METHOD_OVERRIDE;
    void         SetMatrix( int type, const float* matrix ) DISTI_METHOD_OVERRIDE;
    void         SetDefaultOpenGLState() DISTI_METHOD_OVERRIDE;
#endif
 
    void GLS_EXPORT Invalidate() DISTI_METHOD_OVERRIDE;
    bool GLS_EXPORT IsInvalidated() const DISTI_METHOD_OVERRIDE;
    void GLS_EXPORT SetPainter( RSOPainterT* painter ) DISTI_METHOD_OVERRIDE;
};
 
} // end namespace disti
 
#endif