nel/src/3d/landscape_model.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "std3d.h"
  18
  19 #include <vector>
  20 #include "nel/misc/hierarchical_timer.h"
  21 #include "nel/3d/landscape_model.h"
  22 #include "nel/3d/landscape.h"
  23 #include "nel/3d/cluster.h"
  24 #include "nel/3d/scene.h"
  25 #include "nel/3d/light_trav.h"
  26
  27 using namespace std;
  28 using namespace NLMISC;
  29
  30 #ifdef DEBUG_NEW
  31 #define new DEBUG_NEW
  32 #endif
  33
  34 namespace NL3D
  35 {
  36
  37
  38
  39 // ***************************************************************************
  40 void    CLandscapeModel::registerBasic()
  41 {
  42         CScene::registerModel(LandscapeModelId, TransformId, CLandscapeModel::creator);
  43 }
  44
  45
  46 // ***************************************************************************
  47 CLandscapeModel::CLandscapeModel()
  48 {
  49         Landscape.OwnerModel = this;
  50         Landscape.init();
  51         _ActiveAdditive=false;
  52         _Additive=1.f;
  53
  54         // The model is renderable
  55         CTransform::setIsRenderable(true);
  56
  57         // RenderFilter: We are a Landscape
  58         _RenderFilterType= UScene::FilterLandscape;
  59
  60         // Mesh support shadow map receiving only
  61         CTransform::setIsShadowMapReceiver(true);
  62
  63         _RefineCenterUser= CVector::Null;
  64         _RefineCenterAuto= true;
  65 }
  66
  67
  68 // ***************************************************************************
  69 void    CLandscapeModel::initModel()
  70 {
  71         CTransform::initModel();
  72
  73         // Enable the landscape to be clipped by the Cluster System.
  74         getOwnerScene()->getRoot()->clipDelChild(this);
  75         getOwnerScene()->getRootCluster()->clipAddChild(this);
  76
  77         // After creating the landscape (and so the VegetableManager in the ctor).
  78         // we must init correclty the VegetableManager.
  79         Landscape.createVegetableBlendLayersModels(getOwnerScene());
  80 }
  81
  82
  83 // ***************************************************************************
  84 void    CLandscapeModel::traverseHrc()
  85 {
  86         // Call std method.
  87         CTransform::traverseHrc();
  88
  89         /* Compile Animate PointLight here.
  90                 NB: Animated PointLight are important for Dynamic Object lighted by landscape lights.
  91                 The landscape and vegetable are not influenced by thoses animation (as if the light were not animated)
  92                 NB: important to do before the LightTrav. Also even if landscape is hidden, still must animate those light?
  93         */
  94         Landscape.setPointLightFactor(*getOwnerScene());
  95 }
  96
  97
  98 // ***************************************************************************
  99 void    CLandscapeModel::traverseClip()
 100 {
 101         CClipTrav               &clipTrav= getOwnerScene()->getClipTrav();
 102
 103         /// if already clipped in this frame, This means that we are visible from 2 CCluster.
 104         if (_ClipDate == clipTrav.CurrentDate)
 105         {
 106                 // We may set the WorldFrustumPyramid. But do this only if not already set.
 107                 if(!ClusteredPyramidIsFrustum)
 108                 {
 109                         /* If the current pyramid is different from the last stored pyramid, this mean per exemple
 110                          that the player is in a room and look the landscape from 2 windows through portals.
 111                          The other case is that the camera is in 2 clusters, so the clusterSystem start from this 2, and so we arrive
 112                          here 2 times (but through the same portal => same pyramid obviously...)
 113                          */
 114                         if( ClusteredPyramid!=clipTrav.WorldPyramid )
 115                         {
 116                                 // in this rare case take the Whole frustum pyramid (a more correct code is to make an Union of the 2 pyramids...)
 117                                 ClusteredPyramid= clipTrav.WorldFrustumPyramid;
 118                                 ClusteredPyramidIsFrustum= true;
 119                         }
 120                 }
 121         }
 122         else
 123         {
 124                 // If the camera is in Rootcluster or visible through a protal from one Room Cluster only, use the clustered pyramid.
 125                 ClusteredPyramid= clipTrav.WorldPyramid;
 126                 // We are not sure we are the FrustumPyramid
 127                 ClusteredPyramidIsFrustum= false;
 128         }
 129
 130         // Call normal CTransform traverseClip to insert this model in render list etc...
 131         // NB: CTransform::traverseClip() update _ClipDate...
 132         CTransform::traverseClip();
 133 }
 134
 135
 136 // ***************************************************************************
 137 void    CLandscapeModel::clipAndRenderLandscape()
 138 {
 139         /*
 140                 NB: For best Optimisation, it is important that the Clip act at same time as the Render.
 141                 Why? For complex GPU/CPU synchronisation.
 142
 143                 Since the landscape is rendered at end of the opaque pass, the next clip of the next frame will arise
 144                 too early (if we assume no transparent or out-scene rendering), RESULTING IN A LOCK => A CPU STALL!!
 145
 146                 In a "landscape only" program, this is not easily avoidable. But in common programs with other
 147                 opaque meshs, skinning etc... we'll have lot of CPU/GPU Work between this clip and the Landscape Render.
 148                 And since the clip() lock the VB, and stall, all those tasks won't be parralelized.
 149
 150                 I have already seen such a stall (3 ms).
 151
 152                 Therefore, all Landscape VB Lock arise at the same time=> The GPU will render the landscape while the CPU
 153                 will prepare render and do skinning of the next opaque frame for instance.
 154         */
 155
 156         // Clip
 157         // ********
 158
 159         // The real Landscape clip is done here, after std clip
 160         H_AUTO( NL3D_Landscape_Clip );
 161
 162         // Should be unlocked
 163         nlassert (!Landscape.isLocked());
 164
 165         CClipTrav               &clipTrav= getOwnerScene()->getClipTrav();
 166         CRenderTrav             &renderTrav= getOwnerScene()->getRenderTrav();
 167
 168         // Yes, this is ugly, but the clip pass is finished in render(), for clipping TessBlocks.
 169         // This saves another Landscape patch traversal, so this is faster...
 170         // Order them in order which clip faster (first horizontal, then vertical).
 171         // NB: TessBlock are ALWAYS clipped with the frustum pyramid, not the clustered one (faster clip for most common cases).
 172         CurrentPyramid[0]= clipTrav.WorldFrustumPyramid[NL3D_CLIP_PLANE_LEFT];
 173         CurrentPyramid[1]= clipTrav.WorldFrustumPyramid[NL3D_CLIP_PLANE_RIGHT];
 174         CurrentPyramid[2]= clipTrav.WorldFrustumPyramid[NL3D_CLIP_PLANE_TOP];
 175         CurrentPyramid[3]= clipTrav.WorldFrustumPyramid[NL3D_CLIP_PLANE_BOTTOM];
 176         nlassert(NL3D_TESSBLOCK_NUM_CLIP_PLANE==4);
 177
 178         // Before Landscape clip, must setup Driver, for good VB allocation.
 179         Landscape.setDriver(getOwnerScene()->getRenderTrav().getDriver());
 180
 181         // get the refineCenter.
 182         CVector         refineCenter;
 183         if(_RefineCenterAuto)
 184                 refineCenter= clipTrav.CamPos;
 185         else
 186                 refineCenter= _RefineCenterUser;
 187
 188         Landscape.lockBuffers ();
 189
 190         // Use the Clustered pyramid for Patch, but Frustum pyramid for TessBlocks.
 191         // We are sure that pyramid has normalized plane normals.
 192         Landscape.clip(refineCenter, ClusteredPyramid);
 193
 194
 195         // Render
 196         // ********
 197
 198         // Change the landscape center. All Geomorphed pos (in VertexBuffer only or during VertexProgram)
 199         // subtract this position.
 200         Landscape.setPZBModelPosition(renderTrav.CamPos);
 201
 202         /* setup the model matrix
 203                 ZBuffer Precision: set the modelMatrix to the current landscape PZBModelPosition.
 204                 NB: don't use renderTrav.CamPos directly because setPZBModelPosition() may modify the position
 205         */
 206         _RenderWorldMatrix.identity();
 207         _RenderWorldMatrix.setPos(Landscape.getPZBModelPosition());
 208         renderTrav.getDriver()->setupModelMatrix(_RenderWorldMatrix);
 209
 210
 211         // Scene Time/Lighting Mgt.
 212         CScene          *scene= getOwnerScene();
 213         nlassert(scene);
 214         {
 215                 // For vegetable, set the animation Time.
 216                 Landscape.setVegetableTime(scene->getCurrentTime());
 217
 218                 // For vegetable updateLighting, set the system Time.
 219                 Landscape.setVegetableUpdateLightingTime(scene->getCurrentSystemTime());
 220
 221                 // updateLighting
 222                 H_BEFORE( NL3D_Landscape_UpdateLighting );
 223                 Landscape.updateLighting(scene->getCurrentSystemTime());
 224                 H_AFTER( NL3D_Landscape_UpdateLighting );
 225
 226                 // if SceneLighting enabled
 227                 if(scene->isLightingSystemEnabled())
 228                 {
 229                         H_AUTO( NL3D_Landscape_DynamicLighting );
 230
 231                         // For vegetable, set the lighting
 232                         Landscape.setupVegetableLighting(scene->getSunAmbient(), scene->getSunDiffuse(),
 233                                 scene->getSunDirection());
 234
 235                         // current visible Dynamic light list are registered in LightTrav::LightingManager
 236                         CLightTrav              &lightTrav= scene->getLightTrav();
 237                         // Get all dynamic light list, and light landscape with it.
 238                         Landscape.computeDynamicLighting(lightTrav.LightingManager.getAllDynamicLightList());
 239                 }
 240         }
 241
 242         // First, refine.
 243         H_BEFORE( NL3D_Landscape_Refine );
 244         Landscape.refine(refineCenter);
 245         H_AFTER( NL3D_Landscape_Refine );
 246
 247         // then render.
 248         H_BEFORE( NL3D_Landscape_Render );
 249         Landscape.render(refineCenter, renderTrav.CamLook, CurrentPyramid, isAdditive ());
 250         H_AFTER( NL3D_Landscape_Render );
 251
 252         // Should be unlocked by render
 253         nlassert (!Landscape.isLocked());
 254 }
 255
 256 // ***************************************************************************
 257 void    CLandscapeModel::traverseRender()
 258 {
 259         CRenderTrav             &renderTRav= getOwnerScene()->getRenderTrav();
 260
 261         // No-Op. But delay the clip and render to the end of Opaque Rendering. For VBLock optim
 262         renderTRav.addRenderLandscape(this);
 263
 264         // If the landscape receive shadow, then add it.
 265         if(canReceiveShadowMap())
 266                 renderTRav.getShadowMapManager().addShadowReceiver(this);
 267 }
 268
 269 // ***************************************************************************
 270 void    CLandscapeModel::profileRender()
 271 {
 272         Landscape.profileRender();
 273 }
 274
 275
 276 // ***************************************************************************
 277 // ***************************************************************************
 278 // Dynamic ShadowMaping
 279 // ***************************************************************************
 280 // ***************************************************************************
 281
 282
 283 // ***************************************************************************
 284 void            CLandscapeModel::getReceiverBBox(CAABBox &bbox)
 285 {
 286         // Build a dummy bbox around the TileNear distance.
 287         bbox.setCenter(Landscape.getOldRefineCenter());
 288         float   hs= Landscape.getTileNear() * 1.5f; // Enlarge a little because may have some triangles outside this dist.
 289         bbox.setHalfSize(CVector(hs,hs,hs));
 290 }
 291
 292 // ***************************************************************************
 293 void            CLandscapeModel::receiveShadowMap(CShadowMap *shadowMap, const CVector &casterPos, const CMaterial &shadowMat)
 294 {
 295         IDriver *drv= getOwnerScene()->getRenderTrav().getDriver();
 296
 297         // Setup the matrix. The same than one used for render (ie PZB included)
 298         drv->setupModelMatrix(_RenderWorldMatrix);
 299
 300         // render.
 301         Landscape.receiveShadowMap(drv, shadowMap, casterPos, shadowMat, Landscape.getPZBModelPosition());
 302 }
 303
 304
 305
 306 } // NL3D