physicallayer/pl.h

/*
    Crystal Space Entity Layer
    Copyright (C) 2001-2005 by Jorrit Tyberghein

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library 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.
*/

#ifndef __CEL_PL_PL__
#define __CEL_PL_PL__

#include "cstypes.h"
#include "csutil/scf.h"
#include "csutil/strset.h"
#include "csutil/ref.h"
#include "csutil/csstring.h"
#include "physicallayer/messaging.h"

struct iObject;
struct iCelEntity;
struct iCelEntityList;
struct iCelEntityIterator;
struct iCelDataBuffer;
struct iCelParameterBlock;
struct iCelPropertyClass;
struct iCelPropertyClassFactory;
struct iCelBlLayer;
struct iCelBehaviour;
struct iCelEntityTemplate;
struct iSector;
struct iCamera;
class csVector3;
class csBox3;
class csString;

#define CEL_EVENT_PRE 0
#define CEL_EVENT_VIEW 1
#define CEL_EVENT_POST 2

#define CEL_PROPCLASS_END (void*)0
#define CEL_PARAM_END (void*)0

typedef csHash<csStringFast<12>, csStringFast<12> > celEntityTemplateParams;

struct iCelEntityTracker;

struct iCelNewEntityCallback : public virtual iBase
{
  SCF_INTERFACE (iCelNewEntityCallback, 0, 0, 2);

  virtual void NewEntity (iCelEntity* entity) = 0;
};

struct iCelEntityRemoveCallback : public virtual iBase
{
  SCF_INTERFACE (iCelEntityRemoveCallback, 0, 0, 2);

  virtual void RemoveEntity (iCelEntity* entity) = 0;
};


struct iCelTimerListener : public virtual iBase
{
  SCF_INTERFACE (iCelTimerListener, 0, 0, 2);

  virtual void TickEveryFrame () = 0;

  virtual void TickOnce () = 0;
};

struct iCelPlLayer : public virtual iBase
{
  SCF_INTERFACE (iCelPlLayer, 0, 4, 2);

  virtual csPtr<iCelEntity> CreateEntity () = 0;

  virtual csPtr<iCelEntity> CreateEntityInScope (int scope) = 0;

  virtual csPtr<iCelEntity> CreateEntity (uint id) = 0;

  virtual csPtr<iCelEntity> CreateEntity (const char* entname,
        iCelBlLayer* bl, const char* bhname, ...) = 0;

  virtual void RemoveEntity (iCelEntity* entity) = 0;

  virtual void RemoveEntities () = 0;

  virtual iCelEntityTemplate* CreateEntityTemplate (const char* factname) = 0;

  virtual void RemoveEntityTemplate (iCelEntityTemplate* entfact) = 0;

  virtual void RemoveEntityTemplates () = 0;

  virtual iCelEntityTemplate* FindEntityTemplate (const char* factname) = 0;

  virtual size_t GetEntityTemplateCount () const = 0;

  virtual iCelEntityTemplate* GetEntityTemplate (size_t idx) const = 0;

  virtual iCelEntity* CreateEntity (iCelEntityTemplate* factory,
        const char* name, const celEntityTemplateParams& params) = 0;

  virtual iCelEntity* CreateEntity (iCelEntityTemplate* factory,
        const char* name, ...) = 0;

  virtual csPtr<iCelDataBuffer> CreateDataBuffer (long serialnr) = 0;

  virtual void AttachEntity (iObject* object, iCelEntity* entity) = 0;

  virtual void UnattachEntity (iObject* object, iCelEntity* entity) = 0;

  virtual iCelEntity* GetEntity (uint id) = 0;

  virtual size_t GetEntityCount () const = 0;

  virtual iCelEntity* GetEntityByIndex (size_t idx) const = 0;

  virtual iCelEntity* FindEntity (const char* name) = 0;

  virtual iCelBehaviour* GetBehaviour (uint id) = 0;

  virtual iCelEntity* FindAttachedEntity (iObject* object) = 0;

  virtual csPtr<iCelEntityList> FindNearbyEntities (iSector* sector,
        const csVector3& pos, float radius, bool do_invisible = false,
        csStringID cls = csInvalidStringID) = 0;

  virtual csPtr<iCelEntityList> FindNearbyEntities (iSector* sector,
        const csBox3& box, bool do_invisible = false,
        csStringID cls = csInvalidStringID) = 0;

  virtual csPtr<iCelEntityList> FindNearbyEntities (iSector* sector,
        const csVector3& start, const csVector3& end,
        bool do_invisible = false,
        csStringID cls = csInvalidStringID) = 0;

  virtual iCelEntity* GetHitEntity (iCamera* camera, int x, int y) = 0;

  virtual csPtr<iCelEntityList> CreateEmptyEntityList () = 0;

  virtual iCelEntityTracker* CreateEntityTracker (const char* name) = 0;

  virtual iCelEntityTracker* FindEntityTracker (const char* name) = 0;

  virtual void RemoveEntityTracker (iCelEntityTracker* tracker) = 0;

  virtual void SetEntityAddonAllowed (bool allow) = 0;

  virtual bool IsEntityAddonAllowed () const = 0;

  //-------------------------------------------------------------------------

  virtual bool LoadPropertyClassFactory (const char* plugin_id) = 0;

  virtual void RegisterPropertyClassFactory (iCelPropertyClassFactory* pf,
      const char* altname = 0) = 0;

