OgreTerrain.h
Go to the documentation of this file.

    00001 /*
    00002 -----------------------------------------------------------------------------
    00003 This source file is part of OGRE
    00004 (Object-oriented Graphics Rendering Engine)
    00005 For the latest info, see http://www.ogre3d.org/
    00006
    00007 Copyright (c) 2000-2012 Torus Knot Software Ltd
    00008
    00009 Permission is hereby granted, free of charge, to any person obtaining a copy
    00010 of this software and associated documentation files (the "Software"), to deal
    00011 in the Software without restriction, including without limitation the rights
    00012 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    00013 copies of the Software, and to permit persons to whom the Software is
    00014 furnished to do so, subject to the following conditions:
    00015
    00016 The above copyright notice and this permission notice shall be included in
    00017 all copies or substantial portions of the Software.
    00018
    00019 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    00020 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    00021 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    00022 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    00023 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    00024 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    00025 THE SOFTWARE.
    00026 -----------------------------------------------------------------------------
    00027 */
    00028
    00029 #ifndef __Ogre_Terrain_H__
    00030 #define __Ogre_Terrain_H__
    00031
    00032 #include "OgreTerrainPrerequisites.h"
    00033 #include "OgreCommon.h"
    00034 #include "OgreVector3.h"
    00035 #include "OgreAxisAlignedBox.h"
    00036 #include "OgreSceneManager.h"
    00037 #include "OgreTerrainMaterialGenerator.h"
    00038 #include "OgreTerrainLayerBlendMap.h"
    00039 #include "OgreWorkQueue.h"
    00040
    00041 namespace Ogre
    00042 {
    00261     class _OgreTerrainExport Terrain : public SceneManager::Listener,
    00262         public WorkQueue::RequestHandler, public WorkQueue::ResponseHandler, public TerrainAlloc
    00263     {
    00264     public:
    00268         Terrain(SceneManager* sm);
    00269         virtual ~Terrain();
    00270
    00271         static const uint32 TERRAIN_CHUNK_ID;
    00272         static const uint16 TERRAIN_CHUNK_VERSION;
    00273         static const uint16 TERRAIN_MAX_BATCH_SIZE;
    00274
    00275         static const uint32 TERRAINLAYERDECLARATION_CHUNK_ID;
    00276         static const uint16 TERRAINLAYERDECLARATION_CHUNK_VERSION;
    00277         static const uint32 TERRAINLAYERSAMPLER_CHUNK_ID;
    00278         static const uint16 TERRAINLAYERSAMPLER_CHUNK_VERSION;
    00279         static const uint32 TERRAINLAYERSAMPLERELEMENT_CHUNK_ID;
    00280         static const uint16 TERRAINLAYERSAMPLERELEMENT_CHUNK_VERSION;
    00281         static const uint32 TERRAINLAYERINSTANCE_CHUNK_ID;
    00282         static const uint16 TERRAINLAYERINSTANCE_CHUNK_VERSION;
    00283         static const uint32 TERRAINDERIVEDDATA_CHUNK_ID;
    00284         static const uint16 TERRAINDERIVEDDATA_CHUNK_VERSION;
    00285
    00286         static const size_t LOD_MORPH_CUSTOM_PARAM;
    00287
    00288         typedef vector<Real>::type RealVector;
    00289
    00292         struct _OgreTerrainExport LayerInstance
    00293         {
    00295             Real worldSize;
    00297             StringVector textureNames;
    00298
    00299             LayerInstance()
    00300                 : worldSize(100) {}
    00301         };
    00302         typedef vector<LayerInstance>::type LayerInstanceList;
    00303
    00305         enum Alignment
    00306         {
    00308             ALIGN_X_Z = 0,
    00310             ALIGN_X_Y = 1,
    00312             ALIGN_Y_Z = 2
    00313         };
    00314
    00318         struct ImportData
    00319         {
    00321             Alignment terrainAlign;
    00323             uint16 terrainSize;
    00329             uint16 maxBatchSize;
    00340             uint16 minBatchSize;
    00341
    00346             Vector3 pos;
    00347
    00349             Real worldSize;
    00350
    00356             Image* inputImage;
    00357
    00362             float* inputFloat;
    00363
    00367             float constantHeight;
    00368
    00376             bool deleteInputData;
    00377
    00379             Real inputScale;
    00381             Real inputBias;
    00382
    00387             TerrainLayerDeclaration layerDeclaration;
    00392             LayerInstanceList layerList;
    00393
    00394             ImportData()
    00395                 : terrainAlign(ALIGN_X_Z)
    00396                 , terrainSize(1025)
    00397                 , maxBatchSize(65)
    00398                 , minBatchSize(17)
    00399                 , pos(Vector3::ZERO)
    00400                 , worldSize(1000)
    00401                 , inputImage(0)
    00402                 , inputFloat(0)
    00403                 , constantHeight(0)
    00404                 , deleteInputData(false)
    00405                 , inputScale(1.0)
    00406                 , inputBias(0.0)
    00407             {
    00408
    00409             }
    00410
    00411             ImportData(const ImportData& rhs)
    00412                 : terrainAlign(ALIGN_X_Z)
    00413                 , terrainSize(1025)
    00414                 , maxBatchSize(65)
    00415                 , minBatchSize(17)
    00416                 , pos(Vector3::ZERO)
    00417                 , worldSize(1000)
    00418                 , inputImage(0)
    00419                 , inputFloat(0)
    00420                 , constantHeight(0)
    00421                 , deleteInputData(false)
    00422                 , inputScale(1.0)
    00423                 , inputBias(0.0)
    00424             {
    00425                 *this = rhs;
    00426             }
    00427
    00428             ImportData& operator=(const ImportData& rhs)
    00429             {
    00430                 // basic copy
    00431                 terrainAlign = rhs.terrainAlign;
    00432                 terrainSize = rhs.terrainSize;
    00433                 maxBatchSize = rhs.maxBatchSize;
    00434                 minBatchSize = rhs.minBatchSize;
    00435                 pos = rhs.pos;
    00436                 worldSize = rhs.worldSize;
    00437                 constantHeight = rhs.constantHeight;
    00438                 deleteInputData = rhs.deleteInputData;
    00439                 inputScale = rhs.inputScale;
    00440                 inputBias = rhs.inputBias;
    00441                 layerDeclaration = rhs.layerDeclaration;
    00442                 layerList = rhs.layerList;
    00443
    00444                 // By-value copies in ownership cases
    00445                 if (rhs.deleteInputData)
    00446                 {
    00447                     if (rhs.inputImage)
    00448                         inputImage = OGRE_NEW Image(*rhs.inputImage);
    00449                     else
    00450                         inputImage = 0;
    00451
    00452                     if (rhs.inputFloat)
    00453                     {
    00454                         inputFloat = OGRE_ALLOC_T(float, terrainSize*terrainSize, MEMCATEGORY_GEOMETRY);
    00455                         memcpy(inputFloat, rhs.inputFloat, sizeof(float) * terrainSize*terrainSize);
    00456                     }
    00457                     else
    00458                         inputFloat = 0;
    00459                 }
    00460                 else
    00461                 {
    00462                     // re-use pointers
    00463                     inputImage = rhs.inputImage;
    00464                     inputFloat = rhs.inputFloat;
    00465                 }
    00466                 return *this;
    00467             }
    00468
    00470             void destroy()
    00471             {
    00472                 if (deleteInputData)
    00473                 {
    00474                     OGRE_DELETE inputImage;
    00475                     OGRE_FREE(inputFloat, MEMCATEGORY_GEOMETRY);
    00476                     inputImage = 0;
    00477                     inputFloat = 0;
    00478                 }
    00479
    00480             }
    00481
    00482             ~ImportData()
    00483             {
    00484                 destroy();
    00485             }
    00486
    00487         };
    00488
    00490         enum NeighbourIndex
    00491         {
    00492             NEIGHBOUR_EAST = 0,
    00493             NEIGHBOUR_NORTHEAST = 1,
    00494             NEIGHBOUR_NORTH = 2,
    00495             NEIGHBOUR_NORTHWEST = 3,
    00496             NEIGHBOUR_WEST = 4,
    00497             NEIGHBOUR_SOUTHWEST = 5,
    00498             NEIGHBOUR_SOUTH = 6,
    00499             NEIGHBOUR_SOUTHEAST = 7,
    00500
    00501             NEIGHBOUR_COUNT = 8
    00502         };
    00503
    00504         SceneManager* getSceneManager() const { return mSceneMgr; }
    00505
    00507         enum Space
    00508         {
    00510             WORLD_SPACE = 0,
    00512             LOCAL_SPACE = 1,
    00516             TERRAIN_SPACE = 2,
    00520             POINT_SPACE = 3
    00521         };
    00522
    00527         class _OgreTerrainExport GpuBufferAllocator : public TerrainAlloc
    00528         {
    00529         public:
    00530             GpuBufferAllocator() {}
    00531             virtual ~GpuBufferAllocator() {}
    00532
    00538             virtual void allocateVertexBuffers(Terrain* forTerrain, size_t numVertices, HardwareVertexBufferSharedPtr& destPos, HardwareVertexBufferSharedPtr& destDelta) = 0;
    00541             virtual void freeVertexBuffers(const HardwareVertexBufferSharedPtr& posbuf, const HardwareVertexBufferSharedPtr& deltabuf) = 0;
    00542
    00557             virtual HardwareIndexBufferSharedPtr getSharedIndexBuffer(uint16 batchSize,
    00558                 uint16 vdatasize, size_t vertexIncrement, uint16 xoffset, uint16 yoffset, uint16 numSkirtRowsCols,
    00559                 uint16 skirtRowColSkip) = 0;
    00560
    00562             virtual void freeAllBuffers() = 0;
    00563
    00564         };
    00566         class _OgreTerrainExport DefaultGpuBufferAllocator : public GpuBufferAllocator
    00567         {
    00568         public:
    00569             DefaultGpuBufferAllocator();
    00570             ~DefaultGpuBufferAllocator();
    00571             void allocateVertexBuffers(Terrain* forTerrain, size_t numVertices, HardwareVertexBufferSharedPtr& destPos, HardwareVertexBufferSharedPtr& destDelta);
    00572             void freeVertexBuffers(const HardwareVertexBufferSharedPtr& posbuf, const HardwareVertexBufferSharedPtr& deltabuf);
    00573             HardwareIndexBufferSharedPtr getSharedIndexBuffer(uint16 batchSize,
    00574                 uint16 vdatasize, size_t vertexIncrement, uint16 xoffset, uint16 yoffset, uint16 numSkirtRowsCols,
    00575                 uint16 skirtRowColSkip);
    00576             void freeAllBuffers();
    00577
    00581             void warmStart(size_t numInstances, uint16 terrainSize, uint16 maxBatchSize,
    00582                 uint16 minBatchSize);
    00583
    00584         protected:
    00585             typedef list<HardwareVertexBufferSharedPtr>::type VBufList;
    00586             VBufList mFreePosBufList;
    00587             VBufList mFreeDeltaBufList;
    00588             typedef map<uint32, HardwareIndexBufferSharedPtr>::type IBufMap;
    00589             IBufMap mSharedIBufMap;
    00590
    00591             uint32 hashIndexBuffer(uint16 batchSize,
    00592                 uint16 vdatasize, size_t vertexIncrement, uint16 xoffset, uint16 yoffset, uint16 numSkirtRowsCols,
    00593                 uint16 skirtRowColSkip);
    00594             HardwareVertexBufferSharedPtr getVertexBuffer(VBufList& list, size_t vertexSize, size_t numVertices);
    00595
    00596         };
    00597
    00602         void setGpuBufferAllocator(GpuBufferAllocator* alloc);
    00603
    00605         GpuBufferAllocator* getGpuBufferAllocator();
    00606
    00608         static size_t _getNumIndexesForBatchSize(uint16 batchSize);
    00620         static void _populateIndexBuffer(uint16* pIndexes, uint16 batchSize,
    00621             uint16 vdatasize, size_t vertexIncrement, uint16 xoffset, uint16 yoffset, uint16 numSkirtRowsCols,
    00622             uint16 skirtRowColSkip);
    00623
    00625         static uint16 _calcSkirtVertexIndex(uint16 mainIndex, uint16 vdatasize, bool isCol,
    00626             uint16 numSkirtRowsCols, uint16 skirtRowColSkip);
    00627
    00634         void convertPosition(Space inSpace, const Vector3& inPos, Space outSpace, Vector3& outPos) const;
    00641         Vector3 convertPosition(Space inSpace, const Vector3& inPos, Space outSpace) const;
    00648         void convertDirection(Space inSpace, const Vector3& inDir, Space outSpace, Vector3& outDir) const;
    00655         Vector3 convertDirection(Space inSpace, const Vector3& inDir, Space outSpace) const;
    00656
    00661         void setResourceGroup(const String& resGroup) { mResourceGroup = resGroup; }
    00662
    00666         const String& getResourceGroup() const { return mResourceGroup; }
    00667
    00670         const String& _getDerivedResourceGroup() const;
    00671
    00680         void save(const String& filename);
    00686         void save(StreamSerialiser& stream);
    00687
    00694         bool prepare(const String& filename);
    00701         bool prepare(StreamSerialiser& stream);
    00702
    00708         bool prepare(const ImportData& importData);
    00709
    00715         void load(const String& filename);
    00716
    00722         void load(StreamSerialiser& stream);
    00723
    00728         void load();
    00729
    00735         bool isLoaded() const { return mIsLoaded; }
    00736
    00741         bool isModified() const { return mModified; }
    00742
    00743
    00748         bool isHeightDataModified() const { return mHeightDataModified; }
    00749
    00750
    00755         void unload();
    00756
    00761         void unprepare();
    00762
    00763
    00773         float* getHeightData() const;
    00774
    00777         float* getHeightData(long x, long y) const;
    00778
    00783         float getHeightAtPoint(long x, long y) const;
    00784
    00791         void setHeightAtPoint(long x, long y, float h);
    00792
    00796         float getHeightAtTerrainPosition(Real x, Real y);
    00797
    00803         float getHeightAtWorldPosition(Real x, Real y, Real z);
    00804
    00810         float getHeightAtWorldPosition(const Vector3& pos);
    00811
    00818         const float* getDeltaData();
    00819
    00822         const float* getDeltaData(long x, long y);
    00823
    00828         void getPoint(long x, long y, Vector3* outpos);
    00829
    00835         void getPointFromSelfOrNeighbour(long x, long y, Vector3* outpos);
    00836
    00841         void getPoint(long x, long y, float height, Vector3* outpos);
    00845         void getPointTransform(Matrix4* outXform) const;
    00850         void getTerrainVector(const Vector3& inVec, Vector3* outVec);
    00855         void getTerrainVectorAlign(const Vector3& inVec, Alignment align, Vector3* outVec);
    00856
    00861         void getTerrainVector(Real x, Real y, Real z, Vector3* outVec);
    00866         void getTerrainVectorAlign(Real x, Real y, Real z, Alignment align, Vector3* outVec);
    00867
    00872         void getVector(const Vector3& inVec, Vector3* outVec);
    00877         void getVectorAlign(const Vector3& inVec, Alignment align, Vector3* outVec);
    00878
    00883         void getVector(Real x, Real y, Real z, Vector3* outVec);
    00888         void getVectorAlign(Real x, Real y, Real z, Alignment align, Vector3* outVec);
    00889
    00890
    00898         void getPosition(const Vector3& TSpos, Vector3* outWSpos);
    00906         void getPosition(Real x, Real y, Real z, Vector3* outWSpos);
    00907
    00914         void getTerrainPosition(const Vector3& WSpos, Vector3* outTSpos);
    00921         void getTerrainPosition(Real x, Real y, Real z, Vector3* outTSpos);
    00928         void getPositionAlign(const Vector3& TSpos, Alignment align, Vector3* outWSpos);
    00935         void getPositionAlign(Real x, Real y, Real z, Alignment align, Vector3* outWSpos);
    00936
    00943         void getTerrainPositionAlign(const Vector3& WSpos, Alignment align, Vector3* outTSpos);
    00950         void getTerrainPositionAlign(Real x, Real y, Real z, Alignment align, Vector3* outTSpos);
    00951
    00952
    00954         Alignment getAlignment() const;
    00956         uint16 getSize() const;
    00961         void setSize(uint16 newSize);
    00963         uint16 getMaxBatchSize() const;
    00965         uint16 getMinBatchSize() const;
    00967         Real getWorldSize() const;
    00971         void setWorldSize(Real newWorldSize);
    00972
    00974         uint8 getLayerCount() const { return static_cast<uint8>(mLayers.size()); }
    00975
    00977         const TerrainLayerDeclaration& getLayerDeclaration() const { return mLayerDecl; }
    00978
    00985         void addLayer(Real worldSize = 0, const StringVector* textureNames = 0);
    00986
    00994         void addLayer(uint8 index, Real worldSize = 0, const StringVector* textureNames = 0);
    00995
    00998         void removeLayer(uint8 index);
    00999
    01009         void replaceLayer(uint8 index, bool keepBlends, Real worldSize = 0, const StringVector* textureNames = 0);
    01010
    01014         uint8 getMaxLayers() const;
    01015
    01020         Real getLayerWorldSize(uint8 index) const;
    01026         void setLayerWorldSize(uint8 index, Real size);
    01027
    01036         Real getLayerUVMultiplier(uint8 index) const;
    01037
    01043         const String& getLayerTextureName(uint8 layerIndex, uint8 samplerIndex) const;
    01050         void setLayerTextureName(uint8 layerIndex, uint8 samplerIndex, const String& textureName);
    01051
    01058         uint16 getLayerBlendMapSize() const { return mLayerBlendMapSize; }
    01059
    01065         uint16 getLightmapSize() const { return mLightmapSize; }
    01066
    01068         const TexturePtr& getLightmap() const { return mLightmap; }
    01069
    01075         uint16 getCompositeMapSize() const { return mCompositeMapSize; }
    01076
    01078         const TexturePtr& getCompositeMap() const { return mCompositeMap; }
    01079
    01081         const Vector3& getPosition() const { return mPos; }
    01083         void setPosition(const Vector3& pos);
    01085         SceneNode* _getRootSceneNode() const;
    01092         void dirty();
    01093
    01102         void dirtyRect(const Rect& rect);
    01103
    01109         void _dirtyCompositeMapRect(const Rect& rect);
    01110
    01121         void dirtyLightmapRect(const Rect& rect);
    01122
    01133         void dirtyLightmap();
    01134
    01157         void update(bool synchronous = false);
    01158
    01163         void updateGeometry();
    01164
    01165         // Used as a type mask for updateDerivedData
    01166         static const uint8 DERIVED_DATA_DELTAS;
    01167         static const uint8 DERIVED_DATA_NORMALS;
    01168         static const uint8 DERIVED_DATA_LIGHTMAP;
    01169         static const uint8 DERIVED_DATA_ALL;
    01170
    01182         void updateDerivedData(bool synchronous = false, uint8 typeMask = 0xFF);
    01183
    01192         void updateCompositeMap();
    01193
    01207         void updateCompositeMapWithDelay(Real delay = 2);
    01208
    01209
    01213         Real getSkirtSize() const { return mSkirtSize; }
    01214
    01216         uint16 getNumLodLevels() const { return mNumLodLevels; }
    01217
    01219         uint16 getNumLodLevelsPerLeaf() const { return mNumLodLevelsPerLeafNode; }
    01220
    01228         Rect calculateHeightDeltas(const Rect& rect);
    01229
    01237         void finaliseHeightDeltas(const Rect& rect, bool cpuData);
    01238
    01244         PixelBox* calculateNormals(const Rect& rect, Rect& outFinalRect);
    01245
    01253         void finaliseNormals(const Rect& rect, PixelBox* normalsBox);
    01254
    01262         PixelBox* calculateLightmap(const Rect& rect, const Rect& extraTargetRect, Rect& outFinalRect);
    01263
    01271         void finaliseLightmap(const Rect& rect, PixelBox* lightmapBox);
    01272
    01276         uint16 getResolutionAtLod(uint16 lodLevel);
    01277
    01289         std::pair<bool, Vector3> rayIntersects(const Ray& ray,
    01290             bool cascadeToNeighbours = false, Real distanceLimit = 0); //const;
    01291
    01293         const AxisAlignedBox& getAABB() const;
    01295         AxisAlignedBox getWorldAABB() const;
    01297         Real getMinHeight() const;
    01299         Real getMaxHeight() const;
    01301         Real getBoundingRadius() const;
    01302
    01304         const MaterialPtr& getMaterial() const;
    01306         const MaterialPtr& _getMaterial() const { return mMaterial; }
    01308         const MaterialPtr& getCompositeMapMaterial() const;
    01310         const MaterialPtr& _getCompositeMapMaterial() const { return mCompositeMapMaterial; }
    01311
    01313         const String& getMaterialName() const { return mMaterialName; }
    01314
    01316         void preFindVisibleObjects(SceneManager* source,
    01317             SceneManager::IlluminationRenderStage irs, Viewport* v);
    01319         void sceneManagerDestroyed(SceneManager* source);
    01320
    01322         uint8 getRenderQueueGroup(void) const { return mRenderQueueGroup; }
    01326         void setRenderQueueGroup(uint8 grp) { mRenderQueueGroup = grp; }
    01327
    01329         uint32 getVisibilityFlags(void) const { return mVisibilityFlags; }
    01333         void setVisibilityFlags(uint32 flags) { mVisibilityFlags = flags; }
    01334
    01336         uint32 getQueryFlags(void) const { return mQueryFlags; }
    01340         void setQueryFlags(uint32 flags) { mQueryFlags = flags; }
    01341
    01343         void addQueryFlags(uint32 flags) { mQueryFlags |= flags; }
    01344
    01345         /* As setQueryFlags, except the flags passed as parameters are removed from the existing flags on this object. */
    01346         void removeQueryFlags(uint32 flags) { mQueryFlags &= ~flags; }
    01347
    01348
    01361         TerrainLayerBlendMap* getLayerBlendMap(uint8 layerIndex);
    01362
    01368         uint8 getBlendTextureIndex(uint8 layerIndex) const;
    01369
    01371         uint8 getBlendTextureCount() const;
    01373         uint8 getBlendTextureCount(uint8 numLayers) const;
    01374
    01375
    01380         const String& getBlendTextureName(uint8 textureIndex) const;
    01381
    01394         void setGlobalColourMapEnabled(bool enabled, uint16 size = 0);
    01396         bool getGlobalColourMapEnabled() const { return mGlobalColourMapEnabled; }
    01398         uint16 getGlobalColourMapSize() const { return mGlobalColourMapSize; }
    01400         const TexturePtr& getGlobalColourMap() const { return mColourMap; }
    01401
    01407         void widenRectByVector(const Vector3& vec, const Rect& inRect, Rect& outRect);
    01408
    01416         void widenRectByVector(const Vector3& vec, const Rect& inRect,
    01417             Real minHeight, Real maxHeight, Rect& outRect);
    01418
    01428         void freeTemporaryResources();
    01429
    01434         const TexturePtr& getLayerBlendTexture(uint8 index);
    01435
    01442         std::pair<uint8,uint8> getLayerBlendTextureIndex(uint8 layerIndex);
    01443
    01454         void _setMorphRequired(bool morph) { mLodMorphRequired = morph; }
    01456         bool _getMorphRequired() const { return mLodMorphRequired; }
    01457
    01469         void _setNormalMapRequired(bool normalMap);
    01470
    01484         void _setLightMapRequired(bool lightMap, bool shadowsOnly = false);
    01485
    01504         void _setCompositeMapRequired(bool compositeMap);
    01505
    01507         bool _getUseVertexCompression() const;
    01508
    01510         bool canHandleRequest(const WorkQueue::Request* req, const WorkQueue* srcQ);
    01512         WorkQueue::Response* handleRequest(const WorkQueue::Request* req, const WorkQueue* srcQ);
    01514         bool canHandleResponse(const WorkQueue::Response* res, const WorkQueue* srcQ);
    01516         void handleResponse(const WorkQueue::Response* res, const WorkQueue* srcQ);
    01517
    01518         static const uint16 WORKQUEUE_DERIVED_DATA_REQUEST;
    01519
    01520
    01522         uint16 getLODLevelWhenVertexEliminated(long x, long y);
    01524         uint16 getLODLevelWhenVertexEliminated(long rowOrColulmn);
    01525
    01526
    01528         TerrainQuadTreeNode* getQuadTree() { return mQuadTree; }
    01529
    01531         TexturePtr getTerrainNormalMap() const { return mTerrainNormalMap; }
    01532
    01540         Terrain* getNeighbour(NeighbourIndex index);
    01541
    01559         void setNeighbour(NeighbourIndex index, Terrain* neighbour, bool recalculate = false, bool notifyOther = true);
    01560
    01565         static NeighbourIndex getOppositeNeighbour(NeighbourIndex index);
    01566
    01569         static NeighbourIndex getNeighbourIndex(long offsetx, long offsety);
    01570
    01578         void notifyNeighbours();
    01579
    01587         void neighbourModified(NeighbourIndex index, const Rect& edgerect, const Rect& shadowrect);
    01588
    01594         Terrain* raySelectNeighbour(const Ray& ray, Real distanceLimit = 0);
    01595
    01600         void _dumpTextures(const String& prefix, const String& suffix);
    01601
    01603         bool isDerivedDataUpdateInProgress() const { return mDerivedDataUpdateInProgress; }
    01604
    01605
    01607         static void convertWorldToTerrainAxes(Alignment align, const Vector3& worldVec, Vector3* terrainVec);
    01609         static void convertTerrainToWorldAxes(Alignment align, const Vector3& terrainVec, Vector3* worldVec);
    01610
    01612         static void writeLayerDeclaration(const TerrainLayerDeclaration& decl, StreamSerialiser& ser);
    01614         static bool readLayerDeclaration(StreamSerialiser& ser, TerrainLayerDeclaration& targetdecl);
    01616         static void writeLayerInstanceList(const Terrain::LayerInstanceList& lst, StreamSerialiser& ser);
    01618         static bool readLayerInstanceList(StreamSerialiser& ser, size_t numSamplers, Terrain::LayerInstanceList& targetlst);
    01619     protected:
    01620
    01621         void freeCPUResources();
    01622         void freeGPUResources();
    01623         void determineLodLevels();
    01624         void distributeVertexData();
    01625         void updateBaseScale();
    01626         void createGPUBlendTextures();
    01627         void createLayerBlendMaps();
    01628         void createOrDestroyGPUNormalMap();
    01629         void createOrDestroyGPUColourMap();
    01630         void createOrDestroyGPULightmap();
    01631         void createOrDestroyGPUCompositeMap();
    01632         void waitForDerivedProcesses();
    01633         void convertSpace(Space inSpace, const Vector3& inVec, Space outSpace, Vector3& outVec, bool translation) const;
    01634         Vector3 convertWorldToTerrainAxes(const Vector3& inVec) const;
    01635         Vector3 convertTerrainToWorldAxes(const Vector3& inVec) const;
    01639         void getPointAlign(long x, long y, Alignment align, Vector3* outpos);
    01644         void getPointAlign(long x, long y, float height, Alignment align, Vector3* outpos);
    01645         void calculateCurrentLod(Viewport* vp);
    01647         std::pair<bool, Vector3> checkQuadIntersection(int x, int y, const Ray& ray); //const;
    01648
    01650         void deleteBlendMaps(uint8 lowIndex);
    01652         void shiftUpGPUBlendChannels(uint8 index);
    01654         void shiftDownGPUBlendChannels(uint8 index);
    01656         void copyBlendTextureChannel(uint8 srcIndex, uint8 srcChannel, uint8 destIndex, uint8 destChannel );
    01658         void clearGPUBlendChannel(uint8 index, uint channel);
    01659
    01660         void copyGlobalOptions();
    01661         void checkLayers(bool includeGPUResources);
    01662         void checkDeclaration();
    01663         void deriveUVMultipliers();
    01664         PixelFormat getBlendTextureFormat(uint8 textureIndex, uint8 numLayers);
    01665
    01666         void updateDerivedDataImpl(const Rect& rect, const Rect& lightmapExtraRect, bool synchronous, uint8 typeMask);
    01667
    01668         void getEdgeRect(NeighbourIndex index, long range, Rect* outRect);
    01669         // get the equivalent of the passed in edge rectangle in neighbour
    01670         void getNeighbourEdgeRect(NeighbourIndex index, const Rect& inRect, Rect* outRect);
    01671         // get the equivalent of the passed in edge point in neighbour
    01672         void getNeighbourPoint(NeighbourIndex index, long x, long y, long *outx, long *outy);
    01673         // overflow a point into a neighbour index and point
    01674         void getNeighbourPointOverflow(long x, long y, NeighbourIndex *outindex, long *outx, long *outy);
    01675
    01676
    01677
    01678         uint16 mWorkQueueChannel;
    01679         SceneManager* mSceneMgr;
    01680         SceneNode* mRootNode;
    01681         String mResourceGroup;
    01682         bool mIsLoaded;
    01683         bool mModified;
    01684         bool mHeightDataModified;
    01685
    01687         float* mHeightData;
    01689         float* mDeltaData;
    01690         Alignment mAlign;
    01691         Real mWorldSize;
    01692         uint16 mSize;
    01693         uint16 mMaxBatchSize;
    01694         uint16 mMinBatchSize;
    01695         Vector3 mPos;
    01696         TerrainQuadTreeNode* mQuadTree;
    01697         uint16 mNumLodLevels;
    01698         uint16 mNumLodLevelsPerLeafNode;
    01699         uint16 mTreeDepth;
    01701         Real mBase;
    01703         Real mScale;
    01704         TerrainLayerDeclaration mLayerDecl;
    01705         LayerInstanceList mLayers;
    01706         RealVector mLayerUVMultiplier;
    01707
    01708         Real mSkirtSize;
    01709         uint8 mRenderQueueGroup;
    01710         uint32 mVisibilityFlags;
    01711         uint32 mQueryFlags;
    01712
    01713         Rect mDirtyGeometryRect;
    01714         Rect mDirtyDerivedDataRect;
    01715         Rect mDirtyGeometryRectForNeighbours;
    01716         Rect mDirtyLightmapFromNeighboursRect;
    01717         bool mDerivedDataUpdateInProgress;
    01718         uint8 mDerivedUpdatePendingMask; // if another update is requested while one is already running
    01719
    01721         struct DerivedDataRequest
    01722         {
    01723             Terrain* terrain;
    01724             // types requested
    01725             uint8 typeMask;
    01726             Rect dirtyRect;
    01727             Rect lightmapExtraDirtyRect;
    01728             _OgreTerrainExport friend std::ostream& operator<<(std::ostream& o, const DerivedDataRequest& r)
    01729             { return o; }
    01730         };
    01731
    01733         struct DerivedDataResponse
    01734         {
    01735             Terrain* terrain;
    01736             // remaining types not yet processed
    01737             uint8 remainingTypeMask;
    01738             // The area of deltas that was updated
    01739             Rect deltaUpdateRect;
    01740             // the area of normals that was updated
    01741             Rect normalUpdateRect;
    01742             // the area of lightmap that was updated
    01743             Rect lightmapUpdateRect;
    01744             // all CPU-side data, independent of textures; to be blitted in main thread
    01745             PixelBox* normalMapBox;
    01746             PixelBox* lightMapBox;
    01747             _OgreTerrainExport friend std::ostream& operator<<(std::ostream& o, const DerivedDataResponse& r)
    01748             { return o; }
    01749         };
    01750
    01751         String mMaterialName;
    01752         mutable MaterialPtr mMaterial;
    01753         mutable TerrainMaterialGeneratorPtr mMaterialGenerator;
    01754         mutable unsigned long long int mMaterialGenerationCount;
    01755         mutable bool mMaterialDirty;
    01756         mutable bool mMaterialParamsDirty;
    01757
    01758         uint16 mLayerBlendMapSize;
    01759         uint16 mLayerBlendMapSizeActual;
    01760         typedef vector<uint8*>::type BytePointerList;
    01762         BytePointerList mCpuBlendMapStorage;
    01763         typedef vector<TexturePtr>::type TexturePtrList;
    01764         TexturePtrList mBlendTextureList;
    01765         TerrainLayerBlendMapList mLayerBlendMapList;
    01766
    01767         uint16 mGlobalColourMapSize;
    01768         bool mGlobalColourMapEnabled;
    01769         TexturePtr mColourMap;
    01770         uint8* mCpuColourMapStorage;
    01771
    01772         uint16 mLightmapSize;
    01773         uint16 mLightmapSizeActual;
    01774         TexturePtr mLightmap;
    01775         uint8* mCpuLightmapStorage;
    01776
    01777         uint16 mCompositeMapSize;
    01778         uint16 mCompositeMapSizeActual;
    01779         TexturePtr mCompositeMap;
    01780         uint8* mCpuCompositeMapStorage;
    01781         Rect mCompositeMapDirtyRect;
    01782         unsigned long mCompositeMapUpdateCountdown;
    01783         unsigned long mLastMillis;
    01785         bool mCompositeMapDirtyRectLightmapUpdate;
    01786         mutable MaterialPtr mCompositeMapMaterial;
    01787
    01788
    01789         static NameGenerator msBlendTextureGenerator;
    01790         static NameGenerator msNormalMapNameGenerator;
    01791         static NameGenerator msLightmapNameGenerator;
    01792         static NameGenerator msCompositeMapNameGenerator;
    01793
    01794         bool mLodMorphRequired;
    01795         bool mNormalMapRequired;
    01796         bool mLightMapRequired;
    01797         bool mLightMapShadowsOnly;
    01798         bool mCompositeMapRequired;
    01800         TexturePtr mTerrainNormalMap;
    01801
    01803         PixelBox* mCpuTerrainNormalMap;
    01804
    01805         const Camera* mLastLODCamera;
    01806         unsigned long mLastLODFrame;
    01807         int mLastViewportHeight;
    01808
    01809         Terrain* mNeighbours[NEIGHBOUR_COUNT];
    01810
    01811         GpuBufferAllocator* mCustomGpuBufferAllocator;
    01812         DefaultGpuBufferAllocator mDefaultGpuBufferAllocator;
    01813
    01814         size_t getPositionBufVertexSize() const;
    01815         size_t getDeltaBufVertexSize() const;
    01816
    01817     };
    01818
    01819
    01829     class _OgreTerrainExport TerrainGlobalOptions : public TerrainAlloc, public Singleton<TerrainGlobalOptions>
    01830     {
    01831     protected:
    01832
    01833         Real mSkirtSize;
    01834         Vector3 mLightMapDir;
    01835         bool mCastsShadows;
    01836         Real mMaxPixelError;
    01837         uint8 mRenderQueueGroup;
    01838         uint32 mVisibilityFlags;
    01839         uint32 mQueryFlags;
    01840         bool mUseRayBoxDistanceCalculation;
    01841         TerrainMaterialGeneratorPtr mDefaultMaterialGenerator;
    01842         uint16 mLayerBlendMapSize;
    01843         Real mDefaultLayerTextureWorldSize;
    01844         uint16 mDefaultGlobalColourMapSize;
    01845         uint16 mLightmapSize;
    01846         uint16 mCompositeMapSize;
    01847         ColourValue mCompositeMapAmbient;
    01848         ColourValue mCompositeMapDiffuse;
    01849         Real mCompositeMapDistance;
    01850         String mResourceGroup;
    01851         bool mUseVertexCompressionWhenAvailable;
    01852
    01853     public:
    01854         TerrainGlobalOptions();
    01855         virtual ~TerrainGlobalOptions() {}
    01856
    01857
    01861         Real getSkirtSize() { return mSkirtSize; }
    01867         void setSkirtSize(Real skirtSz) { mSkirtSize = skirtSz; }
    01869         const Vector3& getLightMapDirection() { return mLightMapDir; }
    01871         void setLightMapDirection(const Vector3& v) { mLightMapDir = v; }
    01873         const ColourValue& getCompositeMapAmbient() { return mCompositeMapAmbient; }
    01875         void setCompositeMapAmbient(const ColourValue& c) { mCompositeMapAmbient = c; }
    01877         const ColourValue& getCompositeMapDiffuse() { return mCompositeMapDiffuse; }
    01879         void setCompositeMapDiffuse(const ColourValue& c) { mCompositeMapDiffuse = c; }
    01881         Real getCompositeMapDistance() { return mCompositeMapDistance; }
    01883         void setCompositeMapDistance(Real c) { mCompositeMapDistance = c; }
    01884
    01885
    01889         bool getCastsDynamicShadows() { return mCastsShadows; }
    01890
    01896         void setCastsDynamicShadows(bool s) { mCastsShadows = s; }
    01897
    01899         Real getMaxPixelError() { return mMaxPixelError; }
    01900
    01906         void setMaxPixelError(Real pixerr) { mMaxPixelError = pixerr; }
    01907
    01909         uint8 getRenderQueueGroup(void) { return mRenderQueueGroup; }
    01914         void setRenderQueueGroup(uint8 grp) { mRenderQueueGroup = grp; }
    01915
    01917         uint32 getVisibilityFlags(void) { return mVisibilityFlags; }
    01922         void setVisibilityFlags(uint32 flags) { mVisibilityFlags = flags; }
    01923
    01928         void  setQueryFlags(uint32 flags) { mQueryFlags = flags; }
    01931         uint32 getQueryFlags(void) { return mQueryFlags; }
    01932
    01934         void addQueryFlags(uint32 flags) { mQueryFlags |= flags; }
    01935
    01936         /* As setQueryFlags, except the flags passed as parameters are removed from the existing flags on this object. */
    01937         void removeQueryFlags(uint32 flags) { mQueryFlags &= ~flags; }
    01938
    01943         bool getUseRayBoxDistanceCalculation() { return mUseRayBoxDistanceCalculation; }
    01944
    01956         void setUseRayBoxDistanceCalculation(bool rb) { mUseRayBoxDistanceCalculation = rb; }
    01957
    01960         TerrainMaterialGeneratorPtr getDefaultMaterialGenerator();
    01961
    01964         void setDefaultMaterialGenerator(TerrainMaterialGeneratorPtr gen);
    01965
    01968         uint16 getLayerBlendMapSize() { return mLayerBlendMapSize; }
    01969
    01974         void setLayerBlendMapSize(uint16 sz) { mLayerBlendMapSize = sz;}
    01975
    01978         Real getDefaultLayerTextureWorldSize() { return mDefaultLayerTextureWorldSize; }
    01979
    01982         void setDefaultLayerTextureWorldSize(Real sz) { mDefaultLayerTextureWorldSize = sz; }
    01983
    01986         uint16 getDefaultGlobalColourMapSize() { return mDefaultGlobalColourMapSize; }
    01987
    01991         void setDefaultGlobalColourMapSize(uint16 sz) { mDefaultGlobalColourMapSize = sz;}
    01992
    01993
    01996         uint16 getLightMapSize() { return mLightmapSize; }
    01997
    02000         void setLightMapSize(uint16 sz) { mLightmapSize = sz;}
    02001
    02004         uint16 getCompositeMapSize() { return mCompositeMapSize; }
    02005
    02008         void setCompositeMapSize(uint16 sz) { mCompositeMapSize = sz;}
    02009
    02012         void setDefaultResourceGroup(const String& grp) { mResourceGroup = grp; }
    02013
    02016         const String& getDefaultResourceGroup() { return mResourceGroup; }
    02017
    02021         bool getUseVertexCompressionWhenAvailable() const { return mUseVertexCompressionWhenAvailable; }
    02022
    02030         void setUseVertexCompressionWhenAvailable(bool enable) { mUseVertexCompressionWhenAvailable = enable; }
    02031
    02047         static TerrainGlobalOptions& getSingleton(void);
    02063         static TerrainGlobalOptions* getSingletonPtr(void);
    02064
    02065
    02066     };
    02067
    02068
    02071 }
    02072
    02073
    02074
    02075
    02076 #endif

Copyright © 2012 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Sun Sep 2 2012 07:27:24