moMoldeoObject.h

Ir a la documentación de este archivo.

/*******************************************************************************

                                moMoldeoObject.h

  ****************************************************************************
  *                                                                          *
  *   This source is free software; you can redistribute it and/or modify    *
  *   it under the terms of the GNU General Public License as published by   *
  *   the Free Software Foundation; either version 2 of the License, or      *
  *  (at your option) any later version.                                    *
  *                                                                          *
  *   This code is distributed in the hope that it will be useful, but       *
  *   WITHOUT ANY WARRANTY; without even the implied warranty of             *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU      *
  *   General Public License for more details.                               *
  *                                                                          *
  *   A copy of the GNU General Public License is available on the World     *
  *   Wide Web at <http://www.gnu.org/copyleft/gpl.html>. You can also       *
  *   obtain it by writing to the Free Software Foundation,                  *
  *   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.         *
  *                                                                          *
  ****************************************************************************

  Copyright(C) 2006 Fabricio Costa

  Authors:
  Fabricio Costa


*******************************************************************************/

#ifndef __MO_MOLDEOOBJECT_H__
#define __MO_MOLDEOOBJECT_H__

#include "moTypes.h"
#include "moText.h"
#include "moAbstract.h"
#include "moScript.h"
#include "moEventList.h"
#include "moConfig.h"
#include "moArray.h"
#include "moConnectors.h"

#define MO_INLET_NAME 0
#define MO_INLET_TYPE 1

#define MO_OUTLET_NAME 0
#define MO_OUTLET_TYPE 1
#define MO_OUTLET_INLETS_OFFSET 2

#define MO_IODEVICE_KEYBOARD 0
#define MO_IODEVICE_MOUSE 1
#define MO_IODEVICE_MIDI 2
#define MO_IODEVICE_MIXER 3
#define MO_IODEVICE_JOYSTICK 4
#define MO_IODEVICE_NET_TCP_IN 5
#define MO_IODEVICE_NET_UDP_IN 6
#define MO_IODEVICE_NET_TCP_OUT 7
#define MO_IODEVICE_NET_UDP_OUT 8
#define MO_IODEVICE_LIVE 9
#define MO_IODEVICE_TRACKER 10

#define MO_IODEVICE_TABLET 11
#define MO_IODEVICE_TOUCH 12
#define MO_IODEVICE_CONSOLE 20
#define MO_IODEVICE_ANY -1

#define MO_MOLDEOOBJECTS_OFFSET_ID  100
#define MO_MOLDEOSCENEOBJECTS_OFFSET_ID 10000

#define MO_MOLDEOOBJECT_UNDEFINED_ID -1

#define RenderMan()   m_pResourceManager->GetRenderMan()
#define TextureMan()  m_pResourceManager->GetTextureMan()
#define DataMan() m_pResourceManager->GetDataMan()
#define VideoMan()  m_pResourceManager->GetVideoMan()
#define SoundMan()  m_pResourceManager->GetSoundMan()
#define GLMan()  m_pResourceManager->GetGLMan()


class moResourceManager;


class LIBMOLDEO_API moMobIndex : public moAbstract {

    public:

        moMobIndex() { m_paramindex = -1; m_valueindex = -1; }

    moMobIndex( const moMobIndex &src) {
      (*this) = src;
    }

        moMobIndex( MOint p_paramindex, MOint p_valueindex ) {
          m_paramindex = p_paramindex; m_valueindex = p_valueindex;
    }

    moMobIndex& operator = ( const moMobIndex &src) {
       m_paramindex = src.m_paramindex;
       m_valueindex = src.m_valueindex;
       return(*this);
    }

    void SetParamIndex( MOint p_paramindex) { m_paramindex = p_paramindex;}

    void SetValueIndex( MOint p_valueindex ) { m_valueindex = p_valueindex; }

        virtual ~moMobIndex() {}

        MOint GetParamIndex() const { return m_paramindex; }

        MOint GetValueIndex() const { return m_valueindex; }

    private:
        MOint   m_paramindex;
        MOint   m_valueindex;

};


class LIBMOLDEO_API moMobDefinition
{
    public:

        moMobDefinition();
    moMobDefinition(const moMobDefinition& mb);


        moMobDefinition( const moText& p_name,
                      const moText& p_configname,
                      moMoldeoObjectType p_type,
                      const moText& p_labelname,
                      MOint p_moldeoid = -1,
                      const moMobIndex& p_MobIndex = moMobIndex(-1,-1) ) {
        m_Name = p_name;
        m_ConfigName = p_configname;
        m_Type = p_type;
        m_MoldeoLabelName = p_labelname;
        m_MoldeoId = p_moldeoid;
        m_MobIndex = p_MobIndex;
        m_MoldeoFatherId = -1;
        m_MoldeoFatherLabelName = "";
        m_Activate = true;
        m_KeyName = "";
    }

    virtual ~moMobDefinition();

    moMobDefinition& operator = ( const moMobDefinition& mb);

