core/code/system/f_sceneobject.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 "f_sceneobject.h"
  25 #include "f_animation.h"
  26 #include "f_engine.h"
  27 #include "f_timer.h"
  28
  29 namespace fe
  30 {
  31
  32         sceneObject::sceneObject (sceneObject *parent)
  33                 : mRelativeMatrix (true)
  34                 , mWorldMatrix (true)
  35                 , mInitPosInverseMatrix (true)
  36         {
  37                 mpParentObject = parent;
  38                 mFlags = recalc_aab;
  39                 mpAnimatedChildren = NULL;
  40         }
  41
  42         sceneObject::~sceneObject ()
  43         {
  44                 if (mpAnimatedChildren)
  45                         delete[] mpAnimatedChildren;
  46         }
  47
  48         matrix4 sceneObject::getWorldMatrix (void) const
  49         {
  50                 return mWorldMatrix;
  51         }
  52
  53         matrix4 sceneObject::getRelativeMatrix (void) const
  54         {
  55                 return mRelativeMatrix;
  56         }
  57
  58         matrix4 sceneObject::getSkinnedBoneRelativeMatrix (void) const
  59         {
  60                 return mInitPosInverseMatrix * mRelativeMatrix;
  61         }
  62
  63         matrix4 sceneObject::getSkinnedBoneWorldMatrix (void) const
  64         {
  65                 return mInitPosInverseMatrix * mWorldMatrix;
  66         }
  67
  68         void    sceneObject::setWorldMatrix (const matrix4 &m)
  69         {
  70                 mFlags |= (invalidate_children_tm | recalc_aab);
  71                 mWorldMatrix = m;
  72         }
  73
  74         void    sceneObject::setRelativeMatrix (const matrix4 &m)
  75         {
  76                 mFlags |= invalidate_children_tm;
  77                 mRelativeMatrix = m;
  78                 if (mpParentObject)
  79                         mWorldMatrix = mRelativeMatrix * mpParentObject->getWorldMatrix ();
  80                 else
  81                         mWorldMatrix = mRelativeMatrix;
  82         }
  83
  84         void    sceneObject::update (ulong updateFlags)
  85         {
  86                 if (updateFlags & F_RECALC_MATRIX)
  87                 {
  88                         if (mpParentObject)
  89                                 mWorldMatrix = mRelativeMatrix * mpParentObject->getWorldMatrix ();
  90                         else
  91                                 mWorldMatrix = mRelativeMatrix;
  92                 }
  93
  94                 if (mFlags & invalidate_children_tm)
  95                 {
  96                         updateFlags |= F_RECALC_MATRIX;
  97                         mFlags &= ~invalidate_children_tm;
  98                 }
  99
 100                 for (sceneObject *c = mpChildren; c; c = c->mpNextChild)
 101                         c->update (updateFlags);
 102         }
 103
 104         sceneObject *sceneObject::getNewInstance (sceneObject *parent)
 105         {
 106                 sceneObject *obj = new sceneObject (parent);
 107                 if (mpRenderable)
 108                 {
 109                         obj->mpRenderable = mpRenderable->copy ();
 110                         // set new sceneobject to all drawsurfs
 111                         int sz = obj->mpRenderable->numDrawSurfs ();
 112                         for (int i = 0; i < sz; i++)
 113                                 obj->mpRenderable->getDrawSurf (i)->obj = obj;
 114                 }
 115                 obj->mName = mName;
 116                 obj->mWorldMatrix = mWorldMatrix;
 117                 obj->mRelativeMatrix = mRelativeMatrix;
 118                 obj->mInitPosInverseMatrix = mInitPosInverseMatrix;
 119                 for (sceneObject *c = mpChildren; c; c = c->mpNextChild)
 120                 {
 121                         obj->addChild (c->getNewInstance (obj));
 122                 }
 123                 return obj;
 124         }
 125
 126         sceneObject* sceneObject::getChildren (void) const
 127         {
 128                 return mpChildren;
 129         }
 130
 131         void sceneObject::addChild (sceneObject *child)
 132         {
 133                 child->mpNextChild = mpChildren;
 134                 mpChildren = child;
 135         }
 136
 137         void sceneObject::removeChild (sceneObject *child)
 138         {
 139                 assert (mpChildren);
 140                 if (!mpChildren)
 141                         return;
 142
 143                 if (mpChildren == child)
 144                 {
 145                         mpChildren = child->mpNextChild;
 146                         child->mpNextChild = NULL;
 147                 }
 148                 else
 149                 {
 150                         sceneObject *c = mpChildren;
 151
 152                         while (c)
 153                         {
 154                                 if (c->mpNextChild == child)
 155                                 {
 156                                         c->mpNextChild = child->mpNextChild;
 157                                         child->mpNextChild = NULL;
 158                                         break;
 159                                 }
 160                         }
 161                 }
 162         }
 163
 164         sceneObject* sceneObject::getNextChild (void) const
 165         {
 166                 return mpNextChild;
 167         }
 168
 169         static void fillAnimData (sceneObject *obj, sceneObject **lst, animContainer *cont)
 170         {
 171                 int nbones = cont->getNumBones ();
 172                 for (int i = 0; i < nbones; i++)
 173                 {
 174                         const char *n = cont->getBoneName (i);
 175                         if (!strcmp (obj->name (), n))
 176                         {
 177                                 lst[i] = obj;
 178                                 break;
 179                         }
 180                 }
 181                 for (sceneObject *c = obj->getChildren (); c; c = c->getNextChild ())
 182                 {
 183                         fillAnimData (c, lst, cont);
 184                 }
 185         }
 186
 187         void sceneObject::initAnimData (animContainer *cont)
 188         {
 189                 if (mpAnimatedChildren)
 190                         delete[] mpAnimatedChildren;
 191                 int nbones = cont->getNumBones ();
 192                 mpAnimatedChildren = new sceneObject*[nbones];
 193                 fillAnimData (this, mpAnimatedChildren, cont);
 194         }
 195
 196         sceneObject **sceneObject::getAnimatedChildren (void)
 197         {
 198                 return mpAnimatedChildren;
 199         }
 200
 201         void sceneObject::calcAAB (void)
 202         {
 203                 // for now it's just AAB, which is suitable to init physx obj
 204                 vector3 mins(1.0e+5f, 1.0e+5f, 1.0e+5f);
 205                 vector3 maxs(-1.0e+5f, -1.0e+5f, -1.0e+5f);
 206                 if (mpRenderable) {
 207                         const matrix4& mtx = getWorldMatrix ();
 208                         fprintf (stderr, "mtx: %f %f %f\n", mtx.m[3][0], mtx.m[3][1], mtx.m[3][2]);
 209                         int nds = mpRenderable->numDrawSurfs ();
 210                         for (int i = 0; i < nds; i++) {
 211                                 drawSurf_t *ds = mpRenderable->getDrawSurf (i);
 212                                 meshData_t *md = ds->mesh;
 213                                 uchar *vx = md->verts;
 214                                 for (int v = 0; v < md->numVerts; v++, vx += md->vertexSize) {
 215                                         const vector3 pos = *((vector3 *)vx) * mtx;
 216                                         for (int k = 0; k < 3; k++) {
 217                                                 if (pos[k] < mins[k])
 218                                                         mins[k] = pos[k];
 219                                                 if (pos[k] > maxs[k])
 220                                                         maxs[k] = pos[k];
 221                                         }
 222                                 }
 223                         }
 224                 }
 225                 mBBox.mins = mins;
 226                 mBBox.maxs = maxs;
 227                 for (sceneObject *c = mpChildren; c; c = c->mpNextChild) {
 228                         const aab3 &b = c->getBoundingBox (true);
 229                         for (int k = 0; k < 3; k++) {
 230                                 if (b.mins[k] < mins[k])
 231                                         mins[k] = b.mins[k];
 232                                 if (b.maxs[k] > maxs[k])
 233                                         maxs[k] = b.maxs[k];
 234                         }
 235                 }
 236                 mBBoxWithChildren.mins = mins;
 237                 mBBoxWithChildren.maxs = maxs;
 238         }
 239
 240         const aab3 &sceneObject::getBoundingBox (bool withChildren)
 241         {
 242                 if (mFlags & recalc_aab) {
 243                         mFlags &= ~recalc_aab;
 244                         calcAAB ();
 245                 }
 246                 return withChildren ? mBBoxWithChildren : mBBox;
 247         }
 248
 249 }