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/landscape_user.h"
+00029 #include "nel/misc/file.h"
+00030 #include "nel/misc/path.h"
+00031 #include "nel/misc/hierarchical_timer.h"
+00032 
+00033 using namespace NLMISC;
+00034 
+00035 namespace NL3D
+00036 {
+00037 
+00038 H_AUTO_DECL( NL3D_UI_Landscape )
+00039 H_AUTO_DECL( NL3D_Render_Landscape_updateLightingAll )
+00040 H_AUTO_DECL( NL3D_Load_Landscape )
+00041 
+00042 #define NL3D_HAUTO_UI_LANDSCAPE                                         H_AUTO_USE( NL3D_UI_Landscape )
+00043 #define NL3D_HAUTO_LANDSCAPE_UPDATE_LIGHTING_ALL        H_AUTO_USE( NL3D_Render_Landscape_updateLightingAll )
+00044 #define NL3D_HAUTO_LOAD_LANDSCAPE                                       H_AUTO_USE( NL3D_Load_Landscape )
+00045 
+00046 
+00047 //****************************************************************************
+00048 void    CLandscapeUser::setZonePath(const std::string &zonePath)
+00049 {
+00050         NL3D_MEM_LANDSCAPE
+00051         NL3D_HAUTO_UI_LANDSCAPE;
+00052         _ZoneManager.setZonePath(zonePath);
+00053 }
+00054 //****************************************************************************
+00055 void    CLandscapeUser::loadBankFiles(const std::string &tileBankFile, const std::string &farBankFile)
+00056 {
+00057         NL3D_MEM_LANDSCAPE
+00058         NL3D_HAUTO_LOAD_LANDSCAPE;
+00059 
+00060         // First, load the banks.
+00061         //=======================
+00062         CIFile bankFile(CPath::lookup(tileBankFile));
+00063         _Landscape->Landscape.TileBank.serial(bankFile);
+00064         // All textures path are relative!
+00065         _Landscape->Landscape.TileBank.makeAllPathRelative();
+00066         // Use DDS!!!
+00067         _Landscape->Landscape.TileBank.makeAllExtensionDDS();
+00068         // No absolute path
+00069         _Landscape->Landscape.TileBank.setAbsPath ("");
+00070 
+00071         // After loading the TileBank, and before initTileBanks(), must load the vegetables descritpor
+00072         _Landscape->Landscape.TileBank.loadTileVegetableDescs();
+00073 
+00074         CIFile farbankFile(CPath::lookup(farBankFile));
+00075         _Landscape->Landscape.TileFarBank.serial(farbankFile);
+00076         if ( ! _Landscape->Landscape.initTileBanks() )
+00077         {
+00078                 nlwarning( "You need to recompute bank.farbank for the far textures" );
+00079         }
+00080         bankFile.close();
+00081         farbankFile.close();
+00082 
+00083 
+00084         // Second, temporary, flushTiles.
+00085         //===============================
+00086         sint    ts;
+00087         for (ts=0; ts<_Landscape->Landscape.TileBank.getTileSetCount (); ts++)
+00088         {
+00089                 CTileSet *tileSet=_Landscape->Landscape.TileBank.getTileSet (ts);
+00090                 sint tl;
+00091                 for (tl=0; tl<tileSet->getNumTile128(); tl++)
+00092                         _Landscape->Landscape.flushTiles (_Scene->getDriver(), (uint16)tileSet->getTile128(tl), 1);
+00093                 for (tl=0; tl<tileSet->getNumTile256(); tl++)
+00094                         _Landscape->Landscape.flushTiles (_Scene->getDriver(), (uint16)tileSet->getTile256(tl), 1);
+00095                 for (tl=0; tl<CTileSet::count; tl++)
+00096                         _Landscape->Landscape.flushTiles (_Scene->getDriver(), (uint16)tileSet->getTransition(tl)->getTile (), 1);
+00097         }
+00098 
+00099 }
+00100 
+00101 
+00102 //****************************************************************************
+00103 void    CLandscapeUser::loadAllZonesAround(const CVector &pos, float radius, std::vector<std::string> &zonesAdded)
+00104 {
+00105         NL3D_MEM_LANDSCAPE
+00106         NL3D_HAUTO_LOAD_LANDSCAPE;
+00107 
+00108         zonesAdded.clear();
+00109 
+00110         _ZoneManager.checkZonesAround ((uint)pos.x, (uint)(-pos.y), (uint)radius);
+00111         while (_ZoneManager.isWorking())
+00112         {
+00113                 CZoneManager::SZoneManagerWork Work;
+00114                 if (_ZoneManager.isWorkComplete(Work))
+00115                 {
+00116                         nlassert(!Work.ZoneRemoved);
+00117                         if (Work.ZoneAdded)
+00118                         {
+00119                                 if (Work.Zone == (CZone*)-1)
+00120                                 {
+00121                                         nlwarning ("Can't load zone %s", Work.NameZoneAdded.c_str ());
+00122                                 }
+00123                                 else
+00124                                 {
+00125                                         _Landscape->Landscape.addZone (*Work.Zone);
+00126 
+00127                                         delete Work.Zone;
+00128                                         std::string zoneadd = Work.NameZoneAdded;
+00129                                         zoneadd = zoneadd.substr(0, zoneadd.find('.'));
+00130                                         zonesAdded.push_back(zoneadd);
+00131                                 }
+00132                         }
+00133                 }
+00134                 else
+00135                 {
+00136                         nlSleep (1);
+00137                 }
+00138                 _ZoneManager.checkZonesAround ((uint)pos.x, (uint)(-pos.y), (uint)radius);
+00139         }
+00140         // Yoyo: must check the binds of the zones.
+00141         _Landscape->Landscape.checkBinds();
+00142 }
+00143 
+00144 //****************************************************************************
+00145 void    CLandscapeUser::refreshAllZonesAround(const CVector &pos, float radius, std::vector<std::string> &zonesAdded, std::vector<std::string> &zonesRemoved)
+00146 {
+00147         NL3D_MEM_LANDSCAPE
+00148         NL3D_HAUTO_LOAD_LANDSCAPE;
+00149 
+00150         zonesAdded.clear();
+00151         zonesRemoved.clear();
+00152         std::string             za, zr;
+00153 
+00154         _ZoneManager.checkZonesAround ((uint)pos.x, (uint)(-pos.y), (uint)radius);
+00155         while (_ZoneManager.isWorking())
+00156         {
+00157                 refreshZonesAround (pos, radius, za, zr);
+00158 
+00159                 // some zone added or removed??
+00160                 if(za != "")
+00161                         zonesAdded.push_back(za);
+00162                 if(zr != "")
+00163                         zonesRemoved.push_back(zr);
+00164                 
+00165                 _ZoneManager.checkZonesAround ((uint)pos.x, (uint)(-pos.y), (uint)radius);
+00166         }
+00167 }
+00168 
+00169 // ***************************************************************************
+00170 void    CLandscapeUser::getAllZoneLoaded(std::vector<std::string>       &zoneLoaded) const
+00171 {
+00172         NL3D_MEM_LANDSCAPE
+00173         // Build the list of zoneId.
+00174         std::vector<uint16>     zoneIds;
+00175         _Landscape->Landscape.getZoneList(zoneIds);
+00176 
+00177         // transcript
+00178         zoneLoaded.clear();
+00179         zoneLoaded.resize(zoneIds.size());
+00180         for(uint i=0;i<zoneLoaded.size();i++)
+00181         {
+00182                 CLandscape::buildZoneName(zoneIds[i], zoneLoaded[i]);
+00183         }
+00184 }
+00185 
+00186 //****************************************************************************
+00187 void    CLandscapeUser::loadAllZonesAround(const CVector &pos, float radius)
+00188 {
+00189         NL3D_MEM_LANDSCAPE
+00190         std::vector<std::string>        dummy;
+00191         loadAllZonesAround(pos, radius, dummy);
+00192 }
+00193 
+00194 
+00195 //****************************************************************************
+00196 void    CLandscapeUser::refreshZonesAround(const CVector &pos, float radius)
+00197 {
+00198         NL3D_MEM_LANDSCAPE
+00199         NL3D_HAUTO_LOAD_LANDSCAPE;
+00200 
+00201         std::string     dummy1, dummy2;
+00202         refreshZonesAround(pos, radius, dummy1, dummy2);
+00203 }
+00204 //****************************************************************************
+00205 void    CLandscapeUser::refreshZonesAround(const CVector &pos, float radius, std::string &zoneAdded, std::string &zoneRemoved)
+00206 {
+00207         NL3D_MEM_LANDSCAPE
+00208         NL3D_HAUTO_LOAD_LANDSCAPE;
+00209 
+00210         zoneRemoved= "";
+00211         zoneAdded= "";
+00212         CZoneManager::SZoneManagerWork Work;
+00213         // Check if new zone must be added to landscape
+00214         if (_ZoneManager.isWorkComplete(Work))
+00215         {
+00216                 if (Work.ZoneAdded)
+00217                 {
+00218                         if (Work.Zone == (CZone*)-1)
+00219                         {
+00220                                 nlwarning ("Can't load zone %s", Work.NameZoneAdded.c_str ());
+00221                         }
+00222                         else
+00223                         {
+00224                                 _Landscape->Landscape.addZone(*Work.Zone);
+00225 
+00226                                 // Yoyo: must check the binds of the new inserted zone.
+00227                                 try
+00228                                 {
+00229                                         _Landscape->Landscape.checkBinds(Work.Zone->getZoneId());
+00230                                 }
+00231                                 catch (EBadBind &e)
+00232                                 {
+00233                                         nlwarning ("Bind error : %s", e.what());
+00234                                 }
+00235 
+00236                                 delete Work.Zone;
+00237                                 zoneAdded = Work.NameZoneAdded;
+00238                                 zoneAdded = zoneAdded.substr(0, zoneAdded.find('.'));
+00239                         }
+00240                 }
+00241 
+00242                 // Check if a zone must be removed from landscape
+00243                 if (Work.ZoneRemoved)
+00244                 {
+00245                         _Landscape->Landscape.removeZone (Work.IdZoneToRemove);
+00246                         zoneRemoved = Work.NameZoneRemoved;
+00247                         zoneRemoved = zoneRemoved.substr(0, zoneRemoved.find('.'));
+00248                 }
+00249         }
+00250 
+00251         _ZoneManager.checkZonesAround((uint)pos.x, (uint)(-pos.y), (uint)radius);
+00252 }
+00253 
+00254 
+00255 //****************************************************************************
+00256 void    CLandscapeUser::setupStaticLight (const CRGBA &diffuse, const CRGBA &ambiant, float multiply)
+00257 {
+00258         NL3D_MEM_LANDSCAPE
+00259         NL3D_HAUTO_UI_LANDSCAPE;
+00260         _Landscape->Landscape.setupStaticLight(diffuse, ambiant, multiply);
+00261 }
+00262 
+00263 
+00264 
+00265 //****************************************************************************
+00266 void    CLandscapeUser::setThreshold (float thre)
+00267 {
+00268         NL3D_MEM_LANDSCAPE
+00269         NL3D_HAUTO_UI_LANDSCAPE;
+00270         _Landscape->Landscape.setThreshold(thre);
+00271 }
+00272 //****************************************************************************
+00273 float   CLandscapeUser::getThreshold () const
+00274 {
+00275         NL3D_MEM_LANDSCAPE
+00276         NL3D_HAUTO_UI_LANDSCAPE;
+00277         return _Landscape->Landscape.getThreshold();
+00278 }
+00279 //****************************************************************************
+00280 void    CLandscapeUser::setTileNear (float tileNear)
+00281 {
+00282         NL3D_MEM_LANDSCAPE
+00283         NL3D_HAUTO_UI_LANDSCAPE;
+00284         _Landscape->Landscape.setTileNear(tileNear);
+00285 }
+00286 //****************************************************************************
+00287 float   CLandscapeUser::getTileNear () const
+00288 {
+00289         NL3D_MEM_LANDSCAPE
+00290         NL3D_HAUTO_UI_LANDSCAPE;
+00291         return _Landscape->Landscape.getTileNear();
+00292 }
+00293 //****************************************************************************
+00294 void    CLandscapeUser::setTileMaxSubdivision (uint tileDiv)
+00295 {
+00296         NL3D_MEM_LANDSCAPE
+00297         NL3D_HAUTO_UI_LANDSCAPE;
+00298         _Landscape->Landscape.setTileMaxSubdivision(tileDiv);
+00299 }
+00300 //****************************************************************************
+00301 uint    CLandscapeUser::getTileMaxSubdivision ()
+00302 {
+00303         NL3D_MEM_LANDSCAPE
+00304         NL3D_HAUTO_UI_LANDSCAPE;
+00305         return _Landscape->Landscape.getTileMaxSubdivision();
+00306 }
+00307 
+00308 
+00309 //****************************************************************************
+00310 std::string     CLandscapeUser::getZoneName(const CVector &pos)
+00311 {
+00312         NL3D_MEM_LANDSCAPE
+00313         NL3D_HAUTO_UI_LANDSCAPE;
+00314         return _ZoneManager.getZoneName((uint)pos.x, (uint)(-pos.y), 0, 0).first;
+00315 }
+00316 
+00317 
+00318 //****************************************************************************
+00319 CVector         CLandscapeUser::getHeightFieldDeltaZ(float x, float y) const
+00320 {
+00321         NL3D_MEM_LANDSCAPE
+00322         NL3D_HAUTO_UI_LANDSCAPE;
+00323         return _Landscape->Landscape.getHeightFieldDeltaZ(x,y);
+00324 }
+00325 
+00326 //****************************************************************************
+00327 void            CLandscapeUser::setHeightField(const CHeightMap &hf)
+00328 {
+00329         NL3D_MEM_LANDSCAPE
+00330         NL3D_HAUTO_UI_LANDSCAPE;
+00331         _Landscape->Landscape.setHeightField(hf);
+00332 }
+00333 
+00334 
+00335 //****************************************************************************
+00336 void            CLandscapeUser::enableVegetable(bool enable)
+00337 {
+00338         NL3D_MEM_LANDSCAPE
+00339         NL3D_HAUTO_UI_LANDSCAPE;
+00340         _Landscape->Landscape.enableVegetable(enable);
+00341 }
+00342 
+00343 //****************************************************************************
+00344 void            CLandscapeUser::loadVegetableTexture(const std::string &textureFileName)
+00345 {
+00346         NL3D_MEM_LANDSCAPE
+00347         NL3D_HAUTO_LOAD_LANDSCAPE;
+00348         _Landscape->Landscape.loadVegetableTexture(textureFileName);
+00349 }
+00350 
+00351 //****************************************************************************
+00352 void            CLandscapeUser::setupVegetableLighting(const CRGBA &ambient, const CRGBA &diffuse, const CVector &directionalLight)
+00353 {
+00354         NL3D_MEM_LANDSCAPE
+00355         NL3D_HAUTO_UI_LANDSCAPE;
+00356         _Landscape->Landscape.setupVegetableLighting(ambient, diffuse, directionalLight);
+00357 }
+00358 
+00359 //****************************************************************************
+00360 void            CLandscapeUser::setVegetableWind(const CVector &windDir, float windFreq, float windPower, float windBendMin)
+00361 {
+00362         NL3D_MEM_LANDSCAPE
+00363         NL3D_HAUTO_UI_LANDSCAPE;
+00364         _Landscape->Landscape.setVegetableWind(windDir, windFreq, windPower, windBendMin);
+00365 }
+00366 
+00367 //****************************************************************************
+00368 void            CLandscapeUser::setVegetableUpdateLightingFrequency(float freq)
+00369 {
+00370         NL3D_MEM_LANDSCAPE
+00371         NL3D_HAUTO_UI_LANDSCAPE;
+00372         _Landscape->Landscape.setVegetableUpdateLightingFrequency(freq);
+00373 }
+00374 
+00375 
+00376 //****************************************************************************
+00377 void            CLandscapeUser::setPointLightFactor(const std::string &lightGroupName, NLMISC::CRGBA nFactor)
+00378 {
+00379         NL3D_MEM_LANDSCAPE
+00380         NL3D_HAUTO_UI_LANDSCAPE;
+00381         _Landscape->Landscape.setPointLightFactor(lightGroupName, nFactor);
+00382 }
+00383 
+00384 //****************************************************************************
+00385 void            CLandscapeUser::setUpdateLightingFrequency(float freq)
+00386 {
+00387         NL3D_MEM_LANDSCAPE
+00388         NL3D_HAUTO_UI_LANDSCAPE;
+00389         _Landscape->Landscape.setUpdateLightingFrequency(freq);
+00390 }
+00391 
+00392 
+00393 //****************************************************************************
+00394 void            CLandscapeUser::enableAdditive (bool enable)
+00395 {
+00396         NL3D_MEM_LANDSCAPE
+00397         NL3D_HAUTO_UI_LANDSCAPE;
+00398         _Landscape->enableAdditive(enable);
+00399 }
+00400 //****************************************************************************
+00401 bool            CLandscapeUser::isAdditiveEnabled () const
+00402 {
+00403         NL3D_MEM_LANDSCAPE
+00404         NL3D_HAUTO_UI_LANDSCAPE;
+00405         return _Landscape->isAdditive ();
+00406 }
+00407 
+00408 //****************************************************************************
+00409 void            CLandscapeUser::setPointLightDiffuseMaterial(CRGBA diffuse)
+00410 {
+00411         NL3D_MEM_LANDSCAPE
+00412         NL3D_HAUTO_UI_LANDSCAPE;
+00413         _Landscape->Landscape.setPointLightDiffuseMaterial(diffuse);
+00414 }
+00415 //****************************************************************************
+00416 CRGBA           CLandscapeUser::getPointLightDiffuseMaterial () const
+00417 {
+00418         NL3D_MEM_LANDSCAPE
+00419         NL3D_HAUTO_UI_LANDSCAPE;
+00420         return _Landscape->Landscape.getPointLightDiffuseMaterial();
+00421 }
+00422 
+00423 //****************************************************************************
+00424 void            CLandscapeUser::setDLMGlobalVegetableColor(CRGBA gvc)
+00425 {
+00426         NL3D_MEM_LANDSCAPE
+00427         NL3D_HAUTO_UI_LANDSCAPE;
+00428         _Landscape->Landscape.setDLMGlobalVegetableColor(gvc);
+00429 }
+00430 //****************************************************************************
+00431 CRGBA           CLandscapeUser::getDLMGlobalVegetableColor() const
+00432 {
+00433         NL3D_MEM_LANDSCAPE
+00434         NL3D_HAUTO_UI_LANDSCAPE;
+00435         return _Landscape->Landscape.getDLMGlobalVegetableColor();
+00436 }
+00437 //****************************************************************************
+00438 void            CLandscapeUser::updateLightingAll()
+00439 {
+00440         NL3D_MEM_LANDSCAPE
+00441         NL3D_HAUTO_LANDSCAPE_UPDATE_LIGHTING_ALL;
+00442         _Landscape->Landscape.updateLightingAll();
+00443 }
+00444 
+00445 
+00446 
+00447 } // NL3D
+
landscape_user.cpp
