core/code/system/f_resourcemgr.cpp

   1 /*
   2     fegdk: FE Game Development Kit
   3     Copyright (C) 2001-2008 Alexey "waker" Yakovenko
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Library General Public
   7     License as published by the Free Software Foundation; either
   8     version 2 of the License, or (at your option) any later version.
   9
  10     This library is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13     Library General Public License for more details.
  14
  15     You should have received a copy of the GNU Library General Public
  16     License along with this library; if not, write to the Free
  17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18
  19     Alexey Yakovenko
  20     waker@users.sourceforge.net
  21 */
  22
  23 #include "pch.h"
  24 #include "config.h"
  25 #include "f_texture.h"
  26 #include "f_fontft.h"
  27 #include "f_material.h"
  28 #include "f_animation.h"
  29 #include "f_model.h"
  30 #if HAVE_LIBCG
  31 #include "f_cgshader.h"
  32 #endif
  33 #include "f_ps14shader.h"
  34 #include "f_effect.h"
  35 #include "f_resourcemgr.h"
  36 #include "f_error.h"
  37 #include "f_engine.h"
  38
  39 namespace fe
  40 {
  41
  42         resourceMgr::resourceMgr (void)
  43         {
  44                 setName ("resource mgr");
  45         }
  46
  47         resourceMgr::~resourceMgr (void)
  48         {
  49         }
  50
  51         resource <texture> *resourceMgr::getTextureMgr (void)
  52         {
  53                 return &mTextureMgr;
  54         }
  55
  56         resource <material> *resourceMgr::getMaterialMgr (void)
  57         {
  58                 return &mMaterialMgr;
  59         }
  60
  61         resource <fontFT> *resourceMgr::getFontFTMgr (void)
  62         {
  63                 return &mFontMgr;
  64         }
  65
  66         resource <sceneObject> *resourceMgr::getModelMgr (void)
  67         {
  68                 return &mModelMgr;
  69         }
  70
  71         resource <animation> *resourceMgr::getAnimationMgr (void)
  72         {
  73                 return &mAnimationMgr;
  74         }
  75
  76         resource <cgShader> *resourceMgr::getCGShaderMgr (void)
  77         {
  78 #if HAVE_LIBCG
  79                 return &mCGShaderMgr;
  80 #else
  81                 return NULL;
  82 #endif
  83         }
  84
  85         resource <ps14Shader> *resourceMgr::getPS14ShaderMgr (void)
  86         {
  87                 return &mPS14ShaderMgr;
  88         }
  89
  90         resource <effect> *resourceMgr::getEffectMgr (void)
  91         {
  92                 return &mEffectMgr;
  93         }
  94
  95         texture* resourceMgr::createTexture (const char *name)
  96         {
  97                 texture *t = mTextureMgr.create (name);
  98                 if (!t)
  99                         return mTextureMgr.create ("textures/common/notfound.png");
 100                 return t;
 101         }
 102
 103         texture* resourceMgr::createTexture (charParser &parser)
 104         {
 105                 texture *t = mTextureMgr.create (parser);
 106                 if (!t)
 107                         return mTextureMgr.create ("textures/common/notfound.png");
 108                 return t;
 109         }
 110
 111         material* resourceMgr::createMaterial (const char *name)
 112         {
 113                 return mMaterialMgr.create (name);
 114         }
 115
 116         material* resourceMgr::createMaterial (charParser &parser)
 117         {
 118                 return mMaterialMgr.create (parser);
 119         }
 120
 121         fontFT* resourceMgr::createFontFT (const char *name)
 122         {
 123                 return mFontMgr.create (name);
 124         }
 125
 126         fontFT* resourceMgr::createFontFT (charParser &parser)
 127         {
 128                 return mFontMgr.create (parser);
 129         }
 130
 131         struct mtlBlock
 132         {
 133                 std::vector <materialPtr>       mMtlList;
 134
 135                 void add (const materialPtr &mtl) { mMtlList.push_back (mtl); }
 136                 int numMtls (void) const { return (int)mMtlList.size (); }
 137                 materialPtr getMtl (int i) { return mMtlList[i]; }
 138                 void load (file *f)
 139                 {
 140                         uint32 sp;
 141                         f->readUINT32 (&sp, 1);
 142                         if (!sp)
 143                                 return;
 144                         mMtlList.resize (sp);
 145                         for (uint32 i = 0; i < sp; i++)
 146                         {
 147                                 uchar ln;
 148                                 f->read (&ln, 1);
 149                                 char *str = new char[ln+1];
 150                                 f->read (str, ln);
 151                                 str[ln]=0;
 152                                 mMtlList[i] = g_engine->getResourceMgr ()->createMaterial (str);
 153                                 delete[] str;
 154                         }
 155                 }
 156         };
 157
 158         static void loadModelFromFile (file *f, int majorver, int minorver, sceneObject *node, mtlBlock *mtls)
 159         {
 160                 if (minorver >= 2)
 161                 {
 162                         char nsz;
 163                         f->read (&nsz, sizeof (char));
 164                         if (nsz)
 165                         {
 166                                 char nm[100];
 167                                 f->read (nm, nsz);
 168                                 nm[nsz] = 0;
 169                                 node->setName (nm);
 170                         }
 171                 }
 172
 173                 uint32 sp;
 174
 175                 // matrix
 176                 matrix4 mtx;
 177                 f->readMatrix4 (&mtx, 1);
 178                 matrix4 worldMtx = node->getParent () ? mtx * node->getParent ()->getWorldMatrix() : mtx;
 179                 node->setRelativeMatrix (mtx);
 180                 node->setWorldMatrix (worldMtx);
 181
 182                 model *mdl = NULL;
 183                 // ok, try mesh subsets
 184                 f->readUINT32 (&sp, 1);
 185                 if (sp)
 186                 {
 187                         mdl = new model ();
 188                         renderable *rend = new renderable (mdl);
 189                         node->attachRenderable (rend);
 190                         mdl->loadMesh (f, majorver, minorver, mtls->mMtlList, sp, rend);
 191                 }
 192                 else
 193                 {
 194                         // skip mesh flags
 195
 196                         // tangents
 197                         uchar tangents;
 198                         f->read (&tangents, sizeof (uchar));
 199
 200                         // lightmaps
 201                         uchar lightmaps = 0;
 202                         if (minorver >= 1)
 203                                 f->read (&lightmaps, sizeof(uchar));
 204
 205                         // numverts
 206                         f->readUINT32 (&sp, 1);
 207
 208                         // numfaces
 209                         f->readUINT32 (&sp, 1);
 210
 211                         // old version animation flag
 212                         if (minorver < 2)
 213                         {
 214                                 uchar b;
 215                                 f->read (&b, sizeof (b));
 216                         }
 217                 }
 218
 219                 // load children
 220                 f->readUINT32 (&sp, 1);
 221                 int nChildren = sp;
 222
 223                 for (uint32 i = 0; i < nChildren; i++)
 224                 {
 225                         sceneObject *c = new sceneObject (node);
 226                         loadModelFromFile (f, majorver, minorver, c, mtls);
 227                         node->addChild (c);
 228                 }
 229         }
 230
 231         static sceneObject *loadModelFromFile (const char *fname)
 232         {
 233                 // sceneobject must be created for each node
 234                 // model must be created only where mesh exists
 235                 file *f = g_engine->getFileSystem ()->openFile (fname, FS_MODE_READ);
 236
 237                 int majorver = 1;
 238                 int minorver = 0;
 239                 sceneObject *node = new sceneObject (NULL);
 240                 // read magic
 241                 char mgc[10];
 242                 f->read( mgc, 9 );
 243                 mgc[9] = 0;
 244                 // for now i support only 1.1
 245                 if (!strcmp (mgc, "FEMDL0101"))
 246                 {
 247                         majorver = 1;
 248                         minorver = 1;
 249                 }
 250                 else if (!strcmp (mgc, "FEMDL0102"))
 251                 {
 252                         majorver = 1;
 253                         minorver = 2;
 254                 }
 255                 else
 256                         sys_error("Invalid model file signature (%s).\n", f->name());
 257
 258                 // load materials
 259                 mtlBlock mtls;
 260                 mtls.load (f);
 261
 262                 loadModelFromFile (f, majorver, minorver, node, &mtls);
 263                 f->close ();
 264
 265                 return node;
 266         }
 267
 268         sceneObject* resourceMgr::createModel (const char *name, animContainer *anim)
 269         {
 270                 // model is created specially, cause we need instancing
 271                 sceneObject *obj = mModelMgr.getResource (name);
 272                 if (!obj)
 273                 {
 274                         // load template
 275                         obj = loadModelFromFile (name);
 276 //                      model *mdl = new model ();
 277 //                      obj = mdl->load (name);
 278                         mModelMgr.addResource (name, obj);
 279                 }
 280
 281                 // create from template
 282                 sceneObject *newModel = obj->getNewInstance ();
 283                 if (anim)
 284                         newModel->initAnimData (anim);
 285                 return newModel;
 286         }
 287
 288         sceneObject* resourceMgr::createModel (charParser &parser)
 289         {
 290                 return NULL;
 291         }
 292
 293         animation* resourceMgr::createAnimation (const char *name)
 294         {
 295                 return mAnimationMgr.create (name);
 296         }
 297
 298         animation* resourceMgr::createAnimation (charParser &parser)
 299         {
 300                 return mAnimationMgr.create (parser);
 301         }
 302
 303 #ifdef HAVE_LIBCG
 304         cgShader* resourceMgr::createCGShader (const char *name)
 305         {
 306                 return mCGShaderMgr.create (name);
 307         }
 308
 309         cgShader* resourceMgr::createCGShader (charParser &parser)
 310         {
 311                 return mCGShaderMgr.create (parser);
 312         }
 313 #endif
 314
 315         ps14Shader* resourceMgr::createPS14Shader (const char *name)
 316         {
 317                 return mPS14ShaderMgr.create (name);
 318         }
 319         ps14Shader* resourceMgr::createPS14Shader (charParser &parser)
 320         {
 321                 return mPS14ShaderMgr.create (parser);
 322         }
 323
 324         effect* resourceMgr::createEffect (const char *name)
 325         {
 326                 return mEffectMgr.create (name);
 327         }
 328
 329         effect* resourceMgr::createEffect (charParser &parser)
 330         {
 331                 return mEffectMgr.create (parser);
 332         }
 333 }