    inline bool    IsValid() const {
        bool result;
        result = ( m_Type != MO_OBJECT_UNDEFINED
                && m_MoldeoId!=-1
                /*
                && m_MobIndex.GetParamIndex()!=-1
                && m_MobIndex.GetValueIndex()!=-1
                  */ );
        return result;
    }

    const moText& GetName() const;

    void SetName( const moText& p_name );

    const moText& GetConfigName() const;

    void SetConfigName( const moText& p_configname );

    moMoldeoObjectType GetType() const;

    moMoldeoObjectType GetStrToType( const moText& p_Str = moText("default") ) const;

    moText GetTypeStr() const;

    static moText GetTypeToClass( moMoldeoObjectType p_Type = MO_OBJECT_UNDEFINED );

    static moText GetTypeToName( moMoldeoObjectType p_Type = MO_OBJECT_UNDEFINED );

    void SetType( moMoldeoObjectType p_type );

    const moMobIndex& GetMobIndex() const;

    void SetLabelName( const moText& p_labelname );
    const moText& GetLabelName() const;


    void SetMoldeoId( MOint p_moldeoid );


    MOint GetMoldeoId() const;


    MOint GetMoldeoFatherId() const {
      return m_MoldeoFatherId;
    }


    void SetMoldeoFatherId( MOint p_moldeoid ) {
        m_MoldeoFatherId  = p_moldeoid;
    }

    void SetFatherLabelName( const moText& p_labelname );
    const moText& GetFatherLabelName() const {
      return m_MoldeoFatherLabelName;
    }

    void SetKeyName( const moText& p_keyname );
    const moText& GetKeyName() const {
      return m_KeyName;
    }



    const moText& GetDescription() const {
      return m_Description;
    }


    void SetDescription( const moText& p_Description );

    void SetConsoleParamIndex( MOint p_paramindex );

    void SetConsoleValueIndex(MOint p_valueindex);



    bool GetActivate() const {
      return m_Activate;
    }


    void SetActivate( bool p_activate );


    const moText& ToJSON();

    protected:

      MOint                 m_MoldeoFatherId;
      moText                          m_MoldeoFatherLabelName;

      MOint                         m_MoldeoId; 
      moText                          m_MoldeoLabelName; 

      moMoldeoObjectType        m_Type; 
      moText                          m_Name; 
      moText                          m_ConfigName; 
      moText                m_Description;

      moMobIndex            m_MobIndex; 

      moText                m_KeyName;
      bool                  m_Activate;
      moText                m_FullJSON;
};

/*doesnt work with GCC 4.7.1*/
LIBMOLDEO_API moMoldeoObjectType moGetStrType( const moText& p_Str );


class LIBMOLDEO_API moMobState : public moAbstract {

    public:

        moMobState();
        virtual ~moMobState();
        moMobState( const moMobState& p_MobState );
        moMobState& operator = ( const moMobState& src);

        void Activate();
        void Deactivate();

        bool Activated() const;

        void Select();
        void Unselect();

        bool Selected()  const;
        const moText& ToJSON();

    protected:
        MOswitch m_Activated;
        MOswitch m_Selected;
        moText m_FullJSON;

};



class LIBMOLDEO_API moMoldeoObject : public moAbstract, public moScript
{
    public:
        moMoldeoObject();

        moMoldeoObject( moMoldeoObjectType p_type);
        virtual ~moMoldeoObject();

        virtual MOboolean Init();

        virtual MOboolean Init( moResourceManager* p_pResources );

        virtual MOboolean Finish();


        virtual MOboolean CreateConnectors();

        virtual MOboolean UpdateConnectors();


        virtual MOboolean RefreshValue( moParam& param, int value_index );

        virtual MOboolean ResolveValue( moParam& param, int value_index, bool p_refresh=false );


        virtual void Update( moEventList* p_EventList );//checks p_EventList for events/messages

        void    SetResourceManager( moResourceManager* p_pResourceManager );//set the pointer to the resource manager for this object

        moResourceManager* GetResourceManager();//return pointer to the resource manager of this object

        MOint   GetId() const;

        void    SetId( MOint    p_id );

        moMoldeoObjectType  GetType() const;

        void    SetType( moMoldeoObjectType p_type );

        void    SetName( const moText& p_name ) { m_MobDefinition.SetName(p_name); }

        void    SetLabelName( const moText& p_labelname ) { m_MobDefinition.SetLabelName(p_labelname); }

        void    SetKeyName( const moText& p_keyname ) { m_MobDefinition.SetKeyName(p_keyname); }

        const moText&   GetKeyName() const { return m_MobDefinition.GetKeyName(); }

        const moText&   GetName() const { return m_MobDefinition.GetName(); }

        const moText&   GetLabelName() const { return m_MobDefinition.GetLabelName(); }

        moConfig*   GetConfig() { return &m_Config; }

        void  SyncConnections();

        virtual int Save( const moText& p_save_filename = moText("") );

        void    SetConfigName( const moText& p_configname );

        const moText&   GetConfigName() const { return m_MobDefinition.GetConfigName(); }


        const moText& GetDescription() const {
            return m_MobDefinition.GetDescription();
        }



        void SetDescription( const moText& p_Description ) {
            m_MobDefinition.SetDescription(p_Description);

        }

