nevrax.org : docs

00001 
+00007 /* Copyright, 2001 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #include "std3d.h"
+00027 
+00028 #include "3d/cluster.h"
+00029 #include "3d/portal.h"
+00030 #include "nel/misc/stream.h"
+00031 #include "3d/scene.h"
+00032 #include "3d/transform_shape.h"
+00033 #include "3d/mesh_instance.h"
+00034 #include "3d/scene_group.h"
+00035 
+00036 using namespace NLMISC;
+00037 using namespace std;
+00038 
+00039 namespace NL3D 
+00040 {
+00041 
+00042 // 0.5 cm of precision
+00043 #define CLUSTERPRECISION 0.005
+00044 
+00045 
+00046 // ***************************************************************************
+00047 CCluster::CCluster ()
+00048 {
+00049         _Obs = NULL;
+00050         FatherVisible = VisibleFromFather = false;
+00051         Father = NULL;
+00052 }
+00053 
+00054 
+00055 // ***************************************************************************
+00056 CCluster::~CCluster()
+00057 {
+00058         unlinkFromClusterTree();
+00059 }
+00060 
+00061 
+00062 // ***************************************************************************
+00063 void CCluster::unlinkFromParent()
+00064 {
+00065         // unlink from father sons list
+00066         if (Father)
+00067         {
+00068                  Father->Children.erase(std::remove(Father->Children.begin(), Father->Children.end(), this), Father->Children.end());
+00069                  Father = NULL;
+00070         }
+00071 }
+00072 
+00073 // ***************************************************************************
+00074 void CCluster::unlinkSons()
+00075 {
+00076         // tells all sons that they have no more father
+00077         for(uint k = 0; k < Children.size(); ++k)
+00078         {
+00079                 if (Children[k]->Father == this)
+00080                 {
+00081                         Children[k]->Father = NULL;
+00082                 }
+00083         }
+00084         NLMISC::contReset(Children);
+00085 }
+00086 
+00087 
+00088 
+00089 // ***************************************************************************
+00090 void CCluster::unlinkFromClusterTree()
+00091 {
+00092         unlinkFromParent();
+00093         unlinkSons();   
+00094 }
+00095 
+00096 
+00097 
+00098 // ***************************************************************************
+00099 void CCluster::registerBasic ()
+00100 {
+00101         CMOT::registerModel (ClusterId, 0, CCluster::creator);
+00102         CMOT::registerObs (ClipTravId, ClusterId, CClusterClipObs::creator);
+00103         CMOT::registerObs (HrcTravId, ClusterId, CClusterHrcObs::creator);
+00104 }
+00105 
+00106 // ***************************************************************************
+00107 bool CCluster::makeVolume (CVector& p1, CVector& p2, CVector& p3)
+00108 {
+00109         uint i;
+00110         // Check if the plane is not close to a plane that already define the cluster
+00111         for (i = 0; i < _LocalVolume.size(); ++i)
+00112         {
+00113                 float f1 = fabsf (_LocalVolume[i]*p1);
+00114                 float f2 = fabsf (_LocalVolume[i]*p2);
+00115                 float f3 = fabsf (_LocalVolume[i]*p3);
+00116                 if ((f1 < CLUSTERPRECISION) && (f2 < CLUSTERPRECISION) && (f3 < CLUSTERPRECISION))
+00117                         return true;
+00118         }
+00119         // Check if we want to add a triangle not completely in the predefined volume
+00120         for (i = 0; i < _LocalVolume.size(); ++i)
+00121         {
+00122                 float f1 = _LocalVolume[i]*p1;
+00123                 float f2 = _LocalVolume[i]*p2;
+00124                 float f3 = _LocalVolume[i]*p3;
+00125                 if ((f1 > CLUSTERPRECISION) && (f2 > CLUSTERPRECISION) && (f3 > CLUSTERPRECISION))
+00126                         return false;
+00127         }
+00128         // Build volume
+00129         CPlane p;
+00130         p.make (p1, p2, p3);
+00131         p.normalize();
+00132         _LocalVolume.push_back (p);
+00133         // Build BBox   
+00134         if (_LocalVolume.size() == 1)
+00135                 _LocalBBox.setCenter(p1);
+00136         else
+00137                 _LocalBBox.extend(p1);
+00138         _LocalBBox.extend(p2);
+00139         _LocalBBox.extend(p3);
+00140         _Volume = _LocalVolume;
+00141         _BBox = _LocalBBox;
+00142         return true;
+00143 }
+00144 
+00145 // ***************************************************************************
+00146 bool CCluster::isIn (CVector& p)
+00147 {
+00148         for (uint i = 0; i < _Volume.size(); ++i)
+00149                 if (_Volume[i]*p > CLUSTERPRECISION)
+00150                         return false;
+00151         return true;
+00152 }
+00153 
+00154 
+00155 // ***************************************************************************
+00156 bool CCluster::isIn (CAABBox& b)
+00157 {
+00158         for (uint i = 0; i < _Volume.size(); ++i)
+00159         {
+00160                 if (!b.clipBack (_Volume[i]))
+00161                         return false;
+00162         }
+00163         return true;
+00164 }
+00165 
+00166 // ***************************************************************************
+00167 bool CCluster::isIn (NLMISC::CVector& center, float size)
+00168 {
+00169         for (uint i = 0; i < _Volume.size(); ++i)
+00170                 if (_Volume[i]*center > size)
+00171                         return false;
+00172         return true;
+00173 }
+00174 
+00175 // ***************************************************************************
+00176 void CCluster::resetPortalLinks ()
+00177 {
+00178         _Portals.clear();
+00179 }
+00180 
+00181 // ***************************************************************************
+00182 void CCluster::link (CPortal* portal)
+00183 {
+00184         _Portals.push_back (portal);
+00185 }
+00186 
+00187 // ***************************************************************************
+00188 void CCluster::unlink (CPortal* portal)
+00189 {
+00190         uint32 pos;
+00191         for (pos = 0; pos < _Portals.size(); ++pos)
+00192         {
+00193                 if (_Portals[pos] == portal)
+00194                         break;
+00195         }
+00196         if (pos < _Portals.size())
+00197                 _Portals.erase (_Portals.begin()+pos);
+00198 }
+00199 
+00200 // ***************************************************************************
+00201 void CCluster::serial (IStream&f)
+00202 {
+00203         sint version = f.serialVersion (1);
+00204 
+00205         if (version >= 1)
+00206                 f.serial (Name);
+00207         
+00208         f.serialCont (_LocalVolume);
+00209         f.serial (_LocalBBox);
+00210         f.serial (FatherVisible);
+00211         f.serial (VisibleFromFather);
+00212         if (f.isReading())
+00213         {
+00214                 _Volume = _LocalVolume;
+00215                 _BBox = _LocalBBox;
+00216         }
+00217 }
+00218 
+00219 // ***************************************************************************
+00220 void CCluster::setWorldMatrix (const CMatrix &WM)
+00221 {
+00222         uint32 i;
+00223         CMatrix invWM = WM;
+00224         invWM.invert();
+00225 
+00226         // Transform the volume
+00227         for (i = 0; i < _LocalVolume.size(); ++i)
+00228                 _Volume[i] = _LocalVolume[i] * invWM;
+00229 
+00230         _BBox = NLMISC::CAABBox::transformAABBox(WM, _LocalBBox);
+00231 
+00232         // Transform the bounding box
+00233         /*CVector p[8];
+00234         p[0].x = _LocalBBox.getMin().x;
+00235         p[0].y = _LocalBBox.getMin().y;
+00236         p[0].z = _LocalBBox.getMin().z;
+00237 
+00238         p[1].x = _LocalBBox.getMax().x;
+00239         p[1].y = _LocalBBox.getMin().y;
+00240         p[1].z = _LocalBBox.getMin().z;
+00241 
+00242         p[2].x = _LocalBBox.getMin().x;
+00243         p[2].y = _LocalBBox.getMax().y;
+00244         p[2].z = _LocalBBox.getMin().z;
+00245 
+00246         p[3].x = _LocalBBox.getMax().x;
+00247         p[3].y = _LocalBBox.getMax().y;
+00248         p[3].z = _LocalBBox.getMin().z;
+00249 
+00250         p[4].x = _LocalBBox.getMin().x;
+00251         p[4].y = _LocalBBox.getMin().y;
+00252         p[4].z = _LocalBBox.getMax().z;
+00253 
+00254         p[5].x = _LocalBBox.getMax().x;
+00255         p[5].y = _LocalBBox.getMin().y;
+00256         p[5].z = _LocalBBox.getMax().z;
+00257 
+00258         p[6].x = _LocalBBox.getMin().x;
+00259         p[6].y = _LocalBBox.getMax().y;
+00260         p[6].z = _LocalBBox.getMax().z;
+00261 
+00262         p[7].x = _LocalBBox.getMax().x;
+00263         p[7].y = _LocalBBox.getMax().y;
+00264         p[7].z = _LocalBBox.getMax().z;
+00265 
+00266         for (i = 0; i < 8; ++i)
+00267                 p[i] = WM.mulPoint(p[i]);
+00268 
+00269         CAABBox boxTemp;
+00270 
+00271         boxTemp.setCenter(p[0]);
+00272         for (i = 1; i < 8; ++i)
+00273                 boxTemp.extend(p[i]);
+00274         _BBox = boxTemp;*/
+00275 }
+00276 
+00277 // ***************************************************************************
+00278 CClusterClipObs *CCluster::getClipObs()
+00279 {
+00280         if (_Obs == NULL)
+00281                 _Obs = (CClusterClipObs*)getObs (ClipTravId);
+00282         return _Obs;
+00283 }
+00284 
+00285 // ---------------------------------------------------------------------------
+00286 // Observer HRC
+00287 // ---------------------------------------------------------------------------
+00288 
+00289 // ***************************************************************************
+00290 void CClusterHrcObs::traverse (IObs *caller)
+00291 {
+00292         CTransformHrcObs::traverse (caller);
+00293 
+00294         CCluster *pCluster = static_cast<CCluster*>(this->Model);
+00295 
+00296         pCluster->setWorldMatrix (WorldMatrix);
+00297 
+00298         for (uint32 i = 0; i < pCluster->getNbPortals(); ++i)
+00299         {
+00300                 CPortal *pPortal = pCluster->getPortal(i);
+00301                 pPortal->setWorldMatrix (WorldMatrix);
+00302         }
+00303 
+00304         // Re affect the cluster to the accelerator if not the root
+00305         if (!pCluster->isRoot())
+00306         {
+00307                 pCluster->Group->_ClipTrav->Accel.erase (pCluster->AccelIt);
+00308                 pCluster->Group->_ClipTrav->registerCluster (pCluster);
+00309         }
+00310 }
+00311 
+00312 // ---------------------------------------------------------------------------
+00313 // Observer CLIP
+00314 // ---------------------------------------------------------------------------
+00315 
+00316 // ***************************************************************************
+00317 CClusterClipObs::CClusterClipObs ()
+00318 {
+00319         Visited = false;
+00320 }
+00321 
+00322 // ***************************************************************************
+00323 bool CClusterClipObs::clip (IBaseClipObs *caller)
+00324 {
+00325         return true;
+00326 }
+00327 
+00328 // ***************************************************************************
+00329 void CClusterClipObs::traverse (IObs *caller)
+00330 {
+00331         nlassert(!caller || dynamic_cast<IBaseClipObs*>(caller));
+00332 
+00333         if (Visited)
+00334                 return;
+00335         Visited = true;
+00336         // The cluster is visible because we are in it
+00337         // So clip the models attached (with MOT links) to the cluster
+00338         traverseSons();
+00339 
+00340         // And look through portals
+00341         CCluster *pCluster = static_cast<CCluster*>(this->Model);
+00342         uint32 i;
+00343         for (i = 0; i < pCluster->getNbPortals(); ++i)
+00344         {
+00345                 CPortal*pPortal = pCluster->getPortal (i);
+00346                 vector<CPlane> WorldPyrTemp = (static_cast<CClipTrav*>(Trav))->WorldPyramid;
+00347                 bool backfaceclipped = false;
+00348                 CCluster *pOtherSideCluster;
+00349                 if (pPortal->getCluster(0) == pCluster)
+00350                         pOtherSideCluster = pPortal->getCluster (1);
+00351                 else
+00352                         pOtherSideCluster = pPortal->getCluster (0);
+00353 
+00354                 if (pCluster->Father != NULL)
+00355                 if (caller == pCluster->Father->getClipObs()) // If the caller is the father
+00356                 if (pCluster->VisibleFromFather)
+00357                         // Backface clipping
+00358                         if( !pPortal->isInFront( (static_cast<CClipTrav*>(Trav))->CamPos ))
+00359                                 backfaceclipped = true;
+00360 
+00361                 if (!backfaceclipped)
+00362                 if (pPortal->clipPyramid ((static_cast<CClipTrav*>(Trav))->CamPos,
+00363                                                                 (static_cast<CClipTrav*>(Trav))->WorldPyramid))
+00364                 {
+00365                         CClusterClipObs *pObserver = pOtherSideCluster->getClipObs();
+00366                         pObserver->traverse (this);
+00367                 }
+00368 
+00369                 (static_cast<CClipTrav*>(Trav))->WorldPyramid = WorldPyrTemp;
+00370         }
+00371 
+00372         // Link up in hierarchy
+00373         if ((pCluster->FatherVisible)&&(pCluster->Father != NULL))
+00374         {
+00375                 CClusterClipObs *pObserver = pCluster->Father->getClipObs();
+00376                 pObserver->traverse (this);
+00377         }
+00378 
+00379         // Link down in hierarchy
+00380         for (i = 0; i < pCluster->Children.size(); ++i)
+00381         if (pCluster->Children[i]->VisibleFromFather)
+00382         {
+00383                 CClusterClipObs *pObserver = pCluster->Children[i]->getClipObs();
+00384                 pObserver->traverse (this);
+00385         }
+00386 
+00387         Visited = false;
+00388 }
+00389 
+00390 
+00391 // ***************************************************************************
+00392 void CCluster::applyMatrix(const NLMISC::CMatrix &m)
+00393 {
+00394         uint32 i;
+00395         CMatrix invM = m;
+00396         invM.invert();
+00397         nlassert(_Volume.size() == _LocalVolume.size());
+00398 
+00399         // Transform the volume
+00400         for (i = 0; i < _LocalVolume.size(); ++i)
+00401         {       
+00402                 _Volume[i] = _Volume[i] * invM;
+00403                 _LocalVolume[i] = _LocalVolume[i] * invM;
+00404         }
+00405 
+00406         // Transform the bounding boxes 
+00407         _BBox = NLMISC::CAABBox::transformAABBox(m, _BBox);
+00408         _LocalBBox = NLMISC::CAABBox::transformAABBox(m, _LocalBBox);   
+00409 }
+00410 
+00411 
+00412 } // NL3D
+
cluster.cpp
