[Home]	[About]
[Screenshots]	[Download]
[News]	[Community]
[Documentation]	[Manual]
[Bugs & Requests]	[Wiki]

/home/tetron/hack/vos/libs/vos/metaobjects/a3dl/actor.hh

Go to the documentation of this file.

/*
    This file is part of the Virtual Object System of
    the Interreality project (http://interreality.org).

    Copyright (C) 2003 Peter Amstutz

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA

    Peter Amstutz <http://www.interreality.org>
*/

#ifndef _ACTOR_HH_
#define _ACTOR_HH_

#include <vos/vos/vos.hh>

#include "a3dldefs.hh"

#ifndef A3DL_EXPORTS
IMPORT_METAOBJECT_FACTORIES(A3DL_Actor)
#endif

namespace A3DL
{
    class Actor;
    class ActionEvent;

    class A3DL_API ActionListener
    {
    public:
        virtual ~ActionListener() { }
        virtual void notifyActionChange(const ActionEvent& ae) = 0;
    };

    class A3DL_API ActionEvent : public VUtil::RefCounted
    {
    public:
        typedef enum { SetActionCycle, StartActionCycle, StopAction,
                       StopAllActions, DoActionOnce } EventType;
    private:
        EventType type;
        VUtil::vRef<Actor> actor;
        std::string action;
        float weight;
        float delayIn;
        float delayOut;
    public:
        ActionEvent(EventType et, Actor* actor,
                    const std::string& action = "",
                    float weight = 0.0,
                    float delayIn = 0.0,
                    float delayOut = 0.0);
        ~ActionEvent();

        EventType getEventType() const { return type; };
        const std::string& getAction() const { return action; };
        VUtil::vRef<Actor> getActor() const;
        float getWeight() const { return weight; }
        float getDelayIn() const { return delayIn; }
        float getDelayOut() const { return delayOut; }

        void deliverTo(ActionListener* al) { al->notifyActionChange(*this); }
    };

    class A3DL_API RemoteActionListener : public VOS::MetaObject, public ActionListener
    {
    public:
        RemoteActionListener(VOS::VobjectBase* superobject);
        virtual ~RemoteActionListener();

        virtual void notifyActionChange(const ActionEvent& ae);
    };

    class A3DL_API Actor : public VOS::MetaObject
    {
    protected:
        VUtil::ListenerBase<ActionListener, ActionEvent> actionListeners;

        std::map< std::string, VUtil::vRef<ActionEvent> > actions;

    public:
        Actor(VOS::VobjectBase* superobject);
        virtual ~Actor();

        virtual const std::string getVOSType();

        virtual void addActionListener(ActionListener* al);
        virtual void removeActionListener(ActionListener* al);

        virtual void setActionCycle(const std::string& action, float weight) = 0;
        virtual void startActionCycle(const std::string& action, float weight,
                                      float delay) = 0;
        virtual void stopAction(const std::string& action, float delay) = 0;
        virtual void stopAllActions() = 0;
        virtual void doActionOnce(const std::string& action, float delayIn,
                                  float delayOut) = 0;
        virtual bool isDoingAction(const std::string& action)
            { return actions.count(action) > 0; }
    };

    class A3DL_API LocalActor : public virtual Actor
    {
    public:
        LocalActor(VOS::VobjectBase* superobject);
        virtual ~LocalActor();

        static VOS::MetaObject* new_LocalActor(VOS::VobjectBase* superobject,
                                               const std::string& type);

        virtual void addActionListener(ActionListener* al);
        virtual void removeActionListener(ActionListener* al);

        virtual void setActionCycle(const std::string& action, float weight);
        virtual void startActionCycle(const std::string& action, float weight, float delay);
        virtual void stopAction(const std::string& action, float delay);
        virtual void stopAllActions();
        virtual void doActionOnce(const std::string& action, float delayIn, float delayOut);

        virtual void startListeningHandler(VOS::Message* m);
        virtual void stopListeningHandler(VOS::Message* m);
        virtual void actionChangeHandler(VOS::Message* m);
    };

    class A3DL_API RemoteActor : public virtual Actor
    {
    public:
        RemoteActor(VOS::VobjectBase* superobject);
        virtual ~RemoteActor();

        static VOS::MetaObject* new_RemoteActor(VOS::VobjectBase* superobject, const std::string& type);

        virtual void addActionListener(ActionListener* al);
        virtual void removeActionListener(ActionListener* al);

        virtual void setActionCycle(const std::string& action, float weight);
        virtual void startActionCycle(const std::string& action, float weight, float delay);
        virtual void stopAction(const std::string& action, float delay);
        virtual void stopAllActions();
        virtual void doActionOnce(const std::string& action, float delayIn, float delayOut);

        virtual void startListeningUpdateHandler(VOS::Message* m);
        virtual void stopListeningUpdateHandler(VOS::Message* m);
        virtual void actionChangeUpdateHandler(VOS::Message* m);
    };
};

#endif