  virtual void UnregisterPropertyClassFactory (
        iCelPropertyClassFactory* pf) = 0;

  virtual size_t GetPropertyClassFactoryCount () const = 0;

  virtual iCelPropertyClassFactory* GetPropertyClassFactory (size_t idx)
        const = 0;

  virtual iCelPropertyClassFactory* FindPropertyClassFactory (
        const char* name) const = 0;

  virtual iCelPropertyClass* CreatePropertyClass (iCelEntity* entity,
    const char* propname, const char* tagname = 0) = 0;

  virtual iCelPropertyClass* CreateTaggedPropertyClass
      (iCelEntity* entity, const char* propname, const char* tagname) = 0;

  //-------------------------------------------------------------------------

  virtual void RegisterBehaviourLayer (iCelBlLayer* bl) = 0;

  virtual void UnregisterBehaviourLayer (iCelBlLayer* bl) = 0;

  virtual size_t GetBehaviourLayerCount () const = 0;

  virtual iCelBlLayer* GetBehaviourLayer (size_t idx) const = 0;

  virtual iCelBlLayer* FindBehaviourLayer (const char* name) const = 0;

  //-------------------------------------------------------------------------

  virtual void Cache (iBase* object) = 0;

  virtual void Uncache (iBase* object) = 0;

  virtual void CleanCache () = 0;

  //-------------------------------------------------------------------------

  virtual csStringID FetchStringID (const char* str) = 0;

  virtual const char* FetchString (csStringID id) = 0;

  virtual void AddEntityRemoveCallback (iCelEntityRemoveCallback* clback) = 0;

  virtual void RemoveEntityRemoveCallback (
        iCelEntityRemoveCallback* clback) = 0;

  virtual void AddNewEntityCallback (iCelNewEntityCallback* clback) = 0;

  virtual void RemoveNewEntityCallback (iCelNewEntityCallback* clback) = 0;

  //-------------------------------------------------------------------------

  virtual void CallbackEveryFrame (iCelTimerListener* listener, int where) = 0;

  virtual void CallbackOnce (iCelTimerListener* listener, csTicks delta,
        int where) = 0;

  virtual void RemoveCallbackEveryFrame (iCelTimerListener* listener,
        int where) = 0;

  virtual void RemoveCallbackOnce (iCelTimerListener* listener, int where) = 0;

  virtual int AddScope (csString version, int size) = 0;

  /*
   * Get a list of all entities with a certain class assigned.
   * The list returned is always kept up to date by the physical layer so 
   * you can save the reference safely and keep using it.
   */
  virtual const csRef<iCelEntityList> GetClassEntitiesList (
        csStringID classid) = 0;

  /*
   * Send a message to all entities in an entity list. Returns the number
   * of entities that understood and handled the message.
   * Note that this version of SendMessage only sends a message to the
   * behaviour of the entity and not the channel. Use the new messaging
   * system for sending a message to the channel.
   * \deprecated Use SendMessage() for new message system instead.
   */
  CS_DEPRECATED_METHOD_MSG("Use SendMessage() for new message system instead.")
  virtual int SendMessage (iCelEntityList *entlist, const char* msgname,
        iCelParameterBlock* params, ...) = 0;

  /*
   * Send a message to all entities in an entity list. Returns the number
   * of entities that understood and handled the message.
   * Note that this version of SendMessage only sends a message to the
   * behaviour of the entity and not the channel. Use the new messaging
   * system for sending a message to the channel.
   * \deprecated Use SendMessage() for new message system instead.
   */
  CS_DEPRECATED_METHOD_MSG("Use SendMessage() for new message system instead.")
  virtual int SendMessageV (iCelEntityList *entlist, const char* msgname,
        iCelParameterBlock* params, va_list arg) = 0;

  /*
   * Send a message to all entities in an entity list. Returns the number
   * of entities that understood and handled the message.
   * Note that this version of SendMessage() sends a message to the channel
   * of the entity only and not the behaviour (unless the behaviour also
   * happens to subscribe to the channel).
   * \param msgid is the message ID.
   * \param sender is the sender from this message.
   * \param params contains the parameters for this message.
   * \param ret if this is not 0 then it can be used to collect information
   * from the receivers. If 0 then information from the receivers is simply
   * ignored.
   */
  virtual int SendMessage (const char* msgid, iMessageSender* sender,
      iCelEntityList *entlist, iCelParameterBlock* params,
      iCelDataArray* ret = 0) = 0;

  virtual iMessageSender* QueryMessageSender () = 0;
};

struct iCelEntityTracker : public virtual iBase
{
  SCF_INTERFACE (iCelEntityTracker, 0, 0, 3);

  virtual const char* GetName () const = 0;

  virtual bool AddEntity (iCelEntity* entity) = 0;

  virtual void RemoveEntity (iCelEntity* entity) = 0;

  virtual void RemoveEntities () = 0;

  virtual csPtr<iCelEntityList> FindNearbyEntities (iSector* sector,
        const csVector3& pos, float radius,
        csStringID cls = csInvalidStringID) = 0;

  virtual csPtr<iCelEntityIterator> GetIterator () = 0;

  virtual void AddEntities (iCelEntityTracker* tracker) = 0;

  virtual void RemoveEntities (iCelEntityTracker* tracker) = 0;
};

#endif // __CEL_PL_PL__