OGRE  1.9.0
OgreTerrain.h
Go to the documentation of this file.
1/*
2-----------------------------------------------------------------------------
3This source file is part of OGRE
4(Object-oriented Graphics Rendering Engine)
5For the latest info, see http://www.ogre3d.org/
6
7Copyright (c) 2000-2014 Torus Knot Software Ltd
8
9Permission is hereby granted, free of charge, to any person obtaining a copy
10of this software and associated documentation files (the "Software"), to deal
11in the Software without restriction, including without limitation the rights
12to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13copies of the Software, and to permit persons to whom the Software is
14furnished to do so, subject to the following conditions:
15
16The above copyright notice and this permission notice shall be included in
17all copies or substantial portions of the Software.
18
19THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25THE SOFTWARE.
26-----------------------------------------------------------------------------
27*/
28
29#ifndef __Ogre_Terrain_H__
30#define __Ogre_Terrain_H__
31
33#include "OgreCommon.h"
34#include "OgreVector3.h"
35#include "OgreAxisAlignedBox.h"
36#include "OgreSceneManager.h"
39#include "OgreWorkQueue.h"
41
42namespace Ogre
43{
264 {
265 public:
266 friend class TerrainLodManager;
267
272 virtual ~Terrain();
273
278
291
292 static const size_t LOD_MORPH_CUSTOM_PARAM;
293
295
299 {
304
306 : worldSize(100) {}
307 };
309
312 {
314 ALIGN_X_Z = 0,
316 ALIGN_X_Y = 1,
318 ALIGN_Y_Z = 2
319 };
320
325 {
347
353
356
363
369
374
383
388
399
401 : terrainAlign(ALIGN_X_Z)
402 , terrainSize(1025)
403 , maxBatchSize(65)
404 , minBatchSize(17)
405 , pos(Vector3::ZERO)
406 , worldSize(1000)
407 , inputImage(0)
408 , inputFloat(0)
409 , constantHeight(0)
410 , deleteInputData(false)
411 , inputScale(1.0)
412 , inputBias(0.0)
413 {
414
415 }
416
418 : terrainAlign(ALIGN_X_Z)
419 , terrainSize(1025)
420 , maxBatchSize(65)
421 , minBatchSize(17)
422 , pos(Vector3::ZERO)
423 , worldSize(1000)
424 , inputImage(0)
425 , inputFloat(0)
426 , constantHeight(0)
427 , deleteInputData(false)
428 , inputScale(1.0)
429 , inputBias(0.0)
430 {
431 *this = rhs;
432 }
433
435 {
436 // basic copy
437 terrainAlign = rhs.terrainAlign;
438 terrainSize = rhs.terrainSize;
439 maxBatchSize = rhs.maxBatchSize;
440 minBatchSize = rhs.minBatchSize;
441 pos = rhs.pos;
442 worldSize = rhs.worldSize;
443 constantHeight = rhs.constantHeight;
444 deleteInputData = rhs.deleteInputData;
445 inputScale = rhs.inputScale;
446 inputBias = rhs.inputBias;
447 layerDeclaration = rhs.layerDeclaration;
448 layerList = rhs.layerList;
449
450 // By-value copies in ownership cases
451 if (rhs.deleteInputData)
452 {
453 if (rhs.inputImage)
454 inputImage = OGRE_NEW Image(*rhs.inputImage);
455 else
456 inputImage = 0;
457
458 if (rhs.inputFloat)
459 {
460 inputFloat = OGRE_ALLOC_T(float, terrainSize*terrainSize, MEMCATEGORY_GEOMETRY);
461 memcpy(inputFloat, rhs.inputFloat, sizeof(float) * terrainSize*terrainSize);
462 }
463 else
464 inputFloat = 0;
465 }
466 else
467 {
468 // re-use pointers
469 inputImage = rhs.inputImage;
470 inputFloat = rhs.inputFloat;
471 }
472 return *this;
473 }
474
476 void destroy()
477 {
478 if (deleteInputData)
479 {
480 OGRE_DELETE inputImage;
481 OGRE_FREE(inputFloat, MEMCATEGORY_GEOMETRY);
482 inputImage = 0;
483 inputFloat = 0;
484 }
485
486 }
487
489 {
490 destroy();
491 }
492
493 };
494
497 {
498 NEIGHBOUR_EAST = 0,
499 NEIGHBOUR_NORTHEAST = 1,
500 NEIGHBOUR_NORTH = 2,
501 NEIGHBOUR_NORTHWEST = 3,
502 NEIGHBOUR_WEST = 4,
503 NEIGHBOUR_SOUTHWEST = 5,
504 NEIGHBOUR_SOUTH = 6,
505 NEIGHBOUR_SOUTHEAST = 7,
506
507 NEIGHBOUR_COUNT = 8
508 };
509
510 SceneManager* getSceneManager() const { return mSceneMgr; }
511
513 enum Space
514 {
516 WORLD_SPACE = 0,
518 LOCAL_SPACE = 1,
522 TERRAIN_SPACE = 2,
526 POINT_SPACE = 3
527 };
528
534 {
535 public:
538
544 virtual void allocateVertexBuffers(Terrain* forTerrain, size_t numVertices, HardwareVertexBufferSharedPtr& destPos, HardwareVertexBufferSharedPtr& destDelta) = 0;
547 virtual void freeVertexBuffers(const HardwareVertexBufferSharedPtr& posbuf, const HardwareVertexBufferSharedPtr& deltabuf) = 0;
548
564 uint16 vdatasize, size_t vertexIncrement, uint16 xoffset, uint16 yoffset, uint16 numSkirtRowsCols,
565 uint16 skirtRowColSkip) = 0;
566
568 virtual void freeAllBuffers() = 0;
569
570 };
573 {
574 public:
577 void allocateVertexBuffers(Terrain* forTerrain, size_t numVertices, HardwareVertexBufferSharedPtr& destPos, HardwareVertexBufferSharedPtr& destDelta);
580 uint16 vdatasize, size_t vertexIncrement, uint16 xoffset, uint16 yoffset, uint16 numSkirtRowsCols,
581 uint16 skirtRowColSkip);
583
587 void warmStart(size_t numInstances, uint16 terrainSize, uint16 maxBatchSize,
588 uint16 minBatchSize);
589
590 protected:
596
598 uint16 vdatasize, size_t vertexIncrement, uint16 xoffset, uint16 yoffset, uint16 numSkirtRowsCols,
599 uint16 skirtRowColSkip);
600 HardwareVertexBufferSharedPtr getVertexBuffer(VBufList& list, size_t vertexSize, size_t numVertices);
601
602 };
603
609
612
614 static size_t _getNumIndexesForBatchSize(uint16 batchSize);
626 static void _populateIndexBuffer(uint16* pIndexes, uint16 batchSize,
627 uint16 vdatasize, size_t vertexIncrement, uint16 xoffset, uint16 yoffset, uint16 numSkirtRowsCols,
628 uint16 skirtRowColSkip);
629
631 static uint16 _calcSkirtVertexIndex(uint16 mainIndex, uint16 vdatasize, bool isCol,
632 uint16 numSkirtRowsCols, uint16 skirtRowColSkip);
633
640 void convertPosition(Space inSpace, const Vector3& inPos, Space outSpace, Vector3& outPos) const;
647 Vector3 convertPosition(Space inSpace, const Vector3& inPos, Space outSpace) const;
654 void convertDirection(Space inSpace, const Vector3& inDir, Space outSpace, Vector3& outDir) const;
661 Vector3 convertDirection(Space inSpace, const Vector3& inDir, Space outSpace) const;
662
667 void setResourceGroup(const String& resGroup) { mResourceGroup = resGroup; }
668
672 const String& getResourceGroup() const { return mResourceGroup; }
673
677
686 void save(const String& filename);
692 void save(StreamSerialiser& stream);
693
700 bool prepare(const String& filename);
707 bool prepare(DataStreamPtr& stream);
715
721 bool prepare(const ImportData& importData);
722
728 void load(const String& filename);
729
735 void load(StreamSerialiser& stream);
736
743 void load(int lodLevel = 0, bool synchronous = true);
744
750 bool isLoaded() const { return mIsLoaded; }
751
756 bool isModified() const { return mModified; }
757
758
763 bool isHeightDataModified() const { return mHeightDataModified; }
764
765
770 void unload();
771
776 void unprepare();
777
778
788 float* getHeightData() const;
789
792 float* getHeightData(long x, long y) const;
793
798 float getHeightAtPoint(long x, long y) const;
799
806 void setHeightAtPoint(long x, long y, float h);
807
812
819
825 float getHeightAtWorldPosition(const Vector3& pos) const;
826
833 const float* getDeltaData() const;
834
837 const float* getDeltaData(long x, long y) const;
838
843 void getPoint(long x, long y, Vector3* outpos) const;
844
850 void getPointFromSelfOrNeighbour(long x, long y, Vector3* outpos) const;
851
856 void getPoint(long x, long y, float height, Vector3* outpos) const;
860 void getPointTransform(Matrix4* outXform) const;
865 void getTerrainVector(const Vector3& inVec, Vector3* outVec) const;
870 void getTerrainVectorAlign(const Vector3& inVec, Alignment align, Vector3* outVec) const;
871
876 void getTerrainVector(Real x, Real y, Real z, Vector3* outVec) const;
881 void getTerrainVectorAlign(Real x, Real y, Real z, Alignment align, Vector3* outVec) const;
882
887 void getVector(const Vector3& inVec, Vector3* outVec) const;
892 void getVectorAlign(const Vector3& inVec, Alignment align, Vector3* outVec) const;
893
898 void getVector(Real x, Real y, Real z, Vector3* outVec) const;
903 void getVectorAlign(Real x, Real y, Real z, Alignment align, Vector3* outVec) const;
904
905
913 void getPosition(const Vector3& TSpos, Vector3* outWSpos) const;
921 void getPosition(Real x, Real y, Real z, Vector3* outWSpos) const;
922
929 void getTerrainPosition(const Vector3& WSpos, Vector3* outTSpos) const;
936 void getTerrainPosition(Real x, Real y, Real z, Vector3* outTSpos) const;
943 void getPositionAlign(const Vector3& TSpos, Alignment align, Vector3* outWSpos) const;
950 void getPositionAlign(Real x, Real y, Real z, Alignment align, Vector3* outWSpos) const;
951
958 void getTerrainPositionAlign(const Vector3& WSpos, Alignment align, Vector3* outTSpos) const;
965 void getTerrainPositionAlign(Real x, Real y, Real z, Alignment align, Vector3* outTSpos) const;
966
967
976 void setSize(uint16 newSize);
986 void setWorldSize(Real newWorldSize);
987
989 uint8 getLayerCount() const { return static_cast<uint8>(mLayers.size()); }
990
992 const TerrainLayerDeclaration& getLayerDeclaration() const { return mLayerDecl; }
993
1000 void addLayer(Real worldSize = 0, const StringVector* textureNames = 0);
1001
1009 void addLayer(uint8 index, Real worldSize = 0, const StringVector* textureNames = 0);
1010
1013 void removeLayer(uint8 index);
1014
1024 void replaceLayer(uint8 index, bool keepBlends, Real worldSize = 0, const StringVector* textureNames = 0);
1025
1030
1041 void setLayerWorldSize(uint8 index, Real size);
1042
1052
1058 const String& getLayerTextureName(uint8 layerIndex, uint8 samplerIndex) const;
1065 void setLayerTextureName(uint8 layerIndex, uint8 samplerIndex, const String& textureName);
1066
1073 uint16 getLayerBlendMapSize() const { return mLayerBlendMapSize; }
1074
1080 uint16 getLightmapSize() const { return mLightmapSize; }
1081
1083 const TexturePtr& getLightmap() const { return mLightmap; }
1084
1090 uint16 getCompositeMapSize() const { return mCompositeMapSize; }
1091
1093 const TexturePtr& getCompositeMap() const { return mCompositeMap; }
1094
1096 const Vector3& getPosition() const { return mPos; }
1098 void setPosition(const Vector3& pos);
1107 void dirty();
1108
1117 void dirtyRect(const Rect& rect);
1118
1124 void _dirtyCompositeMapRect(const Rect& rect);
1125
1136 void dirtyLightmapRect(const Rect& rect);
1137
1149
1172 void update(bool synchronous = false);
1173
1185
1186 // Used as a type mask for updateDerivedData
1191
1203 void updateDerivedData(bool synchronous = false, uint8 typeMask = 0xFF);
1204
1214
1229
1230
1234 Real getSkirtSize() const { return mSkirtSize; }
1235
1237 uint16 getNumLodLevels() const { return mNumLodLevels; }
1238
1240 uint16 getNumLodLevelsPerLeaf() const { return mNumLodLevelsPerLeafNode; }
1241
1250
1258 void finaliseHeightDeltas(const Rect& rect, bool cpuData);
1259
1265 PixelBox* calculateNormals(const Rect& rect, Rect& outFinalRect);
1266
1274 void finaliseNormals(const Rect& rect, PixelBox* normalsBox);
1275
1283 PixelBox* calculateLightmap(const Rect& rect, const Rect& extraTargetRect, Rect& outFinalRect);
1284
1292 void finaliseLightmap(const Rect& rect, PixelBox* lightmapBox);
1293
1298
1310 std::pair<bool, Vector3> rayIntersects(const Ray& ray,
1311 bool cascadeToNeighbours = false, Real distanceLimit = 0); //const;
1312
1314 const AxisAlignedBox& getAABB() const;
1323
1325 const MaterialPtr& getMaterial() const;
1327 const MaterialPtr& _getMaterial() const { return mMaterial; }
1331 const MaterialPtr& _getCompositeMapMaterial() const { return mCompositeMapMaterial; }
1332
1334 const String& getMaterialName() const { return mMaterialName; }
1335
1341
1343 uint8 getRenderQueueGroup(void) const { return mRenderQueueGroup; }
1347 void setRenderQueueGroup(uint8 grp) { mRenderQueueGroup = grp; }
1348
1350 uint32 getVisibilityFlags(void) const { return mVisibilityFlags; }
1354 void setVisibilityFlags(uint32 flags) { mVisibilityFlags = flags; }
1355
1357 uint32 getQueryFlags(void) const { return mQueryFlags; }
1361 void setQueryFlags(uint32 flags) { mQueryFlags = flags; }
1362
1364 void addQueryFlags(uint32 flags) { mQueryFlags |= flags; }
1365
1366 /* As setQueryFlags, except the flags passed as parameters are removed from the existing flags on this object. */
1367 void removeQueryFlags(uint32 flags) { mQueryFlags &= ~flags; }
1368
1369
1383
1390
1395
1396
1401 const String& getBlendTextureName(uint8 textureIndex) const;
1402
1415 void setGlobalColourMapEnabled(bool enabled, uint16 size = 0);
1417 bool getGlobalColourMapEnabled() const { return mGlobalColourMapEnabled; }
1419 uint16 getGlobalColourMapSize() const { return mGlobalColourMapSize; }
1421 const TexturePtr& getGlobalColourMap() const { return mColourMap; }
1422
1428 void widenRectByVector(const Vector3& vec, const Rect& inRect, Rect& outRect);
1429
1437 void widenRectByVector(const Vector3& vec, const Rect& inRect,
1438 Real minHeight, Real maxHeight, Rect& outRect);
1439
1450
1456
1463 std::pair<uint8,uint8> getLayerBlendTextureIndex(uint8 layerIndex) const;
1464
1475 void _setMorphRequired(bool morph) { mLodMorphRequired = morph; }
1477 bool _getMorphRequired() const { return mLodMorphRequired; }
1478
1490 void _setNormalMapRequired(bool normalMap);
1491
1505 void _setLightMapRequired(bool lightMap, bool shadowsOnly = false);
1506
1525 void _setCompositeMapRequired(bool compositeMap);
1526
1529
1531 bool canHandleRequest(const WorkQueue::Request* req, const WorkQueue* srcQ);
1535 bool canHandleResponse(const WorkQueue::Response* res, const WorkQueue* srcQ);
1537 void handleResponse(const WorkQueue::Response* res, const WorkQueue* srcQ);
1540
1543
1547 uint16 getLODLevelWhenVertexEliminated(long rowOrColulmn) const;
1548
1549
1551 TerrainQuadTreeNode* getQuadTree() { return mQuadTree; }
1552
1554 TexturePtr getTerrainNormalMap() const { return mTerrainNormalMap; }
1555
1564
1582 void setNeighbour(NeighbourIndex index, Terrain* neighbour, bool recalculate = false, bool notifyOther = true);
1583
1589
1592 static NeighbourIndex getNeighbourIndex(long offsetx, long offsety);
1593
1602
1610 void neighbourModified(NeighbourIndex index, const Rect& edgerect, const Rect& shadowrect);
1611
1617 Terrain* raySelectNeighbour(const Ray& ray, Real distanceLimit = 0);
1618
1623 void _dumpTextures(const String& prefix, const String& suffix);
1624
1626 bool isDerivedDataUpdateInProgress() const { return mDerivedDataUpdateInProgress; }
1627
1628
1630 static void convertWorldToTerrainAxes(Alignment align, const Vector3& worldVec, Vector3* terrainVec);
1632 static void convertTerrainToWorldAxes(Alignment align, const Vector3& terrainVec, Vector3* worldVec);
1633
1641 static bool readLayerInstanceList(StreamSerialiser& ser, size_t numSamplers, Terrain::LayerInstanceList& targetlst);
1642
1643 // This mutex is write-locked by neighbours if they are in the process of deleting themselves.
1644 // It should be read-locked whenever using neighbours in calculations which are possibly running in a
1645 // background thread.
1646 OGRE_RW_MUTEX(mNeighbourMutex);
1647
1648 protected:
1657 inline int getPositiveLodLevel( int lodLevel ) const
1658 {
1659 return (lodLevel>=0) ? lodLevel : mNumLodLevels+lodLevel;
1660 }
1662
1675 void convertSpace(Space inSpace, const Vector3& inVec, Space outSpace, Vector3& outVec, bool translation) const;
1681 void getPointAlign(long x, long y, Alignment align, Vector3* outpos) const;
1686 void getPointAlign(long x, long y, float height, Alignment align, Vector3* outpos) const;
1689 std::pair<bool, Vector3> checkQuadIntersection(int x, int y, const Ray& ray); //const;
1690
1692 void deleteBlendMaps(uint8 lowIndex);
1698 void copyBlendTextureChannel(uint8 srcIndex, uint8 srcChannel, uint8 destIndex, uint8 destChannel );
1700 void clearGPUBlendChannel(uint8 index, uint channel);
1701
1703 void checkLayers(bool includeGPUResources);
1706 PixelFormat getBlendTextureFormat(uint8 textureIndex, uint8 numLayers) const;
1707
1708 void updateDerivedDataImpl(const Rect& rect, const Rect& lightmapExtraRect, bool synchronous, uint8 typeMask);
1709
1710 void getEdgeRect(NeighbourIndex index, long range, Rect* outRect) const;
1711 // get the equivalent of the passed in edge rectangle in neighbour
1712 void getNeighbourEdgeRect(NeighbourIndex index, const Rect& inRect, Rect* outRect) const;
1713 // get the equivalent of the passed in edge point in neighbour
1714 void getNeighbourPoint(NeighbourIndex index, long x, long y, long *outx, long *outy) const;
1715 // overflow a point into a neighbour index and point
1716 void getNeighbourPointOverflow(long x, long y, NeighbourIndex *outindex, long *outx, long *outy) const;
1717
1720
1728
1750
1755
1763
1769 {
1771 // types requested
1775 _OgreTerrainExport friend std::ostream& operator<<(std::ostream& o, const DerivedDataRequest& r)
1776 { return o; }
1777 };
1778
1781 {
1794 _OgreTerrainExport friend std::ostream& operator<<(std::ostream& o, const DerivedDataResponse& r)
1795 { return o; }
1796 };
1797
1800 GEN_COMPOSITE_MAP_MATERIAL
1804 {
1806 unsigned long startTime;
1809 _OgreTerrainExport friend std::ostream& operator<<(std::ostream& o, const GenerateMaterialRequest& r)
1810 { return o; }
1811 };
1812
1816 mutable unsigned long long int mMaterialGenerationCount;
1817 mutable bool mMaterialDirty;
1819
1828
1833
1838
1845 unsigned long mLastMillis;
1849
1850
1855
1863
1866
1868 unsigned long mLastLODFrame;
1870
1871 Terrain* mNeighbours[NEIGHBOUR_COUNT];
1872
1875
1878
1880
1881 public:
1885 void increaseLodLevel(bool synchronous = false);
1890
1891 int getHighestLodPrepared() const { return (mLodManager) ? mLodManager->getHighestLodPrepared() : -1; };
1892 int getHighestLodLoaded() const { return (mLodManager) ? mLodManager->getHighestLodLoaded() : -1; };
1893 int getTargetLodLevel() const { return (mLodManager) ? mLodManager->getTargetLodLevel() : -1; };
1894 };
1895
1896
1906 class _OgreTerrainExport TerrainGlobalOptions : public TerrainAlloc, public Singleton<TerrainGlobalOptions>
1907 {
1908 protected:
1909
1929
1930 public:
1933
1934
1938 Real getSkirtSize() const { return mSkirtSize; }
1944 void setSkirtSize(Real skirtSz) { mSkirtSize = skirtSz; }
1946 const Vector3& getLightMapDirection() const { return mLightMapDir; }
1948 void setLightMapDirection(const Vector3& v) { mLightMapDir = v; }
1950 const ColourValue& getCompositeMapAmbient() const { return mCompositeMapAmbient; }
1952 void setCompositeMapAmbient(const ColourValue& c) { mCompositeMapAmbient = c; }
1954 const ColourValue& getCompositeMapDiffuse() const { return mCompositeMapDiffuse; }
1956 void setCompositeMapDiffuse(const ColourValue& c) { mCompositeMapDiffuse = c; }
1958 Real getCompositeMapDistance() const { return mCompositeMapDistance; }
1960 void setCompositeMapDistance(Real c) { mCompositeMapDistance = c; }
1961
1962
1966 bool getCastsDynamicShadows() const { return mCastsShadows; }
1967
1973 void setCastsDynamicShadows(bool s) { mCastsShadows = s; }
1974
1976 Real getMaxPixelError() const { return mMaxPixelError; }
1977
1983 void setMaxPixelError(Real pixerr) { mMaxPixelError = pixerr; }
1984
1986 uint8 getRenderQueueGroup(void) const { return mRenderQueueGroup; }
1991 void setRenderQueueGroup(uint8 grp) { mRenderQueueGroup = grp; }
1992
1994 uint32 getVisibilityFlags(void) const { return mVisibilityFlags; }
1999 void setVisibilityFlags(uint32 flags) { mVisibilityFlags = flags; }
2000
2005 void setQueryFlags(uint32 flags) { mQueryFlags = flags; }
2008 uint32 getQueryFlags(void) const { return mQueryFlags; }
2009
2011 void addQueryFlags(uint32 flags) { mQueryFlags |= flags; }
2012
2013 /* As setQueryFlags, except the flags passed as parameters are removed from the existing flags on this object. */
2014 void removeQueryFlags(uint32 flags) { mQueryFlags &= ~flags; }
2015
2020 bool getUseRayBoxDistanceCalculation() const { return mUseRayBoxDistanceCalculation; }
2021
2033 void setUseRayBoxDistanceCalculation(bool rb) { mUseRayBoxDistanceCalculation = rb; }
2034
2038
2042
2045 uint16 getLayerBlendMapSize() const { return mLayerBlendMapSize; }
2046
2051 void setLayerBlendMapSize(uint16 sz) { mLayerBlendMapSize = sz;}
2052
2055 Real getDefaultLayerTextureWorldSize() const { return mDefaultLayerTextureWorldSize; }
2056
2059 void setDefaultLayerTextureWorldSize(Real sz) { mDefaultLayerTextureWorldSize = sz; }
2060
2063 uint16 getDefaultGlobalColourMapSize() const { return mDefaultGlobalColourMapSize; }
2064
2068 void setDefaultGlobalColourMapSize(uint16 sz) { mDefaultGlobalColourMapSize = sz;}
2069
2070
2073 uint16 getLightMapSize() const { return mLightmapSize; }
2074
2077 void setLightMapSize(uint16 sz) { mLightmapSize = sz;}
2078
2081 uint16 getCompositeMapSize() const { return mCompositeMapSize; }
2082
2085 void setCompositeMapSize(uint16 sz) { mCompositeMapSize = sz;}
2086
2089 void setDefaultResourceGroup(const String& grp) { mResourceGroup = grp; }
2090
2093 const String& getDefaultResourceGroup() const { return mResourceGroup; }
2094
2098 bool getUseVertexCompressionWhenAvailable() const { return mUseVertexCompressionWhenAvailable; }
2099
2107 void setUseVertexCompressionWhenAvailable(bool enable) { mUseVertexCompressionWhenAvailable = enable; }
2108
2141
2142
2143 };
2144
2145
2148}
2149
2150
2151
2152
2153#endif
#define _OgreTerrainExport
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
A 3D box aligned with the x/y/z axes.
A viewpoint from which the scene will be rendered.
Definition OgreCamera.h:87
Class representing colour.
Shared pointer implementation used to share index buffers.
Shared pointer implementation used to share vertex buffers.
Class representing an image file.
Definition OgreImage.h:62
Class encapsulating a standard 4x4 homogeneous matrix.
Definition OgreMatrix4.h:79
Utility class to generate a sequentially numbered series of names.
A primitive describing a volume (3D), image (2D) or line (1D) of pixels in memory.
Representation of a ray in space, i.e.
Definition OgreRay.h:47
Class that allows listening in on the various stages of SceneManager processing, so that custom behav...
Manages the organisation and rendering of a 'scene' i.e.
IlluminationRenderStage
Describes the stage of rendering when performing complex illumination.
Class representing a node in the scene graph.
Template class for creating single-instance global classes.
Utility class providing helper methods for reading / writing structured data held in a DataStream.
Options class which just stores default options for the terrain.
TerrainMaterialGeneratorPtr getDefaultMaterialGenerator()
Get the default material generator.
void setUseVertexCompressionWhenAvailable(bool enable)
Set whether to allow vertex compression to be used when the material generator states that it support...
void setDefaultResourceGroup(const String &grp)
Set the default resource group to use to load / save terrains.
void setCompositeMapSize(uint16 sz)
Sets the default size of composite maps for a new terrain.
Real getDefaultLayerTextureWorldSize() const
Get the default world size for a layer 'splat' texture to cover.
void setCompositeMapAmbient(const ColourValue &c)
Set the composite map ambient light to use.
Real getMaxPixelError() const
Get the maximum screen pixel error that should be allowed when rendering.
void setMaxPixelError(Real pixerr)
Set the maximum screen pixel error that should be allowed when rendering.
static TerrainGlobalOptions * getSingletonPtr(void)
Override standard Singleton retrieval.
void setSkirtSize(Real skirtSz)
method - the default size of 'skirts' used to hide terrain cracks (default 10)
const ColourValue & getCompositeMapAmbient() const
Get the composite map ambient light to use.
void setCompositeMapDiffuse(const ColourValue &c)
Set the composite map diffuse light to use.
void setUseRayBoxDistanceCalculation(bool rb)
Sets whether to use an accurate ray / box intersection to determine distance from a terrain tile,...
bool getUseRayBoxDistanceCalculation() const
Returns whether or not to use an accurate calculation of camera distance from a terrain tile (ray / A...
Real getSkirtSize() const
The default size of 'skirts' used to hide terrain cracks (default 10)
void setLightMapDirection(const Vector3 &v)
Set the shadow map light direction to use (world space).
uint16 getLightMapSize() const
Get the default size of the lightmaps for a new terrain.
const ColourValue & getCompositeMapDiffuse() const
Get the composite map iffuse light to use.
void setLayerBlendMapSize(uint16 sz)
Sets the default size of blend maps for a new terrain.
void setLightMapSize(uint16 sz)
Sets the default size of lightmaps for a new terrain.
Real getCompositeMapDistance() const
Get the distance at which to start using a composite map if present.
void setDefaultGlobalColourMapSize(uint16 sz)
Set the default size of the terrain global colour map for a new terrain.
void setDefaultLayerTextureWorldSize(Real sz)
Set the default world size for a layer 'splat' texture to cover.
uint32 getQueryFlags(void) const
Get the default query flags for terrains.
void setQueryFlags(uint32 flags)
Set the default query flags for terrains.
bool getCastsDynamicShadows() const
Whether the terrain will be able to cast shadows (texture shadows only are supported,...
uint16 getCompositeMapSize() const
Get the default size of the composite maps for a new terrain.
TerrainMaterialGeneratorPtr mDefaultMaterialGenerator
uint8 getRenderQueueGroup(void) const
Get the render queue group that this terrain will be rendered into.
bool getUseVertexCompressionWhenAvailable() const
Get whether to allow vertex compression to be used when the material generator states that it support...
void setVisibilityFlags(uint32 flags)
Set the visbility flags that terrains will be rendered with.
uint16 getDefaultGlobalColourMapSize() const
Get the default size of the terrain global colour map for a new terrain.
uint32 getVisibilityFlags(void) const
Get the visbility flags that terrains will be rendered with.
void setCastsDynamicShadows(bool s)
Whether the terrain will be able to cast shadows (texture shadows only are supported,...
void setCompositeMapDistance(Real c)
Set the distance at which to start using a composite map if present.
void addQueryFlags(uint32 flags)
As setQueryFlags, except the flags passed as parameters are appended to the existing flags on this ob...
uint16 getLayerBlendMapSize() const
Get the default size of the blend maps for a new terrain.
const String & getDefaultResourceGroup() const
Get the default resource group to use to load / save terrains.
void setRenderQueueGroup(uint8 grp)
Set the render queue group that terrains will be rendered into.
void setDefaultMaterialGenerator(TerrainMaterialGeneratorPtr gen)
Set the default material generator.
void removeQueryFlags(uint32 flags)
const Vector3 & getLightMapDirection() const
Get the shadow map light direction to use (world space)
static TerrainGlobalOptions & getSingleton(void)
Override standard Singleton retrieval.
Class exposing an interface to a blend map for a given layer.
Terrain LOD data manager.
A node in a quad tree used to store a patch of terrain.
Standard implementation of a buffer allocator which re-uses buffers.
map< uint32, HardwareIndexBufferSharedPtr >::type IBufMap
void freeAllBuffers()
Free any buffers we're holding.
HardwareIndexBufferSharedPtr getSharedIndexBuffer(uint16 batchSize, uint16 vdatasize, size_t vertexIncrement, uint16 xoffset, uint16 yoffset, uint16 numSkirtRowsCols, uint16 skirtRowColSkip)
Get a shared index buffer for a given number of settings.
list< HardwareVertexBufferSharedPtr >::type VBufList
HardwareVertexBufferSharedPtr getVertexBuffer(VBufList &list, size_t vertexSize, size_t numVertices)
uint32 hashIndexBuffer(uint16 batchSize, uint16 vdatasize, size_t vertexIncrement, uint16 xoffset, uint16 yoffset, uint16 numSkirtRowsCols, uint16 skirtRowColSkip)
void allocateVertexBuffers(Terrain *forTerrain, size_t numVertices, HardwareVertexBufferSharedPtr &destPos, HardwareVertexBufferSharedPtr &destDelta)
Allocate (or reuse) vertex buffers for a terrain LOD.
void warmStart(size_t numInstances, uint16 terrainSize, uint16 maxBatchSize, uint16 minBatchSize)
'Warm start' the allocator based on needing x instances of terrain with the given configuration.
void freeVertexBuffers(const HardwareVertexBufferSharedPtr &posbuf, const HardwareVertexBufferSharedPtr &deltabuf)
Free (or return to the pool) vertex buffers for terrain.
Interface used to by the Terrain instance to allocate GPU buffers.
virtual void allocateVertexBuffers(Terrain *forTerrain, size_t numVertices, HardwareVertexBufferSharedPtr &destPos, HardwareVertexBufferSharedPtr &destDelta)=0
Allocate (or reuse) vertex buffers for a terrain LOD.
virtual HardwareIndexBufferSharedPtr getSharedIndexBuffer(uint16 batchSize, uint16 vdatasize, size_t vertexIncrement, uint16 xoffset, uint16 yoffset, uint16 numSkirtRowsCols, uint16 skirtRowColSkip)=0
Get a shared index buffer for a given number of settings.
virtual void freeAllBuffers()=0
Free any buffers we're holding.
virtual void freeVertexBuffers(const HardwareVertexBufferSharedPtr &posbuf, const HardwareVertexBufferSharedPtr &deltabuf)=0
Free (or return to the pool) vertex buffers for terrain.
The main containing class for a chunk of terrain.
void getVectorAlign(const Vector3 &inVec, Alignment align, Vector3 *outVec) const
Translate a vector into world space based on a specified alignment.
PixelBox * mCpuTerrainNormalMap
Pending data.
void deleteBlendMaps(uint8 lowIndex)
Delete blend maps for all layers >= lowIndex.
TerrainLayerBlendMapList mLayerBlendMapList
void setVisibilityFlags(uint32 flags)
Set the visibility flags for this terrain.
static const uint16 WORKQUEUE_DERIVED_DATA_REQUEST
void dirtyLightmapRect(const Rect &rect)
Mark a region of the lightmap as dirty.
void sceneManagerDestroyed(SceneManager *source)
Overridden from SceneManager::Listener.
Vector3 convertPosition(Space inSpace, const Vector3 &inPos, Space outSpace) const
Convert a position from one space to another with respect to this terrain.
WorkQueue::Response * handleRequest(const WorkQueue::Request *req, const WorkQueue *srcQ)
WorkQueue::RequestHandler override.
BytePointerList mCpuBlendMapStorage
Staging post for blend map data.
void dirtyRect(const Rect &rect)
Mark a region of the terrain as dirty.
TexturePtr mCompositeMap
void createLayerBlendMaps()
void createOrDestroyGPULightmap()
bool isHeightDataModified() const
Returns whether terrain heights have been modified since the terrain was first loaded / defined.
void createOrDestroyGPUNormalMap()
void _setCompositeMapRequired(bool compositeMap)
Request internal implementation options for the terrain material to use, in this case a terrain-wide ...
bool mPrepareInProgress
Don't release Height/DeltaData when preparing.
uint32 getVisibilityFlags(void) const
Get the visibility flags for this terrain.
static void writeLayerDeclaration(const TerrainLayerDeclaration &decl, StreamSerialiser &ser)
Utility method to write a layer declaration to a stream.
static const uint64 TERRAIN_GENERATE_MATERIAL_INTERVAL_MS
uint16 getLayerBlendMapSize() const
Get the requested size of the blend maps used to blend between layers for this terrain.
static const uint16 TERRAINLAYERDECLARATION_CHUNK_VERSION
static NeighbourIndex getNeighbourIndex(long offsetx, long offsety)
Get the neighbour enum for a given offset in a grid (signed).
uint16 mGlobalColourMapSize
static NameGenerator msNormalMapNameGenerator
void clearGPUBlendChannel(uint8 index, uint channel)
Reset a blend channel back to full black.
uint16 mLightmapSizeActual
void widenRectByVector(const Vector3 &vec, const Rect &inRect, Real minHeight, Real maxHeight, Rect &outRect)
Widen a rectangular area of terrain to take into account an extrusion vector, but specify the min / m...
void finaliseNormals(const Rect &rect, PixelBox *normalsBox)
Finalise the normals.
SceneNode * _getRootSceneNode() const
Get the root scene node for the terrain (internal use only)
void getPosition(const Vector3 &TSpos, Vector3 *outWSpos) const
Convert a position from terrain basis space to world space.
uint16 mLayerBlendMapSizeActual
void addLayer(uint8 index, Real worldSize=0, const StringVector *textureNames=0)
Add a new layer to this terrain at a specific index.
void getTerrainPositionAlign(Real x, Real y, Real z, Alignment align, Vector3 *outTSpos) const
Convert a position from world space to terrain basis space based on a specified alignment.
uint8 getLayerCount() const
Get the number of layers in this terrain.
void _dumpTextures(const String &prefix, const String &suffix)
Dump textures to files.
Rect mDirtyGeometryRectForNeighbours
PixelBox * calculateLightmap(const Rect &rect, const Rect &extraTargetRect, Rect &outFinalRect)
Calculate (or recalculate) the terrain lightmap.
void finaliseHeightDeltas(const Rect &rect, bool cpuData)
Finalise the height deltas.
static const uint8 DERIVED_DATA_LIGHTMAP
void shiftUpGPUBlendChannels(uint8 index)
Shift/slide all GPU blend texture channels > index up one slot. Blend data may shift into the next te...
std::pair< bool, Vector3 > checkQuadIntersection(int x, int y, const Ray &ray)
Test a single quad of the terrain for ray intersection.
bool prepare(StreamSerialiser &stream)
Prepare terrain data from saved data.
const TexturePtr & getCompositeMap() const
Get access to the composite map, if enabled (as requested by the material generator)
bool canHandleRequest(const WorkQueue::Request *req, const WorkQueue *srcQ)
WorkQueue::RequestHandler override.
String mMaterialName
float * getHeightData(long x, long y) const
Get a pointer to the height data for a given point.
void determineLodLevels()
TexturePtr mTerrainNormalMap
Texture storing normals for the whole terrrain.
Real getMinHeight() const
Get the minimum height of the terrain.
TerrainMaterialGeneratorPtr mMaterialGenerator
bool mGlobalColourMapEnabled
SceneManager * getSceneManager() const
void _setMorphRequired(bool morph)
Request internal implementation options for the terrain material to use, in this case vertex morphing...
bool prepare(const ImportData &importData)
Prepare the terrain from some import data rather than loading from native data.
static uint16 _calcSkirtVertexIndex(uint16 mainIndex, uint16 vdatasize, bool isCol, uint16 numSkirtRowsCols, uint16 skirtRowColSkip)
Utility method to calculate the skirt index for a given original vertex index.
NeighbourIndex
Neighbour index enumeration - indexed anticlockwise from East like angles.
uint8 getBlendTextureCount(uint8 numLayers) const
Get the number of blend textures needed for a given number of layers.
uint16 getNumLodLevels() const
Get the total number of LOD levels in the terrain.
bool prepare(DataStreamPtr &stream)
Prepare terrain data from saved data.
uint16 getLODLevelWhenVertexEliminated(long rowOrColulmn) const
Utility method, get the first LOD Level at which this vertex is no longer included.
Real getLayerWorldSize(uint8 index) const
How large an area in world space the texture in a terrain layer covers before repeating.
static void _populateIndexBuffer(uint16 *pIndexes, uint16 batchSize, uint16 vdatasize, size_t vertexIncrement, uint16 xoffset, uint16 yoffset, uint16 numSkirtRowsCols, uint16 skirtRowColSkip)
Utility method to populate a (locked) index buffer.
uint16 getMaxBatchSize() const
Get the maximum size in vertices along one side of a batch.
Vector3 convertDirection(Space inSpace, const Vector3 &inDir, Space outSpace) const
Convert a direction from one space to another with respect to this terrain.
GpuBufferAllocator * mCustomGpuBufferAllocator
MaterialPtr mMaterial
static const uint16 TERRAINLAYERSAMPLER_CHUNK_VERSION
void finaliseLightmap(const Rect &rect, PixelBox *lightmapBox)
Finalise the lightmap.
uint16 getCompositeMapSize() const
Get the requested size of composite map for this terrain.
static const uint16 TERRAINGENERALINFO_CHUNK_VERSION
Rect mDirtyGeometryRect
bool _getUseVertexCompression() const
Whether we're using vertex compression or not.
void getPointAlign(long x, long y, float height, Alignment align, Vector3 *outpos) const
Get a Vector3 of the world-space point on the terrain, supplying the height data manually (can be mor...
void _setNormalMapRequired(bool normalMap)
Request internal implementation options for the terrain material to use, in this case a terrain-wide ...
String mResourceGroup
bool canHandleResponse(const WorkQueue::Response *res, const WorkQueue *srcQ)
WorkQueue::ResponseHandler override.
Rect mDirtyLightmapFromNeighboursRect
void getTerrainPositionAlign(const Vector3 &WSpos, Alignment align, Vector3 *outTSpos) const
Convert a position from world space to terrain basis space based on a specified alignment.
void updateBaseScale()
int getPositiveLodLevel(int lodLevel) const
Get the real lod level.
void setLayerWorldSize(uint8 index, Real size)
How large an area in world space the texture in a terrain layer covers before repeating.
void freeLodData()
Real mBase
Base position in world space, relative to mPos.
void getPoint(long x, long y, float height, Vector3 *outpos) const
Get a Vector3 of the world-space point on the terrain, supplying the height data manually (can be mor...
void setQueryFlags(uint32 flags)
Set the query flags for this terrain.
void copyBlendTextureChannel(uint8 srcIndex, uint8 srcChannel, uint8 destIndex, uint8 destChannel)
Copy a GPU blend channel from one source to another. Source and Dest are not required to be in the sa...
TerrainLayerBlendMap * getLayerBlendMap(uint8 layerIndex)
Retrieve the layer blending map for a given layer, which may be used to edit the blending information...
bool mDerivedDataUpdateInProgress
void freeTemporaryResources()
Free as many resources as possible for optimal run-time memory use.
void getPosition(Real x, Real y, Real z, Vector3 *outWSpos) const
Convert a position from terrain basis space to world space.
static const uint32 TERRAINDERIVEDDATA_CHUNK_ID
uint16 mCompositeMapSizeActual
bool isDerivedDataUpdateInProgress() const
Query whether a derived data update is in progress or not.
uint16 mLayerBlendMapSize
void shiftDownGPUBlendChannels(uint8 index)
Shift/slide all GPU blend texture channels > index down one slot. Blend data may shift into the previ...
unsigned long mLastMillis
void getVectorAlign(Real x, Real y, Real z, Alignment align, Vector3 *outVec) const
Translate a vector into world space based on a specified alignment.
const MaterialPtr & _getCompositeMapMaterial() const
Internal getting of material for the terrain composite map.
static const uint32 TERRAINLAYERSAMPLER_CHUNK_ID
const String & _getDerivedResourceGroup() const
Get the final resource group to use when loading / saving.
bool mLightMapShadowsOnly
const float * getDeltaData(long x, long y) const
Get a pointer to the delta data for a given point.
unsigned long mLastLODFrame
Rect calculateHeightDeltas(const Rect &rect)
Calculate (or recalculate) the delta values of heights between a vertex in its recorded position,...
void handleGenerateMaterialResponse(const WorkQueue::Response *res, const WorkQueue *srcQ)
Handler for GenerateMaterial.
void getNeighbourPointOverflow(long x, long y, NeighbourIndex *outindex, long *outx, long *outy) const
TexturePtrList mBlendTextureList
void neighbourModified(NeighbourIndex index, const Rect &edgerect, const Rect &shadowrect)
Notify that a neighbour has just finished updating and that this change affects this tile.
uint16 mWorkQueueChannel
static const uint16 TERRAIN_MAX_BATCH_SIZE
bool _getMorphRequired() const
Get whether LOD morphing is needed.
void deriveUVMultipliers()
void updateCompositeMapWithDelay(Real delay=2)
Performs an update on the terrain composite map based on its dirty region, but only at a maximum freq...
static bool readLayerInstanceList(StreamSerialiser &ser, size_t numSamplers, Terrain::LayerInstanceList &targetlst)
Utility method to read a layer instance list from a stream.
Real getSkirtSize() const
The default size of 'skirts' used to hide terrain cracks (default 10, set for new Terrain using Terra...
static const uint32 TERRAINGENERALINFO_CHUNK_ID
void getTerrainVector(const Vector3 &inVec, Vector3 *outVec) const
Translate a vector from world space to local terrain space based on the alignment options.
static const uint8 DERIVED_DATA_NORMALS
uint8 * mCpuLightmapStorage
const AxisAlignedBox & getAABB() const
Get the AABB (local coords) of the entire terrain.
std::pair< bool, Vector3 > rayIntersects(const Ray &ray, bool cascadeToNeighbours=false, Real distanceLimit=0)
Test for intersection of a given ray with the terrain.
TerrainQuadTreeNode * getQuadTree()
Get the top level of the quad tree which is used to divide up the terrain.
void convertDirection(Space inSpace, const Vector3 &inDir, Space outSpace, Vector3 &outDir) const
Convert a direction from one space to another with respect to this terrain.
void convertPosition(Space inSpace, const Vector3 &inPos, Space outSpace, Vector3 &outPos) const
Convert a position from one space to another with respect to this terrain.
void calculateCurrentLod(Viewport *vp)
static const uint16 TERRAINLAYERSAMPLERELEMENT_CHUNK_VERSION
void updateGeometryWithoutNotifyNeighbours()
Performs an update on the terrain geometry based on the dirty region.
void increaseLodLevel(bool synchronous=false)
Increase Terrain's LOD level by 1.
Vector3 convertTerrainToWorldAxes(const Vector3 &inVec) const
void updateDerivedDataImpl(const Rect &rect, const Rect &lightmapExtraRect, bool synchronous, uint8 typeMask)
RealVector mLayerUVMultiplier
const TexturePtr & getLightmap() const
Get access to the lightmap, if enabled (as requested by the material generator)
void getPositionAlign(Real x, Real y, Real z, Alignment align, Vector3 *outWSpos) const
Convert a position from terrain basis space to world space based on a specified alignment.
Vector3 convertWorldToTerrainAxes(const Vector3 &inVec) const
void addLayer(Real worldSize=0, const StringVector *textureNames=0)
Add a new layer to this terrain.
uint16 mMaxBatchSize
void freeCPUResources()
static size_t _getNumIndexesForBatchSize(uint16 batchSize)
Utility method to get the number of indexes required to render a given batch.
void createGPUBlendTextures()
vector< TexturePtr >::type TexturePtrList
std::pair< uint8, uint8 > getLayerBlendTextureIndex(uint8 layerIndex) const
Get the texture index and colour channel of the blend information for a given layer.
bool mCompositeMapRequired
int getTargetLodLevel() const
float getHeightAtWorldPosition(Real x, Real y, Real z) const
Get the height data for a given world position (projecting the point down on to the terrain).
void createOrDestroyGPUColourMap()
uint8 mRenderQueueGroup
void load(int lodLevel=0, bool synchronous=true)
Load the terrain based on the data already populated via prepare methods.
static void writeLayerInstanceList(const Terrain::LayerInstanceList &lst, StreamSerialiser &ser)
Utility method to write a layer instance list to a stream.
Alignment getAlignment() const
Get the alignment of the terrain.
void getPoint(long x, long y, Vector3 *outpos) const
Get a Vector3 of the world-space point on the terrain, aligned as per options.
void getTerrainPosition(Real x, Real y, Real z, Vector3 *outTSpos) const
Convert a position from world space to terrain basis space.
const TexturePtr & getGlobalColourMap() const
Get access to the global colour map, if enabled.
vector< LayerInstance >::type LayerInstanceList
TexturePtr mLightmap
bool mNormalMapRequired
float getHeightAtPoint(long x, long y) const
Get the height data for a given terrain point.
TerrainLodManager * mLodManager
float * mHeightData
The height data (world coords relative to mPos)
void updateCompositeMap()
Performs an update on the terrain composite map based on its dirty region.
uint8 getRenderQueueGroup(void) const
Get the render queue group that this terrain will be rendered into.
static void convertWorldToTerrainAxes(Alignment align, const Vector3 &worldVec, Vector3 *terrainVec)
Utility method to convert axes from world space to terrain space (xy terrain, z up)
Real mScale
Relationship between one point on the terrain and world size.
const Camera * mLastLODCamera
uint8 getMaxLayers() const
Get the maximum number of layers supported with the current options.
float * mDeltaData
The delta information defining how a vertex moves before it is removed at a lower LOD.
static NameGenerator msBlendTextureGenerator
int getHighestLodLoaded() const
Real getMaxHeight() const
Get the maximum height of the terrain.
uint16 mCompositeMapSize
void updateGeometry()
Performs an update on the terrain geometry based on the dirty region.
void waitForDerivedProcesses()
void distributeVertexData()
void getEdgeRect(NeighbourIndex index, long range, Rect *outRect) const
PixelBox * calculateNormals(const Rect &rect, Rect &outFinalRect)
Calculate (or recalculate) the normals on the terrain.
void _setLightMapRequired(bool lightMap, bool shadowsOnly=false)
Request internal implementation options for the terrain material to use, in this case a terrain-wide ...
uint8 getBlendTextureCount() const
Get the number of blend textures in use.
static const uint16 TERRAINDERIVEDDATA_CHUNK_VERSION
uint32 mVisibilityFlags
void getNeighbourEdgeRect(NeighbourIndex index, const Rect &inRect, Rect *outRect) const
void setSize(uint16 newSize)
Set the size of terrain in vertices along one side.
const float * getDeltaData() const
Get a pointer to all the delta data for this terrain.
void getPointFromSelfOrNeighbour(long x, long y, Vector3 *outpos) const
Get a Vector3 of the world-space point on the terrain, aligned as per options.
Alignment mAlign
void getVector(const Vector3 &inVec, Vector3 *outVec) const
Translate a vector into world space based on the alignment options.
OGRE_RW_MUTEX(mNeighbourMutex)
void notifyNeighbours()
Tell this instance to notify all neighbours that will be affected by a height change that has taken p...
Terrain(SceneManager *sm)
Constructor.
PixelFormat getBlendTextureFormat(uint8 textureIndex, uint8 numLayers) const
void dirtyLightmap()
Mark a the entire lightmap as dirty.
size_t getDeltaBufVertexSize() const
void setRenderQueueGroup(uint8 grp)
Set the render queue group that this terrain will be rendered into.
uint16 mNumLodLevels
void setNeighbour(NeighbourIndex index, Terrain *neighbour, bool recalculate=false, bool notifyOther=true)
Set a terrain's neighbour, or null to detach one.
void removeQueryFlags(uint32 flags)
void updateDerivedData(bool synchronous=false, uint8 typeMask=0xFF)
Updates derived data for the terrain (LOD, lighting) to reflect changed height data,...
uint16 mLightmapSize
uint16 getSize() const
Get the size of the terrain in vertices along one side.
Real getBoundingRadius() const
Get the bounding radius of the entire terrain.
const Vector3 & getPosition() const
Get the world position of the terrain centre.
vector< Real >::type RealVector
void _dirtyCompositeMapRect(const Rect &rect)
Mark a region of the terrain composite map as dirty.
bool getGlobalColourMapEnabled() const
Get whether a global colour map is enabled on this terrain.
void unprepare()
Free CPU resources created during prepare methods.
void setPosition(const Vector3 &pos)
Set the position of the terrain centre in world coordinates.
bool mHeightDataModified
static const uint16 WORKQUEUE_GENERATE_MATERIAL_REQUEST
void dirty()
Mark the entire terrain as dirty.
void getTerrainPosition(const Vector3 &WSpos, Vector3 *outTSpos) const
Convert a position from world space to terrain basis space.
void setResourceGroup(const String &resGroup)
Set the resource group to use when loading / saving.
void getTerrainVectorAlign(const Vector3 &inVec, Alignment align, Vector3 *outVec) const
Translate a vector from world space to local terrain space based on a specified alignment.
TexturePtr getTerrainNormalMap() const
Get the (global) normal map texture.
const TerrainLayerDeclaration & getLayerDeclaration() const
Get the declaration which describes the layers in this terrain.
static const uint8 DERIVED_DATA_ALL
bool prepare(const String &filename)
Prepare the terrain from a standalone file.
static NameGenerator msCompositeMapNameGenerator
TexturePtr mColourMap
void convertSpace(Space inSpace, const Vector3 &inVec, Space outSpace, Vector3 &outVec, bool translation) const
uint16 mNumLodLevelsPerLeafNode
const String & getBlendTextureName(uint8 textureIndex) const
Get the name of the packed blend texture at a specific index.
void createOrDestroyGPUCompositeMap()
size_t getPositionBufVertexSize() const
const MaterialPtr & getMaterial() const
Get the material being used for the terrain.
void getTerrainVector(Real x, Real y, Real z, Vector3 *outVec) const
Translate a vector from world space to local terrain space based on the alignment options.
uint32 getQueryFlags(void) const
Get the query flags for this terrain.
void freeGPUResources()
SceneManager * mSceneMgr
SceneNode * mRootNode
uint getGeoDataSizeAtLod(uint16 lodLevel) const
Gets the data size at a given LOD level.
const MaterialPtr & getCompositeMapMaterial() const
Get the material being used for the terrain composite map.
uint8 * mCpuCompositeMapStorage
uint8 getBlendTextureIndex(uint8 layerIndex) const
Get the index of the blend texture that a given layer uses.
Real getWorldSize() const
Get the size of the terrain in world units.
bool isModified() const
Returns whether this terrain has been modified since it was first loaded / defined.
void decreaseLodLevel()
Removes highest LOD level loaded.
void setGlobalColourMapEnabled(bool enabled, uint16 size=0)
Set whether a global colour map is enabled.
Real getLayerUVMultiplier(uint8 index) const
Get the layer UV multiplier.
static const uint16 TERRAINLAYERINSTANCE_CHUNK_VERSION
static bool readLayerDeclaration(StreamSerialiser &ser, TerrainLayerDeclaration &targetdecl)
Utility method to read a layer declaration from a stream.
static const uint32 TERRAINLAYERDECLARATION_CHUNK_ID
void checkDeclaration()
uint16 getLODLevelWhenVertexEliminated(long x, long y) const
Utility method, get the first LOD Level at which this vertex is no longer included.
Alignment
The alignment of the terrain.
static const uint32 TERRAINLAYERINSTANCE_CHUNK_ID
void save(const String &filename)
Save terrain data in native form to a standalone file.
uint16 getGlobalColourMapSize() const
Get the size of the global colour map (if used)
void getPointTransform(Matrix4 *outXform) const
Get a transform which converts Vector4(xindex, yindex, height, 1) into an object-space position inclu...
void unload()
Unload the terrain and free GPU resources.
const String & getLayerTextureName(uint8 layerIndex, uint8 samplerIndex) const
Get the name of the texture bound to a given index within a given layer.
AxisAlignedBox getWorldAABB() const
Get the AABB (world coords) of the entire terrain.
static const uint32 TERRAIN_CHUNK_ID
virtual ~Terrain()
float getHeightAtWorldPosition(const Vector3 &pos) const
Get the height data for a given world position (projecting the point down on to the terrain).
unsigned long long int mMaterialGenerationCount
bool mCompositeMapDirtyRectLightmapUpdate
True if the updates included lightmap changes (widen)
bool mMaterialParamsDirty
vector< uint8 * >::type BytePointerList
void setHeightAtPoint(long x, long y, float h)
Set the height data for a given terrain point.
void addQueryFlags(uint32 flags)
As setQueryFlags, except the flags passed as parameters are appended to the existing flags on this ob...
const MaterialPtr & _getMaterial() const
Internal getting of material.
void removeFromNeighbours()
Removes this terrain instance from neighbouring terrain's list of neighbours.
void setWorldSize(Real newWorldSize)
Set the world size of terrain.
void copyGlobalOptions()
static NeighbourIndex getOppositeNeighbour(NeighbourIndex index)
Get the opposite neighbour relationship (useful for finding the neighbour index from the perspective ...
void handleResponse(const WorkQueue::Response *res, const WorkQueue *srcQ)
WorkQueue::ResponseHandler override.
void preFindVisibleObjects(SceneManager *source, SceneManager::IlluminationRenderStage irs, Viewport *v)
Overridden from SceneManager::Listener.
float * getHeightData() const
Get a pointer to all the height data for this terrain.
const String & getMaterialName() const
Get the name of the material being used for the terrain.
void getPointAlign(long x, long y, Alignment align, Vector3 *outpos) const
Get a Vector3 of the world-space point on the terrain, aligned Y-up always.
static const uint8 DERIVED_DATA_DELTAS
static const uint32 TERRAINLAYERSAMPLERELEMENT_CHUNK_ID
uint16 getLightmapSize() const
Get the requested size of lightmap for this terrain.
void replaceLayer(uint8 index, bool keepBlends, Real worldSize=0, const StringVector *textureNames=0)
Replace an existing terrain layer, optionally preserving all other layer blend maps.
void removeLayer(uint8 index)
Remove a layer from the terrain.
const TexturePtr & getLayerBlendTexture(uint8 index) const
Get a blend texture with a given index.
void update(bool synchronous=false)
Trigger the update process for the terrain.
uint16 mMinBatchSize
void getNeighbourPoint(NeighbourIndex index, long x, long y, long *outx, long *outy) const
void load(StreamSerialiser &stream)
Prepare and load the terrain in one simple call from a stream.
float getHeightAtTerrainPosition(Real x, Real y) const
Get the height data for a given terrain position.
Terrain * getNeighbour(NeighbourIndex index) const
Retrieve the terrain's neighbour, or null if not present.
void load(const String &filename)
Prepare and load the terrain in one simple call from a standalone file.
uint16 getNumLodLevelsPerLeaf() const
Get the number of LOD levels in a leaf of the terrain quadtree.
Space
Enumeration of relative spaces that you might want to use to address the terrain.
Rect mCompositeMapDirtyRect
static NameGenerator msLightmapNameGenerator
DefaultGpuBufferAllocator mDefaultGpuBufferAllocator
static const size_t LOD_MORPH_CUSTOM_PARAM
Rect mDirtyDerivedDataRect
bool isLoaded() const
Return whether the terrain is loaded.
uint8 * mCpuColourMapStorage
GpuBufferAllocator * getGpuBufferAllocator()
Get the current buffer allocator.
void setLayerTextureName(uint8 layerIndex, uint8 samplerIndex, const String &textureName)
Set the name of the texture bound to a given index within a given layer.
LayerInstanceList mLayers
TerrainQuadTreeNode * mQuadTree
void getTerrainVectorAlign(Real x, Real y, Real z, Alignment align, Vector3 *outVec) const
Translate a vector from world space to local terrain space based on a specified alignment.
uint8 mDerivedUpdatePendingMask
If another update is requested while one is already running.
MaterialPtr mCompositeMapMaterial
void getPositionAlign(const Vector3 &TSpos, Alignment align, Vector3 *outWSpos) const
Convert a position from terrain basis space to world space based on a specified alignment.
void getVector(Real x, Real y, Real z, Vector3 *outVec) const
Translate a vector into world space based on the alignment options.
unsigned long mCompositeMapUpdateCountdown
static void convertTerrainToWorldAxes(Alignment align, const Vector3 &terrainVec, Vector3 *worldVec)
Utility method to convert axes from terrain space (xy terrain, z up) tp world space.
void checkLayers(bool includeGPUResources)
const String & getResourceGroup() const
Get the resource group to use when loading / saving.
void save(StreamSerialiser &stream)
Save terrain data in native form to a serializing stream.
int getHighestLodPrepared() const
void setGpuBufferAllocator(GpuBufferAllocator *alloc)
Tell this instance to use the given GpuBufferAllocator.
static const uint16 TERRAIN_CHUNK_VERSION
Terrain * raySelectNeighbour(const Ray &ray, Real distanceLimit=0)
Utility method to pick a neighbour based on a ray.
bool mGenerateMaterialInProgress
uint16 getMinBatchSize() const
Get the minimum size in vertices along one side of a batch.
uint16 getResolutionAtLod(uint16 lodLevel) const
Gets the resolution of the entire terrain (down one edge) at a given LOD level.
void widenRectByVector(const Vector3 &vec, const Rect &inRect, Rect &outRect)
Widen a rectangular area of terrain to take into account an extrusion vector.
TerrainLayerDeclaration mLayerDecl
Standard 3-dimensional vector.
Definition OgreVector3.h:52
An abstraction of a viewport, i.e.
Interface definition for a handler of requests.
General purpose request structure.
Interface definition for a handler of responses.
Interface to a general purpose request / response style background work queue.
vector< String >::type StringVector
PixelFormat
The pixel format used for images, textures, and render surfaces.
#define OGRE_ALLOC_T(T, count, category)
Allocate a block of memory for a primitive type, and indicate the category of usage.
#define OGRE_NEW
#define OGRE_FREE(ptr, category)
Free the memory allocated with OGRE_MALLOC or OGRE_ALLOC_T. Category is required to be restated to en...
#define OGRE_DELETE
@ MEMCATEGORY_GEOMETRY
Geometry held in main memory.
vector< TerrainLayerBlendMap * >::type TerrainLayerBlendMapList
unsigned char uint8
unsigned long long uint64
float Real
Software floating point type.
unsigned short uint16
unsigned int uint
unsigned int uint32
_StringBase String
The definition of the information each layer will contain in this terrain.
A data holder for communicating with the background derived data update.
_OgreTerrainExport friend std::ostream & operator<<(std::ostream &o, const DerivedDataRequest &r)
A data holder for communicating with the background derived data update.
Rect normalUpdateRect
The area of normals that was updated.
Rect deltaUpdateRect
The area of deltas that was updated.
Rect lightmapUpdateRect
The area of lightmap that was updated.
_OgreTerrainExport friend std::ostream & operator<<(std::ostream &o, const DerivedDataResponse &r)
uint8 remainingTypeMask
Remaining types not yet processed.
PixelBox * normalMapBox
All CPU-side data, independent of textures; to be blitted in main thread.
A data holder for communicating with the background GetMaterial.
_OgreTerrainExport friend std::ostream & operator<<(std::ostream &o, const GenerateMaterialRequest &r)
Structure encapsulating import data that you may use to bootstrap the terrain without loading from a ...
uint16 terrainSize
Terrain size (along one edge) in vertices; must be 2^n+1.
float constantHeight
If neither inputImage or inputFloat are supplied, the constant height at which the initial terrain sh...
LayerInstanceList layerList
List of layer structures, one for each layer required.
Real worldSize
The world size of the terrain.
uint16 minBatchSize
Minimum batch size (along one edge) in vertices; must be 2^n+1.
Image * inputImage
Optional heightmap providing the initial heights for the terrain.
void destroy()
Delete any input data if this struct is set to do so.
ImportData(const ImportData &rhs)
ImportData & operator=(const ImportData &rhs)
Alignment terrainAlign
The alignment of the terrain.
Real inputBias
How to bias the input values provided (if any)
float * inputFloat
Optional list of terrainSize * terrainSize floats defining the terrain.
bool deleteInputData
Whether this structure should 'own' the input data (inputImage and inputFloat), and therefore delete ...
uint16 maxBatchSize
Maximum batch size (along one edge) in vertices; must be 2^n+1 and <= 65.
Vector3 pos
Position of the terrain.
TerrainLayerDeclaration layerDeclaration
Definition of the contents of each layer (required).
Real inputScale
How to scale the input values provided (if any)
An instance of a layer, with specific texture names.
StringVector textureNames
List of texture names to import; must match with TerrainLayerDeclaration.
Real worldSize
The world size of the texture to be applied in this layer.
General purpose response structure.
std::list< T, A > type
std::map< K, V, P, A > type
std::vector< T, A > type