Table of contents
- Paging Landscape Scene Manager 2
- Demo Application
- Mapsplitter Application
- Integration with physics engines
- Integration with PagedGeometry
- Known Bugs
Alright, you’ve evaluated the choices, and decided to go with the Paging Scene Manager.
If you’re just interested in how to compile and set up the Paging Scene Manager, see Paging Scene Manager Installation
If you’re just interested in creating a new application using PLSM2 see Creating a PLSM Application
The Paging Scene Manager allows scenes to be split into a set of pages. Only those pages that are being used need be loaded at any given time, allowing arbitrarily large scenes. Each page has its own heightmap, to which several textures can be applied by height. (This allows snowy-peaked mountains within a green landscape, for example.)
The current version in development is paging landscape manager 2 (PLSM2).
(Please read this whole WIKI page before posting)
Latest win32 Binary Demo and sample Maps is here (03/07/2005)
The SVN PLSM2 code is the latest PLSM2, and the only compatible with latest Ogre (1.6 and above)Download The zipped source of PLSM2 at this site which is OGRE 1.2 SDK compatible
There are currently 4 components available via SVN :
- paging landscape manager plugin itself.
- paging landscape demo application showing all possibilities
- Mapsplitter tool
- Paging Landscape Editor (deprecated)
you may see other folder regarding WIP (IPLSM) and older version (PLSM1)
This plugin incorporates all you need in a terrain scene manager, it’s not just about paging:
- Optimised rendering, in terms of memory (vertex compression aka displacment mapping, texture coordinates sharing) and speed (LOD).
- Real-Time Deformations
- Quality render with splatting, morphing, real-time mountain shadows, huge texture (can be bigger than heightmap page size (having a 2048x2048 texture for a 513x513 page is possible))
- Its flexibility, as all texture modes and datasource can be plugged in and out, tilesize and page size
- Map loading, unloading and changing at the speed of light.
- Build on top of an octree scene manager it handles all sort of queries (ray, sphere, box, etc...)
- Offers software horizon occlusion culling. (Hardware occlusion query is to come)
- To be used with maptool and mapeditor, that splits map generates automatically, at the resolution choosen, normal map, horizon maps, texture maps, etc... in order to help you texturize the terrain.
- Coherent Occlusion Culling : meaning that objects hidden to viewer is not rendered at all, saving precious FPS.
- Real-Time Deformations (Craters predefined, user can submit a Float Array containing Delta to apply to terrain, like a Brush in a paint tool.)
- 10 different texturing methods :
- Splatting (using multi-texture, multi-pass or using shaders)
- Real-Time Texturing (creates Textures on the fly, or updates it upon deformations)
- Geomipmaping LOD (LOD choice comes upon tile complexity, screen size and camera to tile distance)
- GeoMorphing between Lod transition (using vertex shaders, it’s visually great but is slower and takes more GPU memory. I would consider using it with 128 memory GPU card at least of one years old GPU ( ATI 9800, NVIDIA geforce fx 5,6 or when wihtout it, and you have at least 140 fps in windowed mode. (be aware that fullscreen mode is faster.)
- Octree Culling .
- Horizon Culling (do not show tiles hidden by moutains)
- Displacement mapping : defining a point only by its Y instead of X,Y,Z (using vertex shaders, divides GPU memory by 3, named VertexCompression in cfg files)
- Buffer Sharing Texture coordinates and IndexBuffers sharing across pages (saves GPU memory by number of pages)
- Tiles and Renderables Pooling.
- Load Queues : Data, Texture and uploading to GPU are done separatly and not at the same time, preventing frame hits. Pages are queued and loaded using a distance to cam sort (nearest pages loaded first).
- Paging Event Listener that gives you Load, unload, deformed events, along with a pointer to heighfield data.
- Perfect Ray Scene Queries that interpolates between terrain vertices even near boundaries of tile/page (stitching make it harder on this case.)
Data Source Loading Modes defines how your land heights will be loaded. You can use a 8bits image (any format devil supports), or use 16 bits Raw (as it can be exported from terragen). It can transform heights on Load (TC) or loads land Normals along with land heights.
Raw is recommended for best details.
- Ogre::PagingLandScapeData2D_HeightField : Loads data from a 8bits grey image.
- Ogre::PagingLandScapeData2D_HeightFieldN : Loads data from a 8bits grey image, and Normals from 32bits image
- Ogre::PagingLandScapeData2D_HeightFieldRaw : Loads data from 16bits rawimage
- Ogre::PagingLandScapeData2D_HeightFieldRawTC : Loads data from 16bits rawimage and expands heights using TC algo.
- Ogre::PagingLandScapeData2D_HeightFieldTC : Loads data from 8bits grey image and expands heights using TC algo.
- Ogre::PagingLandScapeData2D_HeightFieldNTC : Loads data from 8bits grey image and expands heights using TC algo, and Normals from 32bits image
- Ogre::PagingLandScapeData2D_Spline : create on the fly spline terrain
- Ogre::PagingLandScapeData2D_HeightFieldBlendNeighbor: Loads data from a 8bits grey image, and blend it with already loaded neighbors. (dynamically created pages)
- intensively tested and supported.
Texture Mode choose how your land will be colored.
You can use a big image per Page (Color Texture Modes), or use splatting that would give better near terrain detail, but use more GPU and memory Power.
Color Texture Modes :
fixed pipeline :
- Image : Uses a User given Map.(generated with terragen, for example.)
- BaseTexture : Computes a Color Map based on height and slope
- BaseTexture2 : like BaseTexture but using precomputed map
- InstantBase : like BaseTexture but using precomputed map, and reflect deformation on terrain dynamically.
- InstantBaseShadowed : like BaseTexture but using precomputed map, with dynamically shadow changes upon sun position.
Splatting Modes :
fixed pipeline :
- Splatting : Computes 4 alpha maps (one for each splats, based on height and slope) => 4 passes 2 texture unit
- Splatting2 : like “splatting” (using precomputed 4 alpha maps) ) => 4 passes 2 texture unit
- Splatting4 : like splatting2 but 7 texture units per pass (using precomputed 4 alpha maps) => 1 passes 7 texture unit
- Splatting5 : like splatting4 but 4 texture units 1 pass, use of a Pixel Shader (arbfp1 or ps_2_0) 1 passes 4 texture unit all real-time (no alpha maps, so uses less texture units)
- SplattingShader : like splatting4 but 4 texture units 1 pass, use of a Pixel Shader (arbfp1 or ps_2_0) 1 passes 7 texture (using alpha maps.)
Splatting Lighted Modes :
- splatting3 : One pass, 3 Texture Units + one for light = 4. (using precomputed 3 alpha maps)
- Splatting6 : like splatting2 but 3 texture units per Pass, 4 Pass (using precomputed 4 alpha maps)
- Splatting7 : multitexturing splatting using 6 Texture Unit in one Pass (using precomputed 3 alpha maps)
Provide the Plugin the material script you want to use using CFG file or setOption mechanism.
Inside the material script you provide, just use keyword inside material scripts : Splatting, Alpha, Coverage, Horizon, Image, Light and those keywords will be dynamically replaced by the related page texture (Coverage will become coverage.1.2.0.png if page X is 1 and page Z is 2 and Coverage keyword is read for the first time in this material technique.)(case sensitive.)
Best may be to have a look on plsm2 provided texture mode material scripts to read some samples on how to do that.
- MaxPixelError : The maximum error allowed when determining which LOD to use. That would determine complexity on screen. More Precise means slower.
- PageSize : determines how ‘GPU batched’ your terrain will be, as it determines the size of the texture per page. Bigger is Better, but not all video card would support too big texture. (note that plsm2 demos uses small pagesize like 257, mainly for page management testing), that can lead to false impression that PLSM2 is slower than TSM. At same pagesize and number of page, you’d get same results or faster. try 1025, 2049.
- TileSize : Difficult to tweak, determines how big a Vertex Buffer will be. Using Too big Tilesize (> 193). make plsm2 to use 32 bits index buffers (slower and not supported on all video cards). using too small Tilesize (<65) would make plsm2 handle thousands of tiles each frames and wouldn’t be very GPU Batch friendly, but gives much more Culling opportunities (Frustum Culling, Horizon Culling, Octree Culling...)
- VertexCompression : If your card supports it, enable it (if you card doesn’t suport it will be ignored). It divides GPU Memory usage by at least factor 3.
- VertexProgramMorph : If you notice too much popping when tiles changes Lod, this reduce it a lot. But it has a big performance cost, so in case of bad performance, be sure to diable it. (on ATI opengl, it leads to a driver bug.)
- HorizonVisibilityComputing : enable it if your map have moutains, cliffs... not if it’s mainly a plane. Everything (for now just other terrain tiles, soon also any objects) hidden by Terrain Tiles will not be send to GPU, saving massive amounts of framerates, but in particular case. (didn’t cost much if enabled anyway.)
- Using setOption, getOption Mechanism, per camera, you set the occlusion mechanism.
scenemgr->setOption ("NextCullMode", myCamObject); scenemgr->setOption ("setCullingMode", "VIEW_FRUSTUM_DIRECT") scenemgr->setOption ("setCullingMode", "CHC") scenemgr->setOption ("setCullingMode", "CHC_CONSERVATIVE")
- Nodes are now either static or movable (use static in entity names), so they’re either in Octree or loose octree.Nodes are either Occluders, Occludee or none (skipping tests.).
- A node is a static if containing only entities that name begins with “Static”.
- They’re Occluders only if containing entities that begins with “StaticOccluder”.
(StaticGeometry, Terrain Renderables are static occluder by default.)
- They’re Occludees only if containing entities that begins with “Occludee”.
- F1 = cycle Help / debug panels
- M = Switch between camera mode and cursor mode (that enable deformation, and sphere test)
- K = Texture Mode changes, ‘n’, ‘p’ or ‘l’ for map changes.
- N, P or L, = Load Next, Previous or reload map.
- LEFT CONTROL = Increase the moving speed
- A = Move Left
- D = Move Right
- W = Move Forward
- S = Move Backward
- PgUp = Move Up
- PgDn = Move Down
- Cursor Right = Rotate Right
- Cursor Left = Rotate Left
- ESC = Exit
- F = Show/Hide the debug overlay
- T = render terrain Solid/Wireframe
- PrtSc = Makes a Screenshot
- F2 = Display the terrain height at the current position.
The map splitter breaks the terrain into sections which the manager can page in as required, precomputes and generates the base texture and splatting textures. It can also compute lights maps and blur heightmaps. All parameters come from config files: maptool.cfg and one config file per map. The maptool.cfg file “DefaultMap” entry names the config files for each map to be generated. maptool.cfg is basically a list of maps to be split, in batch mode or one at a time.
Since MapSplitter is an Ogre application the plugins and resources config files must also be setup correctly. At runtime the program will generate a text file with a .log extension. If there are problems this log file will probably have enough information for debugging.
The input to the mapsplitter is a large single terrain heightmap that will be split into pages, with correct size and format, so that you can run the plugin. (It won’t work with unsplit heightfield maps. (unless you’re using only one page.))
- Supported formats : 8 bit heightmaps (all DevIL supported format) and 16 bits Raw files
- Suggested tools to generate heightmaps
- searching !
- Please Report plsm2 ogre addon forum
- Fast Terrain Rendering Using Geometrical MipMapping by William de Boer (implemented)
- Coherent Hierarchical Culling (implemented)
- Near Optimal Hierarchical Culling (not yet implemented)
- Rendering Outdoor Light Scattering in Real Time (not yet totally implemented, only moutain shadowing code)
- Terrain Occlusion Culling with Horizons Glenn Fiedler Game Programming Gems 4 (not yet implemented)
- LOD-Sprite Technique for Accelerated Terrain Rendering (not yet implemented)