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 disti::RSOInterfaceES1             RsoImplBaseInterface;
typedef disti::RSOInterfaceES1             RsoImplMultiTouchInterface;
typedef disti::RSOInterfaceES1::MatrixF    RSOMatrixT;
typedef disti::RSOInterfaceES2::RSOPainter RSOPainterT;
#else
#    include "rso_interface_5.h"
typedef disti::RSOInterface5             RsoImplBaseClass;
typedef disti::RSOInterface1             RsoImplBaseInterface;
typedef disti::RSOInterface3             RsoImplMultiTouchInterface;
typedef disti::RSOInterface1::MatrixD    RSOMatrixT;
typedef disti::RSOInterface5::RSOPainter RSOPainterT;
#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;

public:
    GLS_EDITOR RSOResourceFilterImpl( GlsResourceFilter* filter ) { _filter = filter; }
    GLS_EDITOR ~RSOResourceFilterImpl() {}

    // How many levels of qualification to show in the name.
    // -1 means full qualification.
    // Default: 0  // TODO: confirm this default
    int  LevelsUp() const DISTI_METHOD_OVERRIDE { return _filter->LevelsUp(); }
    void LevelsUp( int value ) DISTI_METHOD_OVERRIDE { _filter->LevelsUp( value ); }

    // How many levels of children to show.
    //  0 means don't show any children properties
    // -1 means all the way down.
    // Default: -1
    int  GroupLevelsDown() const DISTI_METHOD_OVERRIDE { return _filter->GroupLevelsDown(); }
    void GroupLevelsDown( int value ) DISTI_METHOD_OVERRIDE { _filter->GroupLevelsDown( value ); }

    // If true, only a list of names will be returned.
    // Values will not be returned.
    // The format changes to not include the ":".
    // Default: false
    bool NamesOnly() const DISTI_METHOD_OVERRIDE { return _filter->NamesOnly(); }
    void NamesOnly( bool value ) DISTI_METHOD_OVERRIDE { _filter->NamesOnly( value ); }

    // Manage the list of excluded attributes
    void AddExclude( const char* str ) DISTI_METHOD_OVERRIDE { _filter->AddExclude( str ); }
    // Returns the number of entries in the exclude list.
    // Default: 0
    int ExcludeCount() const DISTI_METHOD_OVERRIDE { return _filter->ExcludeCount(); }
    // Returns NULL if index >= ExcludeCount() or index < -1
    const char* GetExclude( int index ) const DISTI_METHOD_OVERRIDE { return _filter->GetExclude( index ); }

    // Manage the list of included attributes
    void AddInclude( const char* str ) DISTI_METHOD_OVERRIDE { _filter->AddInclude( str ); }
    // Returns the number of entries in the include list.
    // Default: 0
    int IncludeCount() const DISTI_METHOD_OVERRIDE { return _filter->IncludeCount(); }
    // Returns NULL if index >= IncludeCount() or index < -1
    const char* GetInclude( int index ) const DISTI_METHOD_OVERRIDE { return _filter->GetInclude( index ); }

    // Check a name against the filters
    // Exclude list takes precedence
    bool PassFilter( const char* name ) const DISTI_METHOD_OVERRIDE { return _filter->PassFilter( name ); }

    // Manage the stack of parent object names
    void PushParentName( const char* parent ) { _filter->PushParentName( parent ); }
    void PopParentName() { _filter->PopParentName(); }
    // Returns the number of entries in the parent name stack
    unsigned int ParentNameCount() const { return _filter->ParentNameCount(); }
    // Returns NULL if index >= ParentNameCount() or index < -1
    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 containers event handler
    RsoImplBaseInterface::EmittedEventHandler* _emittedEventHandler;

    // string to return from Resources methods
    std::string _resourcesRetVal;

    // RSOInterface2 implementation

    typedef std::map<ResourceHandle, DistiAttributeBase*> ResourceHandleMap;

    ResourceHandleMap _resourceHandleMap;
    ResourceHandle    _nextResourceHandle;
    bool              _firstDraw;

    RSOPainterT* _painter;

    DistiAttributeBase& GetAttribute( ResourceHandle handle );

    // Protected constructor - Call CreateInstance instead
    GLS_EXPORT GlsRSOInterfaceImpl( ComponentBase* component );

    // Protected destructor - Call DeleteInstance instead
    virtual GLS_EXPORT ~GlsRSOInterfaceImpl();

public:
    static GLS_EXPORT GlsRSOInterfaceImpl* CreateInstance( ComponentBase* component );

    // Pass an event that was emitted from the component to the container
    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

    /** Calls Invalidate on the parent's painter, causing the scene to redraw in conditional rendering. */
    virtual void GLS_EXPORT Invalidate();

    /** Assigns a parent painter to this RSO which will be updated when any RSO child object causes invalidation. */
    virtual void GLS_EXPORT SetPainter( RSOPainterT* painter );
};

} // end namespace disti

#endif