        const moMobDefinition&     GetMobDefinition() const {
            return m_MobDefinition;
        }

        void     SetMobDefinition( const moMobDefinition& p_MobDef ) {
            m_MobDefinition = p_MobDef;
        }


        virtual moConfigDefinition * GetDefinition( moConfigDefinition *p_configdefinition = NULL );//retreive the parameters definition of the Moldeo Object

        moOutlets* GetOutlets();

        moInlets* GetInlets();

        MOint GetInletIndex( moText p_connector_name ) const;

        MOint GetOutletIndex( moText p_connector_name ) const;

        virtual void RegisterFunctions();

        virtual int ScriptCalling(moLuaVirtualMachine& vm, int iFunctionNumber);

        virtual void HandleReturns(moLuaVirtualMachine& vm, const char *strFunc);


        virtual const moMobState& GetState() const;

        virtual bool SetState( const moMobState& p_MobState );


        virtual void Activate();

        virtual void Deactivate();

        virtual bool Activated() const;

        virtual void Select();

        virtual void Unselect();

        virtual bool Selected() const;

        virtual void SetConsoleParamIndex( MOint p_paramindex ) {
            m_MobDefinition.SetConsoleParamIndex(p_paramindex);

        }

        virtual void SetConsoleValueIndex(MOint p_valueindex) {
            m_MobDefinition.SetConsoleValueIndex(p_valueindex);
        }

        virtual const moText& ToJSON();

    protected:

        moText    m_FullJSON;

        virtual void LoadDefinition();

    virtual void ScriptExeInit();
        virtual void ScriptExeRun();
        virtual void ScriptExeUpdate();
        virtual void ScriptExeFinish();

        void SetScript( const moText& p_script );


        moText  m_Script;


        moMobDefinition         m_MobDefinition;

        moMobState              m_MobState;

        moConfig                m_Config;

        moResourceManager*      m_pResourceManager;

        moOutlets               m_Outlets;

        moInlets                m_Inlets;

    moInlet*        InletScreenWidth;
    moInlet*        InletScreenHeight;
    moInlet*        InletTimeabs;
    moInlet*        InletPreconfig;

        MOboolean m_bConnectorsLoaded;

    int __iscript;

    protected:


        int luaPushDebugString(moLuaVirtualMachine& vm);

        int luaGetResourceManager(moLuaVirtualMachine& vm);

        int luaSetPreconf(moLuaVirtualMachine& vm);
        int luaGetPreconf(moLuaVirtualMachine& vm);

        int luaGetParamIndex(moLuaVirtualMachine& vm);

        int luaGetCurrentValue(moLuaVirtualMachine& vm);
        int luaSetCurrentValue(moLuaVirtualMachine& vm);
        int luaGetValuesCount(moLuaVirtualMachine& vm);

        int luaGetInletIndex(moLuaVirtualMachine& vm);
        int luaGetInletData(moLuaVirtualMachine& vm);
        int luaSetInletData(moLuaVirtualMachine& vm);

#ifdef USE_TUIO
        int luaGetTuioSystem(moLuaVirtualMachine& vm);
        int luaGetTuioCursorCount(moLuaVirtualMachine& vm);
        int luaGetTuioCursor(moLuaVirtualMachine& vm);
        int luaGetTuioObjectCount(moLuaVirtualMachine& vm);
        int luaGetTuioObject(moLuaVirtualMachine& vm);
#endif

        int luaGetTrackerSystemData(moLuaVirtualMachine& vm);
        int luaGetTrackerFeaturesCount(moLuaVirtualMachine& vm);
        int luaGetTrackerValidFeatures(moLuaVirtualMachine& vm);
        int luaGetTrackerFeature(moLuaVirtualMachine& vm);
        int luaGetTrackerVariance(moLuaVirtualMachine& vm);
        int luaGetTrackerBarycenter(moLuaVirtualMachine& vm);
        int luaGetTrackerAcceleration(moLuaVirtualMachine& vm);
        int luaGetTrackerVelocity(moLuaVirtualMachine& vm);
        int luaGetTrackerZone(moLuaVirtualMachine& vm);

        int luaGetTrackerHistory(moLuaVirtualMachine& vm); 
        int luaStartTrackerHistory(moLuaVirtualMachine& vm); 
        int luaPauseTrackerHistory(moLuaVirtualMachine& vm);
        int luaContinueTrackerHistory(moLuaVirtualMachine& vm);
        int luaStopTrackerHistory(moLuaVirtualMachine& vm);
        int luaGetHistoryRecord(moLuaVirtualMachine& vm); 
        int luaGetHistoryBarycenter(moLuaVirtualMachine& vm);
        int luaGetHistoryVariance(moLuaVirtualMachine& vm);
        int luaGetHistoryBounding(moLuaVirtualMachine& vm);
        int luaGetHistoryAverage(moLuaVirtualMachine& vm);
        int luaGetHistoryMinMax(moLuaVirtualMachine& vm);

};

moDeclareExportedDynamicArray( moMoldeoObject*, moMoldeoObjects);

#include "moResourceManager.h"

#endif