tools/fgp/f_expmodel.h

   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 #ifndef __F_EXPMODEL_H
  24 #define __F_EXPMODEL_H
  25
  26 #include "f_string.h"
  27 #include "f_parser.h"
  28 #include "f_math.h"
  29 #include "f_sceneobject.h"
  30 #include "f_animation.h"
  31 #include "f_model.h"
  32 #include "f_helpers.h"
  33
  34 namespace fe
  35 {
  36
  37         enum objClassID
  38         {
  39                 UNKNOWN_OBJECT_CLASS_ID,
  40                 TRI_OBJECT_CLASS_ID,
  41                 ENTITY_OBJECT_CLASS_ID,
  42                 REF_OBJECT_CLASS_ID,
  43                 DUMMY_OBJECT_CLASS_ID
  44         };
  45
  46         struct expFace
  47         {
  48                 int v[3];
  49         };
  50
  51         class expScene;
  52
  53         class expObject : public baseObject
  54         {
  55
  56         public:
  57                 typedef std::vector < smartPtr <expObject> >    childrenList;
  58
  59         protected:
  60
  61                 float                                           mFrameRate;
  62                 expObject*      mpParent;
  63                 matrix4         mMatrix;
  64                 matrix4         mWorldMatrix;
  65
  66                 childrenList mChildren;
  67
  68                 objClassID      mClassID;
  69
  70                 bool baseLoad (charParser &p, const char *fname);
  71                 void recalcWorldTransforms (void);
  72
  73                 virtual ~expObject (void)
  74                 {
  75                         mChildren.clear ();
  76                 }
  77
  78         public:
  79
  80                 // constructor & destructor
  81                 expObject (expObject *parent);
  82
  83                 objClassID getClassID (void) const { return mClassID; }
  84
  85                 const matrix4 &getMatrix (void) const
  86                 {
  87                         return mMatrix;
  88                 }
  89
  90                 const matrix4 &getWorldMatrix (void) const
  91                 {
  92                         return mWorldMatrix;
  93                 }
  94
  95                 void setMatrix (const matrix4 &m);
  96                 void setWorldMatrix (const matrix4 &m);
  97                 virtual void load (charParser &p, const char *fname) = 0;
  98                 virtual void render (const smartPtr <expScene> &scene) const;
  99                 const childrenList&     children (void) const { return mChildren; }
 100                 void addChild (const smartPtr <expObject> &child);
 101                 void removeChild (const smartPtr <expObject> &child);
 102                 void setParent (expObject *parent);
 103                 smartPtr <expObject> getParent (void) { return mpParent; }
 104
 105                 float   frameRate (void) const { return mFrameRate; }
 106         };
 107         typedef smartPtr <expObject> expObjectPtr;
 108
 109         class expScene : public baseObject
 110         {
 111
 112         public:
 113
 114                 typedef std::vector <materialPtr>       materialList;
 115
 116         protected:
 117
 118                 expObjectPtr    mpSceneRoot;
 119                 std::vector <cStr>      mMtlNameList;
 120                 std::vector <cStr>      mBoneList;
 121                 materialList mMtlList;
 122
 123                 void                    load (charParser &p);
 124                 expObjectPtr    loadObject (charParser &p);
 125
 126                 ~expScene (void);
 127
 128         public:
 129
 130                 expScene (void);
 131
 132                 int load (const char *fname);
 133
 134                 expObjectPtr    getRootNode (void) { return mpSceneRoot; }
 135
 136                 std::vector <cStr>& mtlNameList (void) { return mMtlNameList; }
 137                 materialList& mtlList (void) { return mMtlList; }
 138
 139                 virtual void render (void);
 140         };
 141
 142         typedef smartPtr <expScene> expScenePtr;
 143
 144         class expTriObject : public expObject
 145         {
 146
 147         protected:
 148
 149                 std::vector <vector3>   mVerts;
 150                 std::vector <vector3>   mColors;
 151                 std::vector <vector3>   mNormals;
 152                 std::vector <vector2>   mTexCoords;
 153                 std::vector <vector2>   mLightmapTexCoords;
 154                 std::vector <expFace>   mFaces;
 155                 std::vector <expFace>   mColorFaces;
 156                 std::vector <expFace>   mNormalFaces;
 157                 std::vector <expFace>   mTexCoordFaces;
 158                 std::vector <expFace>   mLightmapTexCoordFaces;
 159                 std::vector <int>               mMtlIndex;
 160                 std::vector <vector3> mTangents;
 161                 std::vector <vector3> mBinormals;
 162                 std::vector <expFace> mTSFaces;
 163
 164                 struct boneInfl {
 165                         int bone;
 166                         float weight;
 167                 };
 168                 typedef std::vector <boneInfl>  vertexInfl;
 169                 std::vector <vertexInfl>        mVertexInfluences;
 170
 171                 void                                            flush (expScene *scene, int mtl, int firstFace, int numFaces);
 172
 173                 ~expTriObject (void) {}
 174
 175         public:
 176
 177                 expTriObject (expObject *parent);
 178
 179                 virtual void load (charParser &p, const char *fname);
 180                 void transformIntoWorldSpace (void);
 181
 182                 std::vector<vector3>&   verts () { return mVerts; }
 183                 std::vector<vector3>&   colors () { return mColors; }
 184                 std::vector<vector3>&   normals () { return mNormals; }
 185                 std::vector<vector2>&   texCoords () { return mTexCoords; }
 186                 std::vector<vector2>&   lightmapTexCoords () { return mLightmapTexCoords; }
 187                 std::vector<expFace>&   faces () { return mFaces; }
 188                 std::vector<expFace>&   colorFaces () { return mColorFaces; }
 189                 std::vector<expFace>&   normalFaces () { return mNormalFaces; }
 190                 std::vector<expFace>&   texCoordFaces () { return mTexCoordFaces; }
 191                 std::vector<expFace>&   lightmapTexCoordFaces () { return mLightmapTexCoordFaces; }
 192                 std::vector<int>&       mtlIndex () { return mMtlIndex; }
 193                 std::vector<vector3>&   tangents () { return mTangents; }
 194                 std::vector<vector3>&   binormals () { return mBinormals; }
 195                 std::vector<expFace>&   tsFaces () { return mTSFaces; }
 196
 197                 const std::vector<vector3>&     verts () const { return mVerts; }
 198                 const std::vector<vector3>&     colors () const { return mColors; }
 199                 const std::vector<vector3>&     normals () const { return mNormals; }
 200                 const std::vector<vector2>&     texCoords () const { return mTexCoords; }
 201                 const std::vector<vector2>&     lightmapTexCoords () const { return mLightmapTexCoords; }
 202                 const std::vector<expFace>&     faces () const { return mFaces; }
 203                 const std::vector<expFace>&     colorFaces () const { return mColorFaces; }
 204                 const std::vector<expFace>&     normalFaces () const { return mNormalFaces; }
 205                 const std::vector<expFace>&     texCoordFaces () const { return mTexCoordFaces; }
 206                 const std::vector<expFace>&     lightmapTexCoordFaces () const { return mLightmapTexCoordFaces; }
 207                 const std::vector<int>& mtlIndex () const { return mMtlIndex; }
 208                 const std::vector<vector3>&     tangents () const { return mTangents; }
 209                 const std::vector<vector3>&     binormals () const { return mBinormals; }
 210                 const std::vector<expFace>&     tsFaces () const { return mTSFaces; }
 211
 212                 virtual void render (expScene *scene);
 213         };
 214
 215         typedef smartPtr <expTriObject> expTriObjectPtr;
 216
 217         class expModel : public sceneObject
 218         {
 219
 220         protected:
 221
 222                 struct face
 223                 {
 224                         ushort v[3];
 225                 };
 226
 227                 struct subset
 228                 {
 229                         uint32 firstVertex;
 230                         uint32 firstFace;
 231                         uint32 numVerts;
 232                         uint32 numFaces;
 233                         uint32 mtl;
 234                 };
 235
 236                 bool mbLightmaps, mbTangents;
 237
 238                 std::vector< subset >   mSubSets;
 239                 std::vector< drawVertex_t >     mVerts;
 240                 std::vector< face >             mFaces;
 241                 std::vector< int >              mMtlIndex;
 242                 cStr                                    mLightmapName;
 243
 244                 ~expModel (void);
 245                 void    saveGeometry (FILE *fp) const;
 246
 247         public:
 248
 249                 expModel (expModel *parent);
 250
 251                 void    convertFrom (const expScenePtr &s, const expObjectPtr &o);
 252                 void    save (const char *fname, const expScenePtr &s) const;
 253         };
 254
 255         class expEntityObject : public expObject
 256         {
 257         private:
 258
 259         public:
 260                 // data
 261                 std::map<cStr, cStr>    mProps;
 262
 263         public:
 264
 265                 virtual void load (charParser &p, const char *fname);
 266
 267                 // constructor & destructor
 268                 expEntityObject (expObject *parent);
 269                 virtual void render (expScene *scene);
 270
 271         protected:
 272                 virtual ~expEntityObject () {};
 273         };
 274
 275         class expRefObject : public expObject
 276         {
 277
 278                 // data
 279                 cStr            mRefObjFileName;        // imported .mdl filename
 280                 expScene*       mpScene;                        // imported scene ptr
 281
 282         public:
 283
 284                 virtual void load (charParser &p, const char *fname);
 285
 286                 // constructor & destructor
 287                 expRefObject (expObject *parent);
 288                 virtual void render (expScene *scene);
 289
 290         protected:
 291
 292                 virtual ~expRefObject () {};
 293
 294         };
 295
 296         class expDummyObject : public expObject
 297         {
 298
 299         public:
 300
 301                 expDummyObject (expObject *parent);
 302                 virtual void load (charParser &p, const char *fname);
 303                 virtual void render (expScene *scene);
 304         };
 305
 306 }
 307
 308 #endif // __F_EXPMODEL_H
 309