Public API Reference

ivaria/engseq.h

Go to the documentation of this file.

/*
    Copyright (C) 2002 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., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_IVARIA_ENGSEQ_H__
#define __CS_IVARIA_ENGSEQ_H__

#include "csutil/scf.h"

struct iLight;
struct iMeshWrapper;
struct iObject;
struct iSector;
struct iSharedVariable;

class csBox3;
class csColor;
class csSphere;
class csVector3;

struct iSequence;
struct iSequenceManager;
struct iSequenceTrigger;
struct iSequenceWrapper;


enum
{
  CS_SEQUENCE_LIGHTCHANGE_NONE = 0,
  CS_SEQUENCE_LIGHTCHANGE_LESS = 1,
  CS_SEQUENCE_LIGHTCHANGE_GREATER = 2
};

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

  virtual iBase* GetValue (iBase* params = 0) const = 0;

  virtual bool IsConstant () const = 0;
};

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

  virtual size_t GetParameterCount () const = 0;

  virtual iBase* GetParameter (size_t idx) const = 0;

  virtual iBase* GetParameter (const char* name) const = 0;

  virtual size_t GetParameterIdx (const char* name) const = 0;

  virtual const char* GetParameterName (size_t idx) const = 0;

  virtual void AddParameter (const char* name, iBase* def_value = 0) = 0;

  virtual void SetParameter (size_t idx, iBase* value) = 0;

  virtual void SetParameter (const char* name, iBase* value) = 0;

  virtual csPtr<iParameterESM> CreateParameterESM (const char* name) = 0;
};

struct iSequenceWrapper : public virtual iBase
{
  SCF_INTERFACE (iSequenceWrapper, 0, 3, 0);
  virtual iObject* QueryObject () = 0;

  virtual iSequence* GetSequence () = 0;

  virtual iEngineSequenceParameters* CreateBaseParameterBlock () = 0;

  virtual iEngineSequenceParameters* GetBaseParameterBlock () = 0;

  virtual csPtr<iEngineSequenceParameters> CreateParameterBlock () = 0; 

  virtual void AddOperationSetVariable (csTicks time,
                iSharedVariable* var, float value, float dvalue = 0) = 0;

  virtual void AddOperationSetVariable (csTicks time,
                iSharedVariable* var, iSharedVariable* value,
                iSharedVariable* dvalue = 0) = 0;

  virtual void AddOperationSetVariable (csTicks time,
                iSharedVariable* var, const csVector3& v) = 0;

  virtual void AddOperationSetVariable (csTicks time,
                iSharedVariable* var, const csColor& c) = 0;

  virtual void AddOperationSetMaterial (csTicks time, iParameterESM* mesh,
                  iParameterESM* mat) = 0;

  virtual void AddOperationSetPolygonMaterial (csTicks time,
                  iParameterESM* polygon, iParameterESM* mat) = 0;

  virtual void AddOperationSetLight (csTicks time, iParameterESM* light,
                  const csColor& color) = 0;

  virtual void AddOperationFadeLight (csTicks time, iParameterESM* light,
                  const csColor& color, csTicks duration) = 0;

  virtual void AddOperationSetAmbient (csTicks time, iParameterESM* sector,
                  const csColor& color, iSharedVariable *colorvar) = 0;

  virtual void AddOperationFadeAmbient (csTicks time, iParameterESM* sector,
                  const csColor& color, csTicks duration) = 0;

  virtual void AddOperationRandomDelay (csTicks time, int min, int max) = 0;

  virtual void AddOperationSetMeshColor (csTicks time, iParameterESM* mesh,
                  const csColor& color) = 0;

  virtual void AddOperationFadeMeshColor (csTicks time, iParameterESM* mesh,
                  const csColor& color, csTicks duration) = 0;

  virtual void AddOperationSetFog (csTicks time, iParameterESM* sector,
                  const csColor& color, float density) = 0;

  virtual void AddOperationFadeFog (csTicks time, iParameterESM* sector,
                  const csColor& color, float density, csTicks duration) = 0;

  virtual void AddOperationRotateDuration (csTicks time, iParameterESM* mesh,
                int axis1, float tot_angle1,
                int axis2, float tot_angle2,
                int axis3, float tot_angle3,
                const csVector3& offset,
                csTicks duration) = 0;

  virtual void AddOperationMoveDuration (csTicks time, iParameterESM* mesh,
                const csVector3& offset, csTicks duration) = 0;

  virtual void AddOperationTriggerState (csTicks time,
                  iParameterESM* trigger, bool en) = 0;

  virtual void AddOperationCheckTrigger (csTicks time,
                  iParameterESM* trigger, csTicks delay) = 0;

  virtual void AddOperationTestTrigger (csTicks time,
                  iParameterESM* trigger,
                  iSequence* trueSequence,
                  iSequence* falseSequence) = 0;
};

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

  virtual iObject* QueryObject () = 0;

  virtual void AddConditionInSector (iSector* sector) = 0;

  virtual void AddConditionInSector (iSector* sector,
        const csBox3& box) = 0;

  virtual void AddConditionInSector (iSector* sector,
        const csSphere& sphere) = 0;

  virtual void AddConditionSectorVisible (iSector* sector) = 0;

  virtual void AddConditionMeshClick (iMeshWrapper* mesh) = 0;

  virtual void AddConditionLightChange (iLight *whichlight, 
                                        int oper, const csColor& color) = 0;

  virtual void AddConditionManual () = 0;

  virtual void SetEnabled (bool en) = 0;

  virtual bool IsEnabled () const = 0;

  virtual void ClearConditions () = 0;

  virtual void Trigger () = 0;

  virtual void SetParameters (iEngineSequenceParameters* params) = 0;

  virtual iEngineSequenceParameters* GetParameters () const = 0;

  virtual void FireSequence (csTicks delay, iSequenceWrapper* seq) = 0;

  virtual iSequenceWrapper* GetFiredSequence () = 0;

  virtual void TestConditions (csTicks delay) = 0;

  virtual bool CheckState () = 0;

  virtual void ForceFire (bool now = false) = 0;
};

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

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

struct iEngineSequenceManager : public virtual iBase
{
  SCF_INTERFACE (iEngineSequenceManager, 1, 0, 0);
 
  virtual iSequenceManager* GetSequenceManager () = 0;

  virtual csPtr<iParameterESM> CreateParameterESM (iBase* value) = 0;

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

  virtual csPtr<iSequenceTrigger> CreateTrigger (const char* name) = 0;

  virtual void RemoveTrigger (iSequenceTrigger* trigger) = 0;

  virtual void RemoveTriggers () = 0;

  virtual size_t GetTriggerCount () const = 0;

  virtual iSequenceTrigger* GetTrigger (size_t idx) const = 0;

  virtual iSequenceTrigger* FindTriggerByName (const char* name) const = 0;

  virtual bool FireTriggerByName (const char *name, bool now = false) const = 0;

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

  virtual csPtr<iSequenceWrapper> CreateSequence (const char* name) = 0;

  virtual void RemoveSequence (iSequenceWrapper* seq) = 0;

  virtual void RemoveSequences () = 0;

  virtual size_t GetSequenceCount () const = 0;

  virtual iSequenceWrapper* GetSequence (size_t idx) const = 0;

  virtual iSequenceWrapper* FindSequenceByName (const char* name) const = 0;

  virtual bool RunSequenceByName (const char *name,int delay) const = 0;

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

  virtual void FireTimedOperation (csTicks delta, csTicks duration,
        iSequenceTimedOperation* op, iBase* params = 0,
        uint sequence_id = 0) = 0;

  virtual void DestroyTimedOperations (uint sequence_id) = 0;

  //-----------------------------------------------------------------------
};

#endif // __CS_IVARIA_ENGSEQ_H__

---