Public API Reference

celtool/stdparams.h

/*
    Crystal Space Entity Layer
    Copyright (C) 2003 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_CELTOOL_PARAMS__
#define __CEL_CELTOOL_PARAMS__

#include "cstypes.h"
#include "csutil/scf.h"
#include "csutil/strhash.h"
#include "csutil/util.h"
#include "csutil/array.h"
#include "csutil/stringarray.h"
#include "csutil/refarr.h"
#include "behaviourlayer/behave.h"
#include "tools/expression.h"

#include "celtool/celtoolextern.h"

struct iObjectRegistry;
struct iDocumentNode;
struct iParameter;
struct iParameterManager;
struct iCelPlLayer;
class celVariableParameterBlock;

struct celParSpec
{
  celDataType type;

  csStringID id;

  csString value;

  celParSpec () { }
  celParSpec (celDataType type, csStringID id, const char* value) :
    type (type), id (id), value (value) { }
};

class CEL_CELTOOL_EXPORT celParameterTools
{
public:
  static csRef<iCelParameterBlock> ParseParams (iObjectRegistry* object_reg,
      iDocumentNode* node, ...);

  static bool WriteParams (iObjectRegistry* object_reg,
    iDocumentNode* node, iCelParameterBlock* params);

  static csString GetTypeName (celDataType type);

  static celDataType GetType (const char* name);

  static bool ToString (const celData& in, csString& out);

  static bool ToLong (const celData& in, long& out);

  static bool ToBool (const celData& in, bool& out);

  static bool ToFloat (const celData& in, float& out);

  static bool ToVector2 (const celData& in, csVector2& out);

  static bool ToVector3 (const celData& in, csVector3& out);

  static bool ToVector4 (const celData& in, csVector4& out);

  static bool ToColor (const celData& in, csColor& out);

  static bool ToColor4 (const celData& in, csColor4& out);

  static bool Convert (const celData& in, celDataType type, celData& out);

  static bool ParseParSpecBlock (iObjectRegistry* object_reg,
    iDocumentNode* node, csArray<celParSpec>& parameters);

  static bool WriteParSpecBlock (iObjectRegistry* object_reg,
    iDocumentNode* node, const csArray<celParSpec>& parameters);

  static csPtr<celVariableParameterBlock> GetParameterBlock (
        iParameterManager* pm,
        iCelParameterBlock* params,
        const csArray<celParSpec>& parameters,
        csRefArray<iParameter>& dyn_parameters);

  static bool FillParameterBlock (
        iCelPlLayer* pl,
        iCelParameterBlock* params,
        celVariableParameterBlock* act_params,
        const csArray<celParSpec>& parameters,
        const csRefArray<iParameter>& dyn_parameters);

  static csString GetDebugData (const celData* data);

  static void Dump (const char* title,
      iCelParameterBlock* params, iCelPlLayer* pl = 0);
};

struct celVariable
{
  csStringID id;
  celData data;

  celVariable () { }
  celVariable (csStringID id, const celData& data) : id (id), data (data) { }
};

class CEL_CELTOOL_EXPORT celVariableParameterBlock : public scfImplementation1<
        celVariableParameterBlock,iCelParameterBlock>
{
private:
  csArray<celVariable> vars;

public:
  celVariableParameterBlock (int capacity = 0) :
    scfImplementationType (this), vars (capacity)
  {
  }
  celVariableParameterBlock (iCelParameterBlock* other) :
    scfImplementationType (this)
  {
    if (other != 0)
    {
      celDataType type;
      for (size_t idx = 0; idx < other->GetParameterCount (); idx++)
      {
        AddParameter (other->GetParameterDef (idx, type), *other->GetParameterByIndex (idx));
      }
    }
  }
  virtual ~celVariableParameterBlock ()
  {
  }

  void Clear ()
  {
    vars.Empty ();
  }

  size_t AddParameter (csStringID id, const celData& data)
  {
    celVariable var (id, data);
    return vars.Push (var);
  }

  void RemoveParameter (csStringID id)
  {
    for (size_t i = 0 ; i < vars.GetSize () ; i++)
      if (vars[i].id == id)
      {
        vars.DeleteIndex (i);
        return;
      }
  }

  celData& AddParameter (csStringID id)
  {
    celVariable var;
    var.id = id;
    size_t idx = vars.Push (var);
    return vars[idx].data;
  }

  void SetParameterDef (size_t idx, csStringID id)
  {
    vars.GetExtend (idx).id = id;
  }
  celData& GetParameter (size_t idx)
  {
    return vars.GetExtend (idx).data;
  }

  virtual size_t GetParameterCount () const { return vars.GetSize (); }
  virtual csStringID GetParameterDef (size_t idx, celDataType& t) const
  {
    if (/*idx < 0 || */idx >= vars.GetSize ())
    {
      t = CEL_DATA_NONE;
      return csInvalidStringID;
    }
    t = vars[idx].data.type;
    return vars[idx].id;
  }
  virtual const celData* GetParameter (csStringID id) const
  {
    size_t i;
    for (i = 0 ; i < vars.GetSize () ; i++)
      if (id == vars[i].id)
        return &vars[i].data;
    return 0;
  }
  virtual const celData* GetParameterByIndex (size_t idx) const
  {
    return (idx >= vars.GetSize ()) ? 0 : &vars[idx].data;
  }

  celData* GetParameter (csStringID id)
  {
    size_t i;
    for (i = 0 ; i < vars.GetSize () ; i++)
      if (id == vars[i].id)
        return &vars[i].data;
    return 0;
  }

  void Merge (iCelParameterBlock* params);
};

