00001
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
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
00061
00062 CIFile bankFile(CPath::lookup(tileBankFile));
00063 _Landscape->Landscape.TileBank.serial(bankFile);
00064
00065 _Landscape->Landscape.TileBank.makeAllPathRelative();
00066
00067 _Landscape->Landscape.TileBank.makeAllExtensionDDS();
00068
00069 _Landscape->Landscape.TileBank.setAbsPath ("");
00070
00071
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
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
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
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
00174 std::vector<uint16> zoneIds;
00175 _Landscape->Landscape.getZoneList(zoneIds);
00176
00177
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
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
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
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 }