CEL: Crystal Entity Layer: celtool/stdparams.h Source File (CEL: Crystal Entity Layer Public API Reference)

| ## Public API Reference

- Main Page
- Classes
- Files

# celtool/stdparams.h

    00001 /*
    00002     Crystal Space Entity Layer
    00003     Copyright (C) 2003 by Jorrit Tyberghein
    00004
    00005     This library is free software; you can redistribute it and/or
    00006     modify it under the terms of the GNU Library General Public
    00007     License as published by the Free Software Foundation; either
    00008     version 2 of the License, or (at your option) any later version.
    00009
    00010     This library is distributed in the hope that it will be useful,
    00011     but WITHOUT ANY WARRANTY; without even the implied warranty of
    00012     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00013     Library General Public License for more details.
    00014
    00015     You should have received a copy of the GNU Library General Public
    00016     License along with this library; if not, write to the Free
    00017     Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
    00018 */
    00019
    00020 #ifndef __CEL_CELTOOL_PARAMS__
    00021 #define __CEL_CELTOOL_PARAMS__
    00022
    00023 #include "cstypes.h"
    00024 #include "csutil/scf.h"
    00025 #include "csutil/strhash.h"
    00026 #include "csutil/util.h"
    00027 #include "csutil/array.h"
    00028 #include "csutil/stringarray.h"
    00029 #include "behaviourlayer/behave.h"
    00030
    00031 // The following macros will set 'var' to the required variable and
    00032 // 'p_var' will be made to 0 if there is a failure.
    00033 #define CEL_FETCH_STRING_PAR(var,params,id) \
    00034   const celData* p_##var = params->GetParameter (id); \
    00035   const char* var = 0; \
    00036   if (p_##var && p_##var->type == CEL_DATA_STRING) { \
    00037     var = p_##var->value.s->GetData (); \
    00038   } else { p_##var = 0; }
    00039 #define CEL_FETCH_VECTOR3_PAR(var,params,id) \
    00040   const celData* p_##var = params->GetParameter (id); \
    00041   csVector3 var; \
    00042   if (p_##var && p_##var->type == CEL_DATA_VECTOR3) { \
    00043     var.Set (p_##var->value.v.x, p_##var->value.v.y, p_##var->value.v.z); \
    00044   } else { p_##var = 0; }
    00045 #define CEL_FETCH_FLOAT_PAR(var,params,id) \
    00046   const celData* p_##var = params->GetParameter (id); \
    00047   float var = 0.0f; \
    00048   if (p_##var) { \
    00049     if (p_##var->type == CEL_DATA_FLOAT) \
    00050       var = p_##var->value.f; \
    00051     else if (p_##var->type == CEL_DATA_LONG) \
    00052       var = float (p_##var->value.l); \
    00053     else p_##var = 0; \
    00054   }
    00055 #define CEL_FETCH_LONG_PAR(var,params,id) \
    00056   const celData* p_##var = params->GetParameter (id); \
    00057   long var = 0; \
    00058   if (p_##var) { \
    00059     if (p_##var->type == CEL_DATA_LONG) \
    00060       var = p_##var->value.l; \
    00061     else if (p_##var->type == CEL_DATA_FLOAT) \
    00062       var = long (p_##var->value.f); \
    00063     else p_##var = 0; \
    00064   }
    00065 #define CEL_FETCH_BOOL_PAR(var,params,id) \
    00066   const celData* p_##var = params->GetParameter (id); \
    00067   bool var = false; \
    00068   if (p_##var) { \
    00069     if (p_##var->type == CEL_DATA_BOOL) \
    00070       var = p_##var->value.bo; \
    00071     else if (p_##var->type == CEL_DATA_LONG) \
    00072     var =  ((p_##var->value.l)? true : false); \
    00073     else p_##var = 0; \
    00074   }
    00075
    00079 class celGenericParameterBlock : public iCelParameterBlock
    00080 {
    00081 private:
    00082   size_t count;
    00083   csStringID* ids;
    00084   celData* data;
    00085   char** names;
    00086
    00087 public:
    00088   celGenericParameterBlock (size_t count)
    00089   {
    00090     SCF_CONSTRUCT_IBASE (0);
    00091     celGenericParameterBlock::count = count;
    00092     ids = new csStringID[count];
    00093     data = new celData[count];
    00094     names = new char*[count];
    00095     memset (names, 0, sizeof (char*)*count);
    00096   }
    00097   virtual ~celGenericParameterBlock ()
    00098   {
    00099     delete[] ids;
    00100     delete[] data;
    00101     size_t i;
    00102     for (i = 0 ; i < count ; i++)
    00103       delete[] names[i];
    00104     delete[] names;
    00105     SCF_DESTRUCT_IBASE ();
    00106   }
    00107
    00108   void SetParameterDef (size_t idx, csStringID id, const char* parname)
    00109   {
    00110     ids[idx] = id;
    00111     delete[] names[idx];
    00112     names[idx] = csStrNew (parname);
    00113   }
    00114   celData& GetParameter (size_t idx) { return data[idx]; }
    00115
    00116   SCF_DECLARE_IBASE;
    00117
    00118   virtual size_t GetParameterCount () const { return count; }
    00119   virtual const char* GetParameter (size_t idx, csStringID& id,
    00120         celDataType& t) const
    00121   {
    00122     if (/*idx < 0 || */idx >= count)
    00123     {
    00124       id = csInvalidStringID;
    00125       t = CEL_DATA_NONE;
    00126       return 0;
    00127     }
    00128     id = ids[idx];
    00129     t = data[idx].type;
    00130     return names[idx];
    00131   }
    00132   virtual const celData* GetParameter (csStringID id) const
    00133   {
    00134     size_t i;
    00135     for (i = 0 ; i < count ; i++)
    00136       if (id == ids[i])
    00137         return &data[i];
    00138     return 0;
    00139   }
    00140   virtual const celData* GetParameterByIndex (size_t idx) const
    00141   {
    00142     return (idx >= count) ? 0 : &data[idx];
    00143   }
    00144 };
    00145
    00149 class celVariableParameterBlock : public iCelParameterBlock
    00150 {
    00151 private:
    00152   csArray<csStringID> ids;
    00153   csArray<celData> data;
    00154   csStringArray names;
    00155
    00156 public:
    00157   celVariableParameterBlock ()
    00158   {
    00159     SCF_CONSTRUCT_IBASE (0);
    00160   }
    00164   celVariableParameterBlock (iCelParameterBlock* other)
    00165   {
    00166     SCF_CONSTRUCT_IBASE (0);
    00167     if (other != 0)
    00168     {
    00169       const char* name = 0;
    00170       csStringID id;
    00171       celDataType type;
    00172       for (size_t idx = 0; idx < other->GetParameterCount (); idx++)
    00173       {
    00174         name = other->GetParameter (idx, id, type);
    00175         SetParameterDef (idx, id, name);
    00176         data.GetExtend (idx) = *other->GetParameter (id);
    00177       }
    00178     }
    00179   }
    00180   virtual ~celVariableParameterBlock ()
    00181   {
    00182     SCF_DESTRUCT_IBASE ();
    00183   }
    00184
    00185   void SetParameterDef (size_t idx, csStringID id, const char* parname)
    00186   {
    00187     ids.GetExtend (idx) = id;
    00188     if (idx >= names.Length ())
    00189       names.SetLength (idx+1);
    00190     names.Put (idx, parname);
    00191   }
    00192   celData& GetParameter (size_t idx) { return data.GetExtend (idx); }
    00193
    00194   SCF_DECLARE_IBASE;
    00195
    00196   virtual size_t GetParameterCount () const { return data.Length (); }
    00197   virtual const char* GetParameter (size_t idx, csStringID& id,
    00198         celDataType& t) const
    00199   {
    00200     if (/*idx < 0 || */idx >= data.Length ())
    00201     {
    00202       id = csInvalidStringID;
    00203       t = CEL_DATA_NONE;
    00204       return 0;
    00205     }
    00206     id = ids[idx];
    00207     t = data[idx].type;
    00208     return names[idx];
    00209   }
    00210   virtual const celData* GetParameter (csStringID id) const
    00211   {
    00212     size_t i;
    00213     for (i = 0 ; i < data.Length () ; i++)
    00214       if (id == ids[i])
    00215         return &data[i];
    00216     return 0;
    00217   }
    00218   virtual const celData* GetParameterByIndex (size_t idx) const
    00219   {
    00220     return (idx >= data.Length ()) ? 0 : &data[idx];
    00221   }
    00222 };
    00223
    00227 class celOneParameterBlock : public iCelParameterBlock
    00228 {
    00229 private:
    00230   csStringID id;
    00231   celData data;
    00232   char* name;
    00233
    00234 public:
    00235   celOneParameterBlock ()
    00236   {
    00237     SCF_CONSTRUCT_IBASE (0);
    00238     name = 0;
    00239   }
    00240   virtual ~celOneParameterBlock ()
    00241   {
    00242     delete[] name;
    00243     SCF_DESTRUCT_IBASE ();
    00244   }
    00245
    00246   void SetParameterDef (csStringID id, const char* parname)
    00247   {
    00248     celOneParameterBlock::id = id;
    00249     delete[] name;
    00250     name = csStrNew (parname);
    00251   }
    00252   celData& GetParameter (int) { return data; }
    00253
    00254   SCF_DECLARE_IBASE;
    00255
    00256   virtual size_t GetParameterCount () const { return 1; }
    00257   virtual const char* GetParameter (size_t idx, csStringID& id,
    00258         celDataType& t) const
    00259   {
    00260     if (idx != 0)
    00261     {
    00262       id = csInvalidStringID;
    00263       t = CEL_DATA_NONE;
    00264       return 0;
    00265     }
    00266     id = celOneParameterBlock::id;
    00267     t = data.type;
    00268     return name;
    00269   }
    00270   virtual const celData* GetParameter (csStringID id) const
    00271   {
    00272     if (id != celOneParameterBlock::id) return 0;
    00273     return &data;
    00274   }
    00275   virtual const celData* GetParameterByIndex (size_t idx) const
    00276   {
    00277     return (idx != 0) ? 0 : &data;
    00278   }
    00279 };
    00280
    00281 #endif // __CEL_CELTOOL_PARAMS__
    00282