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 );
 
    /// \copydoc RSOInterface1::Calculate
    GLS_EXPORT void Calculate( double time ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface1::CloneObject
    GLS_EXPORT RsoImplBaseInterface* CloneObject() DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface1::DeleteInstance
    GLS_EXPORT void DeleteInstance() DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface1::Draw
    GLS_EXPORT void Draw() DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface1::SetEmittedEventHandler
    GLS_EXPORT bool SetEmittedEventHandler( RsoImplBaseInterface::EmittedEventHandler* handler ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface1::GetBoundingSphere
    GLS_EXPORT bool GetBoundingSphere( RsoImplBaseInterface::Vector* center, float* radius ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface1::GetBoundingBox
    GLS_EXPORT bool GetBoundingBox( RsoImplBaseInterface::Vector* min, RsoImplBaseInterface::Vector* max, const RSOMatrixT* transform = NULL ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface1::HandleInput
    GLS_EXPORT bool HandleInput( RsoImplBaseInterface::Event* ev ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface3::HandleMultiTouchInput
    GLS_EXPORT bool HandleMultiTouchInput( RsoImplMultiTouchInterface::MouseMultiTouchEvent* ev ) DISTI_METHOD_OVERRIDE;
 
    /// \copydoc RSOInterface1::Pick3D
    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;
 
    /// \copydoc RSOInterface1::PreDraw
    GLS_EXPORT void PreDraw( const RsoImplBaseInterface::OpenGLMatrices& current, RsoImplBaseInterface::Culler& culler ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface1::SetResource
    GLS_EXPORT void SetResource( const char* resourceName, const char* resourceVal ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface1::GetResource
    GLS_EXPORT const char* GetResource( const char* resourceName ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface1::GetResources
    GLS_EXPORT const char* GetResources( RsoImplBaseInterface::ResourceFilter* filter = NULL ) DISTI_METHOD_OVERRIDE;
 
    /// \copydoc RSOInterface2::CreateResourceHandle
    ResourceHandle CreateResourceHandle( const char* resourceName ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface2::ReleaseResourceHandle
    void ReleaseResourceHandle( ResourceHandle resourceHandle ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface2::IsResourceHandleValid
    bool IsResourceHandleValid( ResourceHandle resourceHandle ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface2::SetResource
    void SetResource( ResourceHandle resourceHandle, const char* resourceVal ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface2::GetResource
    const char* GetResource( ResourceHandle resourceHandle ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface2::SetIntResource(const char*, long)
    void SetIntResource( const char* resourceName, long resourceVal ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface2::GetIntResource(const char*)
    long GetIntResource( const char* resourceName ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface2::SetIntResource(ResourceHandle, long)
    void SetIntResource( ResourceHandle handle, long resourceVal ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface2::GetIntResource(ResourceHandle)
    long GetIntResource( ResourceHandle resourceHandle ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface2::SetFloatResource(const char*, double)
    void SetFloatResource( const char* resourceName, double resourceVal ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface2::GetFloatResource(const char*)
    double GetFloatResource( const char* resourceName ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface2::SetFloatResource(ResourceHandle, double)
    void SetFloatResource( ResourceHandle handle, double resourceVal ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface2::GetFloatResource(ResourceHandle)
    double GetFloatResource( ResourceHandle resourceHandle ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface4::RegisterResourceObserver
    CallbackID RegisterResourceObserver( ResourceHandle resourceHandle, ResourceObserver* observer ) DISTI_METHOD_OVERRIDE;
    /// \copydoc RSOInterface4::UnregisterResourceObserver
    void UnregisterResourceObserver( ResourceHandle resourceHandle, CallbackID id ) DISTI_METHOD_OVERRIDE;
 
#ifdef GLES
    /// \return The maximum number of possible lights this platform supports.
    unsigned int GetMaxNumLights();
 
    /// Updates the state manager to set various light parameters.
    /// \param numLights The number of lights within the lightData.
    /// \param lightData An array of data where each element contains a collection of light properties.
    void SetLightData( unsigned int numLights, LightData* lightData );
 
    /// \return The maximum number of clip planes supported by the current driver.
    unsigned int GetMaxClipPlanes();
 
    /// Activates and updates the clip planes in the state manager.
    /// \param[in] numClipPlanes Determines how many planes are defined in the equations array.
    /// \param[in] equations An array of floats that define each plane where each equation is defined by four floats. equations[numClipPlanes][4].
    void SetClipPlaneData( unsigned int numClipPlanes, float** equations );
 
    /// Updates the state manager's top matrix based on the type.
    /// \param[in] type If it's equal to RSO_MODELVIEW_MATRIX, it'll load the model view matrix. If it's RSO_PROJECTION_MATRIX, then it'll retrieve the ProjectionMatrix instead.
    /// \param[in] matrix The matrix to push to the top of the stack.
    void SetMatrix( int type, const float* matrix );
 
    /// Restores the state manager back to its default state.
    void SetDefaultOpenGLState();
#endif
 
    /// \copydoc RSOInterface5::RSOPainter::Invalidate
    void GLS_EXPORT Invalidate() DISTI_METHOD_OVERRIDE;
 
    /// \copydoc GlsPainter::IsInvalidated
    bool GLS_EXPORT IsInvalidated() const DISTI_METHOD_OVERRIDE;
 
    /// \copydoc RSOInterface5::SetPainter
    void GLS_EXPORT SetPainter( RSOPainterT* painter ) DISTI_METHOD_OVERRIDE;
};
 
} // end namespace disti
 
#endif