class CEL_CELTOOL_EXPORT celEntityParameterBlock : public scfImplementation1<
        celEntityParameterBlock, iCelParameterBlock>
{
private:
  static csStringID thisID;
  celData thisData;
  iCelEntity* entity;

public:
  celEntityParameterBlock (iCelPlLayer* pl, iCelEntity* entity);
  virtual ~celEntityParameterBlock () { }

  virtual size_t GetParameterCount () const { return 1; }
  virtual csStringID GetParameterDef (size_t idx, celDataType& t) const
  {
    if (idx == 0) { t = CEL_DATA_ENTITY; return thisID; }
    return csInvalidStringID;
  }
  virtual const celData* GetParameter (csStringID id) const
  {
    if (id == thisID) return &thisData;
    return 0;
  }
  virtual const celData* GetParameterByIndex (size_t idx) const
  {
    if (idx == 0) return &thisData;
    return 0;
  }
};

class CEL_CELTOOL_EXPORT celOneParameterBlock : public scfImplementation1<
        celOneParameterBlock, iCelParameterBlock>
{
private:
  csStringID id;
  celData data;

public:
  celOneParameterBlock () : scfImplementationType (this)
  {
  }
  celOneParameterBlock (csStringID id, const char* str)
    : scfImplementationType (this)
  {
    SetParameterDef (id);
    GetParameter (0).Set (str);
  }
  virtual ~celOneParameterBlock ()
  {
  }

  void SetParameterDef (csStringID id)
  {
    celOneParameterBlock::id = id;
  }
  celData& GetParameter (int) { return data; }

  virtual size_t GetParameterCount () const { return 1; }
  virtual csStringID GetParameterDef (size_t idx, celDataType& t) const
  {
    if (idx != 0)
    {
      t = CEL_DATA_NONE;
      return csInvalidStringID;
    }
    t = data.type;
    return celOneParameterBlock::id;
  }
  virtual const celData* GetParameter (csStringID id) const
  {
    if (id != celOneParameterBlock::id) return 0;
    return &data;
  }
  virtual const celData* GetParameterByIndex (size_t idx) const
  {
    return (idx != 0) ? 0 : &data;
  }
};

class CEL_CELTOOL_EXPORT celCombineParameterBlock : public scfImplementation1<
        celCombineParameterBlock, iCelParameterBlock>
{
private:
  csRef<iCelParameterBlock> b1;
  csRef<iCelParameterBlock> b2;

public:
  celCombineParameterBlock (iCelParameterBlock* b1, iCelParameterBlock* b2)
    : scfImplementationType (this), b1 (b1), b2 (b2)
  {
  }
  virtual ~celCombineParameterBlock ()
  {
  }
  void SetParameterBlock1 (iCelParameterBlock* b1)
  {
    celCombineParameterBlock::b1 = b1;
  }
  void SetParameterBlock2 (iCelParameterBlock* b2)
  {
    celCombineParameterBlock::b2 = b2;
  }

  virtual size_t GetParameterCount () const
  {
    return b1->GetParameterCount () + (b2 ? b2->GetParameterCount () : 0);
  }
  virtual csStringID GetParameterDef (size_t idx, celDataType& t) const
  {
    if (idx < b1->GetParameterCount ())
    {
      return b1->GetParameterDef (idx, t);
    }
    else if (b2)
    {
      return b2->GetParameterDef (idx-b1->GetParameterCount (), t);
    }
    else
    {
      return csInvalidStringID;
    }
  }
  virtual const celData* GetParameter (csStringID id) const
  {
    const celData* data = b1->GetParameter (id);
    if (data) return data;
    if (!b2) return 0;
    return b2->GetParameter (id);
  }
  virtual const celData* GetParameterByIndex (size_t idx) const
  {
    if (idx < b1->GetParameterCount ())
    {
      return b1->GetParameterByIndex (idx);
    }
    else if (b2)
    {
      return b2->GetParameterByIndex (idx-b1->GetParameterCount ());
    }
    else
    {
      return 0;
    }
  }
};

struct celParameterMapping
{
  csStringID source;
  csStringID dest;
  csRef<iCelExpression> expression;
};

class CEL_CELTOOL_EXPORT celMappedParameterBlock : public celVariableParameterBlock
{
public:
  celMappedParameterBlock (iCelEntity* entity, iCelParameterBlock* params,
      const csArray<celParameterMapping>& mapping)
  {
    for (size_t mi = 0 ; mi < mapping.GetSize () ; mi++)
    {
      const celParameterMapping& m = mapping[mi];
      SetParameterDef (mi, m.dest);
      if (m.expression)
        m.expression->Execute (entity, GetParameter (mi), params);
      else
      {
        for (size_t i = 0 ; i < params->GetParameterCount () ; i++)
        {
          celDataType t;
          csStringID id = params->GetParameterDef (i, t);
          if (id == m.source)
          {
            GetParameter (mi) = *params->GetParameterByIndex (i);
            break;
          }
        }
      }
    }
    for (size_t i = 0 ; i < params->GetParameterCount () ; i++)
    {
      celDataType t;
      csStringID id = params->GetParameterDef (i, t);
      size_t idx = i+mapping.GetSize ();
      SetParameterDef (idx, id);
      const celData* data = params->GetParameterByIndex (i);
      if (data)
        GetParameter (idx) = *data;
    }
  }
  virtual ~celMappedParameterBlock ()
  {
  }
};

#endif // __CEL_CELTOOL_PARAMS__

---