tools/sequences.h

/*
    Crystal Space Entity Layer
    Copyright (C) 2004-2006 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_SEQUENCES__
#define __CEL_SEQUENCES__

#include "behaviourlayer/behave.h"
#include "tools/parameters.h"


//-------------------------------------------------------------------------
// Sequence operations
//-------------------------------------------------------------------------

struct iSeqOp : public virtual iBase
{
  SCF_INTERFACE (iSeqOp, 0, 0, 1);
  
  virtual void Init (iCelParameterBlock* params) = 0;

  virtual bool Load (iCelDataBuffer* databuf) = 0;

  virtual void Save (iCelDataBuffer* databuf) = 0;

  virtual void Do (float time, iCelParameterBlock* params) = 0;
};

struct iSeqOpFactory : public virtual iBase
{
  SCF_INTERFACE (iSeqOpFactory, 0, 0, 1);

  virtual csPtr<iSeqOp> CreateSeqOp (const celParams& params) = 0;

  virtual bool Load (iDocumentNode* node) = 0;
};

struct iSeqOpType : public virtual iBase
{
  SCF_INTERFACE (iSeqOpType, 0, 0, 1);

  virtual const char* GetName () const = 0;
  
  virtual csPtr<iSeqOpFactory> CreateSeqOpFactory () = 0;
};

struct iCelSequence;

struct iCelSequenceCallback : public virtual iBase
{
  SCF_INTERFACE (iCelSequenceCallback, 0, 0, 1);

  virtual void SequenceFinished (iCelSequence* sequence) = 0;
};

struct iCelSequence : public virtual iBase
{
  SCF_INTERFACE (iCelSequence, 0, 0, 1);

  virtual const char* GetName () const = 0;

  virtual void SaveState (iCelDataBuffer* databuf) = 0;
  virtual bool LoadState (iCelDataBuffer* databuf) = 0;

  virtual bool Start (csTicks delay, iCelParameterBlock* params) = 0;

  virtual void Finish () = 0;

  virtual void Abort () = 0;

  virtual bool IsRunning () = 0;

  virtual void AddSequenceCallback (iCelSequenceCallback* cb) = 0;
  virtual void RemoveSequenceCallback (iCelSequenceCallback* cb) = 0;
};

struct iCelSequenceFactory : public virtual iBase
{
  SCF_INTERFACE (iCelSequenceFactory, 0, 0, 1);

  virtual csPtr<iCelSequence> CreateSequence (const celParams& params) = 0;

  virtual const char* GetName () const = 0;
  
  virtual void SetName (const char* name) = 0;

  virtual void AddSeqOpFactory (iSeqOpFactory* seqopfact,
        const char* duration) = 0;

  virtual void AddDelay (const char* delay) = 0;
};

struct iCelSequenceFactoryGenerator : public virtual iBase
{
  SCF_INTERFACE (iCelSequenceFactoryGenerator, 0, 0, 1);

  virtual csPtr<iCelSequenceFactory> CreateSequenceFactory () = 0;
};

//-------------------------------------------------------------------------
// Specific sequence operation implementations.
//-------------------------------------------------------------------------

struct iDebugPrintSeqOpFactory : public virtual iBase
{
  SCF_INTERFACE (iDebugPrintSeqOpFactory, 0, 0, 1);

  virtual void SetMessageParameter (const char* msg) = 0;
};


struct iLightSeqOpFactory : public virtual iBase
{
  SCF_INTERFACE (iLightSeqOpFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity, const char* tag = 0) = 0;

  virtual void SetRelColorParameter (const char* red, const char* green,
        const char* blue) = 0;

  virtual void SetAbsColorParameter (const char* red, const char* green,
        const char* blue) = 0;
};

struct iMovePathSeqOpFactory : public virtual iBase
{
  SCF_INTERFACE (iMovePathSeqOpFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity, const char* tag = 0) = 0;

  virtual void AddPathNode (const char* sectorname, const char* node,
        const char* time) = 0;
};

struct iPropertySeqOpFactory : public virtual iBase
{
  SCF_INTERFACE (iPropertySeqOpFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity) = 0;

  virtual void SetPCParameter (const char* pc, const char* tag = 0) = 0;

  virtual void SetPropertyParameter (const char* property_name) = 0;

  virtual void SetFloatParameter (const char* pfloat) = 0;

  virtual void SetLongParameter (const char* plong) = 0;

  virtual void SetVector2Parameter (const char* vectorx, 
        const char* vectory) = 0;

  virtual void SetVector3Parameter (const char* vectorx, const char* vectory,
        const char* vectorz) = 0;

  virtual void SetRelative (bool is_relative) = 0;
};


struct iTransformSeqOpFactory : public virtual iBase
{
  SCF_INTERFACE (iTransformSeqOpFactory, 0, 0, 1);

  virtual void SetEntityParameter (const char* entity, const char* tag = 0) = 0;

  virtual void SetVectorParameter (const char* vectorx, const char* vectory,
        const char* vectorz) = 0;

  virtual void SetRotationParameter (int rot_axis, const char* rot_angle) = 0;
};
//-------------------------------------------------------------------------

#define CEL_DECLARE_SEQOPTYPE(name,id)                                  \
class cel##name##SeqOpType : public scfImplementation2<                 \
        cel##name##SeqOpType,iSeqOpType,iComponent>                             \
{                                                                       \
public:                                                                 \
  iObjectRegistry* object_reg;                                          \
  csWeakRef<iCelPlLayer> pl;                                            \
  cel##name##SeqOpType (iBase* parent);                 \
  virtual ~cel##name##SeqOpType () { }                                  \
  virtual bool Initialize (iObjectRegistry*)    ;               \
  virtual const char* GetName () const { return id; }                   \
  virtual csPtr<iSeqOpFactory> CreateSeqOpFactory ();           \
};

#define CEL_IMPLEMENT_SEQOPTYPE(name)                                   \
cel##name##SeqOpType::cel##name##SeqOpType (                            \
        iBase* parent) : scfImplementationType (this, parent),  \
        object_reg(0)                                                                                   \
{                                                                                                                       \
}                                                                                                                       \
bool cel##name##SeqOpType::Initialize (                                 \
        iObjectRegistry* object_reg)                                                    \
{                                                                                                                       \
  cel##name##SeqOpType::object_reg = object_reg;                        \
  pl = csQueryRegistry<iCelPlLayer> (object_reg);                       \
  return true;                                                                                          \
}                                                                       \
csPtr<iSeqOpFactory> cel##name##SeqOpType::CreateSeqOpFactory ()        \
{                                                                       \
  cel##name##SeqOpFactory* fact = new cel##name##SeqOpFactory (this);   \
  return fact;                                                          \
}


#endif // __CEL_SEQUENCES__