OGRE: OgreTerrain.h Source File - OGRE Documentation

# 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-2009 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);
    00846         void getTerrainVector(const Vector3& inVec, Vector3* outVec);
    00851         void getTerrainVectorAlign(const Vector3& inVec, Alignment align, Vector3* outVec);
    00852
    00857         void getTerrainVector(Real x, Real y, Real z, Vector3* outVec);
    00862         void getTerrainVectorAlign(Real x, Real y, Real z, Alignment align, Vector3* outVec);
    00863
    00868         void getVector(const Vector3& inVec, Vector3* outVec);
    00873         void getVectorAlign(const Vector3& inVec, Alignment align, Vector3* outVec);
    00874
    00879         void getVector(Real x, Real y, Real z, Vector3* outVec);
    00884         void getVectorAlign(Real x, Real y, Real z, Alignment align, Vector3* outVec);
    00885
    00886
    00894         void getPosition(const Vector3& TSpos, Vector3* outWSpos);
    00902         void getPosition(Real x, Real y, Real z, Vector3* outWSpos);
    00903
    00910         void getTerrainPosition(const Vector3& WSpos, Vector3* outTSpos);
    00917         void getTerrainPosition(Real x, Real y, Real z, Vector3* outTSpos);
    00924         void getPositionAlign(const Vector3& TSpos, Alignment align, Vector3* outWSpos);
    00931         void getPositionAlign(Real x, Real y, Real z, Alignment align, Vector3* outWSpos);
    00932
    00939         void getTerrainPositionAlign(const Vector3& WSpos, Alignment align, Vector3* outTSpos);
    00946         void getTerrainPositionAlign(Real x, Real y, Real z, Alignment align, Vector3* outTSpos);
    00947
    00948
    00950         Alignment getAlignment() const;
    00952         uint16 getSize() const;
    00954         uint16 getMaxBatchSize() const;
    00956         uint16 getMinBatchSize() const;
    00958         Real getWorldSize() const;
    00959
    00961         uint8 getLayerCount() const { return static_cast<uint8>(mLayers.size()); }
    00962
    00964         const TerrainLayerDeclaration& getLayerDeclaration() const { return mLayerDecl; }
    00965
    00972         void addLayer(Real worldSize = 0, const StringVector* textureNames = 0);
    00973
    00981         void addLayer(uint8 index, Real worldSize = 0, const StringVector* textureNames = 0);
    00982
    00985         void removeLayer(uint8 index);
    00986
    00996         void replaceLayer(uint8 index, bool keepBlends, Real worldSize = 0, const StringVector* textureNames = 0);
    00997
    01001         uint8 getMaxLayers() const;
    01002
    01007         Real getLayerWorldSize(uint8 index) const;
    01013         void setLayerWorldSize(uint8 index, Real size);
    01014
    01023         Real getLayerUVMultiplier(uint8 index) const;
    01024
    01030         const String& getLayerTextureName(uint8 layerIndex, uint8 samplerIndex) const;
    01037         void setLayerTextureName(uint8 layerIndex, uint8 samplerIndex, const String& textureName);
    01038
    01045         uint16 getLayerBlendMapSize() const { return mLayerBlendMapSize; }
    01046
    01052         uint16 getLightmapSize() const { return mLightmapSize; }
    01053
    01055         const TexturePtr& getLightmap() const { return mLightmap; }
    01056
    01062         uint16 getCompositeMapSize() const { return mCompositeMapSize; }
    01063
    01065         const TexturePtr& getCompositeMap() const { return mCompositeMap; }
    01066
    01068         const Vector3& getPosition() const { return mPos; }
    01070         void setPosition(const Vector3& pos);
    01072         SceneNode* _getRootSceneNode() const;
    01079         void dirty();
    01080
    01089         void dirtyRect(const Rect& rect);
    01090
    01096         void _dirtyCompositeMapRect(const Rect& rect);
    01097
    01108         void dirtyLightmapRect(const Rect& rect);
    01109
    01120         void dirtyLightmap();
    01121
    01144         void update(bool synchronous = false);
    01145
    01150         void updateGeometry();
    01151
    01152         // Used as a type mask for updateDerivedData
    01153         static const uint8 DERIVED_DATA_DELTAS;
    01154         static const uint8 DERIVED_DATA_NORMALS;
    01155         static const uint8 DERIVED_DATA_LIGHTMAP;
    01156         static const uint8 DERIVED_DATA_ALL;
    01157
    01169         void updateDerivedData(bool synchronous = false, uint8 typeMask = 0xFF);
    01170
    01179         void updateCompositeMap();
    01180
    01194         void updateCompositeMapWithDelay(Real delay = 2);
    01195
    01196
    01200         Real getSkirtSize() const { return mSkirtSize; }
    01201
    01203         uint16 getNumLodLevels() const { return mNumLodLevels; }
    01204
    01206         uint16 getNumLodLevelsPerLeaf() const { return mNumLodLevelsPerLeafNode; }
    01207
    01215         Rect calculateHeightDeltas(const Rect& rect);
    01216
    01224         void finaliseHeightDeltas(const Rect& rect, bool cpuData);
    01225
    01231         PixelBox* calculateNormals(const Rect& rect, Rect& outFinalRect);
    01232
    01240         void finaliseNormals(const Rect& rect, PixelBox* normalsBox);
    01241
    01249         PixelBox* calculateLightmap(const Rect& rect, const Rect& extraTargetRect, Rect& outFinalRect);
    01250
    01258         void finaliseLightmap(const Rect& rect, PixelBox* lightmapBox);
    01259
    01263         uint16 getResolutionAtLod(uint16 lodLevel);
    01264
    01276         std::pair<bool, Vector3> rayIntersects(const Ray& ray,
    01277             bool cascadeToNeighbours = false, Real distanceLimit = 0); //const;
    01278
    01280         const AxisAlignedBox& getAABB() const;
    01282         AxisAlignedBox getWorldAABB() const;
    01284         Real getMinHeight() const;
    01286         Real getMaxHeight() const;
    01288         Real getBoundingRadius() const;
    01289
    01291         const MaterialPtr& getMaterial() const;
    01293         const MaterialPtr& _getMaterial() const { return mMaterial; }
    01295         const MaterialPtr& getCompositeMapMaterial() const;
    01297         const MaterialPtr& _getCompositeMapMaterial() const { return mCompositeMapMaterial; }
    01298
    01300         const String& getMaterialName() const { return mMaterialName; }
    01301
    01303         void preFindVisibleObjects(SceneManager* source,
    01304             SceneManager::IlluminationRenderStage irs, Viewport* v);
    01306         void sceneManagerDestroyed(SceneManager* source);
    01307
    01309         uint8 getRenderQueueGroup(void) const { return mRenderQueueGroup; }
    01313         void setRenderQueueGroup(uint8 grp) { mRenderQueueGroup = grp; }
    01314
    01316         uint32 getVisibilityFlags(void) const { return mVisibilityFlags; }
    01320         void setVisibilityFlags(uint32 flags) { mVisibilityFlags = flags; }
    01321
    01323         uint32 getQueryFlags(void) const { return mQueryFlags; }
    01327         void setQueryFlags(uint32 flags) { mQueryFlags = flags; }
    01328
    01330         void addQueryFlags(uint32 flags) { mQueryFlags |= flags; }
    01331
    01332         /* As setQueryFlags, except the flags passed as parameters are removed from the existing flags on this object. */
    01333         void removeQueryFlags(uint32 flags) { mQueryFlags &= ~flags; }
    01334
    01335
    01348         TerrainLayerBlendMap* getLayerBlendMap(uint8 layerIndex);
    01349
    01355         uint8 getBlendTextureIndex(uint8 layerIndex) const;
    01356
    01358         uint8 getBlendTextureCount() const;
    01360         uint8 getBlendTextureCount(uint8 numLayers) const;
    01361
    01362
    01367         const String& getBlendTextureName(uint8 textureIndex) const;
    01368
    01381         void setGlobalColourMapEnabled(bool enabled, uint16 size = 0);
    01383         bool getGlobalColourMapEnabled() const { return mGlobalColourMapEnabled; }
    01385         uint16 getGlobalColourMapSize() const { return mGlobalColourMapSize; }
    01387         const TexturePtr& getGlobalColourMap() const { return mColourMap; }
    01388
    01394         void widenRectByVector(const Vector3& vec, const Rect& inRect, Rect& outRect);
    01395
    01403         void widenRectByVector(const Vector3& vec, const Rect& inRect,
    01404             Real minHeight, Real maxHeight, Rect& outRect);
    01405
    01415         void freeTemporaryResources();
    01416
    01421         const TexturePtr& getLayerBlendTexture(uint8 index);
    01422
    01429         std::pair<uint8,uint8> getLayerBlendTextureIndex(uint8 layerIndex);
    01430
    01441         void _setMorphRequired(bool morph) { mLodMorphRequired = morph; }
    01443         bool _getMorphRequired() const { return mLodMorphRequired; }
    01444
    01456         void _setNormalMapRequired(bool normalMap);
    01457
    01471         void _setLightMapRequired(bool lightMap, bool shadowsOnly = false);
    01472
    01491         void _setCompositeMapRequired(bool compositeMap);
    01492
    01494         bool canHandleRequest(const WorkQueue::Request* req, const WorkQueue* srcQ);
    01496         WorkQueue::Response* handleRequest(const WorkQueue::Request* req, const WorkQueue* srcQ);
    01498         bool canHandleResponse(const WorkQueue::Response* res, const WorkQueue* srcQ);
    01500         void handleResponse(const WorkQueue::Response* res, const WorkQueue* srcQ);
    01501
    01502         static const uint16 WORKQUEUE_DERIVED_DATA_REQUEST;
    01503
    01504
    01506         uint16 getLODLevelWhenVertexEliminated(long x, long y);
    01508         uint16 getLODLevelWhenVertexEliminated(long rowOrColulmn);
    01509
    01510
    01512         TerrainQuadTreeNode* getQuadTree() { return mQuadTree; }
    01513
    01515         TexturePtr getTerrainNormalMap() const { return mTerrainNormalMap; }
    01516
    01524         Terrain* getNeighbour(NeighbourIndex index);
    01525
    01543         void setNeighbour(NeighbourIndex index, Terrain* neighbour, bool recalculate = false, bool notifyOther = true);
    01544
    01549         static NeighbourIndex getOppositeNeighbour(NeighbourIndex index);
    01550
    01553         static NeighbourIndex getNeighbourIndex(long offsetx, long offsety);
    01554
    01562         void notifyNeighbours();
    01563
    01571         void neighbourModified(NeighbourIndex index, const Rect& edgerect, const Rect& shadowrect);
    01572
    01578         Terrain* raySelectNeighbour(const Ray& ray, Real distanceLimit = 0);
    01579
    01584         void _dumpTextures(const String& prefix, const String& suffix);
    01585
    01587         bool isDerivedDataUpdateInProgress() const { return mDerivedDataUpdateInProgress; }
    01588
    01589
    01591         static void convertWorldToTerrainAxes(Alignment align, const Vector3& worldVec, Vector3* terrainVec);
    01593         static void convertTerrainToWorldAxes(Alignment align, const Vector3& terrainVec, Vector3* worldVec);
    01594
    01596         static void writeLayerDeclaration(const TerrainLayerDeclaration& decl, StreamSerialiser& ser);
    01598         static bool readLayerDeclaration(StreamSerialiser& ser, TerrainLayerDeclaration& targetdecl);
    01600         static void writeLayerInstanceList(const Terrain::LayerInstanceList& lst, StreamSerialiser& ser);
    01602         static bool readLayerInstanceList(StreamSerialiser& ser, size_t numSamplers, Terrain::LayerInstanceList& targetlst);
    01603     protected:
    01604
    01605         void freeCPUResources();
    01606         void freeGPUResources();
    01607         void determineLodLevels();
    01608         void distributeVertexData();
    01609         void updateBaseScale();
    01610         void createGPUBlendTextures();
    01611         void createLayerBlendMaps();
    01612         void createOrDestroyGPUNormalMap();
    01613         void createOrDestroyGPUColourMap();
    01614         void createOrDestroyGPULightmap();
    01615         void createOrDestroyGPUCompositeMap();
    01616         void waitForDerivedProcesses();
    01617         void convertSpace(Space inSpace, const Vector3& inVec, Space outSpace, Vector3& outVec, bool translation) const;
    01618         Vector3 convertWorldToTerrainAxes(const Vector3& inVec) const;
    01619         Vector3 convertTerrainToWorldAxes(const Vector3& inVec) const;
    01623         void getPointAlign(long x, long y, Alignment align, Vector3* outpos);
    01628         void getPointAlign(long x, long y, float height, Alignment align, Vector3* outpos);
    01629         void calculateCurrentLod(Viewport* vp);
    01631         std::pair<bool, Vector3> checkQuadIntersection(int x, int y, const Ray& ray); //const;
    01632
    01634         void deleteBlendMaps(uint8 lowIndex);
    01636         void shiftUpGPUBlendChannels(uint8 index);
    01638         void shiftDownGPUBlendChannels(uint8 index);
    01640         void copyBlendTextureChannel(uint8 srcIndex, uint8 srcChannel, uint8 destIndex, uint8 destChannel );
    01642         void clearGPUBlendChannel(uint8 index, uint channel);
    01643
    01644         void copyGlobalOptions();
    01645         void checkLayers(bool includeGPUResources);
    01646         void checkDeclaration();
    01647         void deriveUVMultipliers();
    01648         PixelFormat getBlendTextureFormat(uint8 textureIndex, uint8 numLayers);
    01649
    01650         void updateDerivedDataImpl(const Rect& rect, const Rect& lightmapExtraRect, bool synchronous, uint8 typeMask);
    01651
    01652         void getEdgeRect(NeighbourIndex index, long range, Rect* outRect);
    01653         // get the equivalent of the passed in edge rectangle in neighbour
    01654         void getNeighbourEdgeRect(NeighbourIndex index, const Rect& inRect, Rect* outRect);
    01655         // get the equivalent of the passed in edge point in neighbour
    01656         void getNeighbourPoint(NeighbourIndex index, long x, long y, long *outx, long *outy);
    01657         // overflow a point into a neighbour index and point
    01658         void getNeighbourPointOverflow(long x, long y, NeighbourIndex *outindex, long *outx, long *outy);
    01659
    01660
    01661
    01662         uint16 mWorkQueueChannel;
    01663         SceneManager* mSceneMgr;
    01664         SceneNode* mRootNode;
    01665         String mResourceGroup;
    01666         bool mIsLoaded;
    01667         bool mModified;
    01668         bool mHeightDataModified;
    01669
    01671         float* mHeightData;
    01673         float* mDeltaData;
    01674         Alignment mAlign;
    01675         Real mWorldSize;
    01676         uint16 mSize;
    01677         uint16 mMaxBatchSize;
    01678         uint16 mMinBatchSize;
    01679         Vector3 mPos;
    01680         TerrainQuadTreeNode* mQuadTree;
    01681         uint16 mNumLodLevels;
    01682         uint16 mNumLodLevelsPerLeafNode;
    01683         uint16 mTreeDepth;
    01685         Real mBase;
    01687         Real mScale;
    01688         TerrainLayerDeclaration mLayerDecl;
    01689         LayerInstanceList mLayers;
    01690         RealVector mLayerUVMultiplier;
    01691
    01692         Real mSkirtSize;
    01693         uint8 mRenderQueueGroup;
    01694         uint32 mVisibilityFlags;
    01695         uint32 mQueryFlags;
    01696
    01697         Rect mDirtyGeometryRect;
    01698         Rect mDirtyDerivedDataRect;
    01699         Rect mDirtyGeometryRectForNeighbours;
    01700         Rect mDirtyLightmapFromNeighboursRect;
    01701         bool mDerivedDataUpdateInProgress;
    01702         uint8 mDerivedUpdatePendingMask; // if another update is requested while one is already running
    01703
    01705         struct DerivedDataRequest
    01706         {
    01707             Terrain* terrain;
    01708             // types requested
    01709             uint8 typeMask;
    01710             Rect dirtyRect;
    01711             Rect lightmapExtraDirtyRect;
    01712             _OgreTerrainExport friend std::ostream& operator<<(std::ostream& o, const DerivedDataRequest& r)
    01713             { return o; }
    01714         };
    01715
    01717         struct DerivedDataResponse
    01718         {
    01719             Terrain* terrain;
    01720             // remaining types not yet processed
    01721             uint8 remainingTypeMask;
    01722             // The area of deltas that was updated
    01723             Rect deltaUpdateRect;
    01724             // the area of normals that was updated
    01725             Rect normalUpdateRect;
    01726             // the area of lightmap that was updated
    01727             Rect lightmapUpdateRect;
    01728             // all CPU-side data, independent of textures; to be blitted in main thread
    01729             PixelBox* normalMapBox;
    01730             PixelBox* lightMapBox;
    01731             _OgreTerrainExport friend std::ostream& operator<<(std::ostream& o, const DerivedDataResponse& r)
    01732             { return o; }
    01733         };
    01734
    01735         String mMaterialName;
    01736         mutable MaterialPtr mMaterial;
    01737         mutable TerrainMaterialGeneratorPtr mMaterialGenerator;
    01738         mutable unsigned long long int mMaterialGenerationCount;
    01739         mutable bool mMaterialDirty;
    01740         mutable bool mMaterialParamsDirty;
    01741
    01742         uint16 mLayerBlendMapSize;
    01743         uint16 mLayerBlendMapSizeActual;
    01744         typedef vector<uint8*>::type BytePointerList;
    01746         BytePointerList mCpuBlendMapStorage;
    01747         typedef vector<TexturePtr>::type TexturePtrList;
    01748         TexturePtrList mBlendTextureList;
    01749         TerrainLayerBlendMapList mLayerBlendMapList;
    01750
    01751         uint16 mGlobalColourMapSize;
    01752         bool mGlobalColourMapEnabled;
    01753         TexturePtr mColourMap;
    01754         uint8* mCpuColourMapStorage;
    01755
    01756         uint16 mLightmapSize;
    01757         uint16 mLightmapSizeActual;
    01758         TexturePtr mLightmap;
    01759         uint8* mCpuLightmapStorage;
    01760
    01761         uint16 mCompositeMapSize;
    01762         uint16 mCompositeMapSizeActual;
    01763         TexturePtr mCompositeMap;
    01764         uint8* mCpuCompositeMapStorage;
    01765         Rect mCompositeMapDirtyRect;
    01766         unsigned long mCompositeMapUpdateCountdown;
    01767         unsigned long mLastMillis;
    01769         bool mCompositeMapDirtyRectLightmapUpdate;
    01770         mutable MaterialPtr mCompositeMapMaterial;
    01771
    01772
    01773         static NameGenerator msBlendTextureGenerator;
    01774         static NameGenerator msNormalMapNameGenerator;
    01775         static NameGenerator msLightmapNameGenerator;
    01776         static NameGenerator msCompositeMapNameGenerator;
    01777
    01778         bool mLodMorphRequired;
    01779         bool mNormalMapRequired;
    01780         bool mLightMapRequired;
    01781         bool mLightMapShadowsOnly;
    01782         bool mCompositeMapRequired;
    01784         TexturePtr mTerrainNormalMap;
    01785
    01787         PixelBox* mCpuTerrainNormalMap;
    01788
    01789         const Camera* mLastLODCamera;
    01790         unsigned long mLastLODFrame;
    01791         int mLastViewportHeight;
    01792
    01793         Terrain* mNeighbours[NEIGHBOUR_COUNT];
    01794
    01795         GpuBufferAllocator* mCustomGpuBufferAllocator;
    01796         DefaultGpuBufferAllocator mDefaultGpuBufferAllocator;
    01797
    01798         size_t getPositionBufVertexSize() const;
    01799         size_t getDeltaBufVertexSize() const;
    01800
    01801     };
    01802
    01803
    01813     class _OgreTerrainExport TerrainGlobalOptions : public TerrainAlloc, public Singleton<TerrainGlobalOptions>
    01814     {
    01815     protected:
    01816
    01817         Real mSkirtSize;
    01818         Vector3 mLightMapDir;
    01819         bool mCastsShadows;
    01820         Real mMaxPixelError;
    01821         uint8 mRenderQueueGroup;
    01822         uint32 mVisibilityFlags;
    01823         uint32 mQueryFlags;
    01824         bool mUseRayBoxDistanceCalculation;
    01825         TerrainMaterialGeneratorPtr mDefaultMaterialGenerator;
    01826         uint16 mLayerBlendMapSize;
    01827         Real mDefaultLayerTextureWorldSize;
    01828         uint16 mDefaultGlobalColourMapSize;
    01829         uint16 mLightmapSize;
    01830         uint16 mCompositeMapSize;
    01831         ColourValue mCompositeMapAmbient;
    01832         ColourValue mCompositeMapDiffuse;
    01833         Real mCompositeMapDistance;
    01834         String mResourceGroup;
    01835
    01836     public:
    01837         TerrainGlobalOptions();
    01838         virtual ~TerrainGlobalOptions() {}
    01839
    01840
    01844         Real getSkirtSize() { return mSkirtSize; }
    01850         void setSkirtSize(Real skirtSz) { mSkirtSize = skirtSz; }
    01852         const Vector3& getLightMapDirection() { return mLightMapDir; }
    01854         void setLightMapDirection(const Vector3& v) { mLightMapDir = v; }
    01856         const ColourValue& getCompositeMapAmbient() { return mCompositeMapAmbient; }
    01858         void setCompositeMapAmbient(const ColourValue& c) { mCompositeMapAmbient = c; }
    01860         const ColourValue& getCompositeMapDiffuse() { return mCompositeMapDiffuse; }
    01862         void setCompositeMapDiffuse(const ColourValue& c) { mCompositeMapDiffuse = c; }
    01864         Real getCompositeMapDistance() { return mCompositeMapDistance; }
    01866         void setCompositeMapDistance(Real c) { mCompositeMapDistance = c; }
    01867
    01868
    01872         bool getCastsDynamicShadows() { return mCastsShadows; }
    01873
    01879         void setCastsDynamicShadows(bool s) { mCastsShadows = s; }
    01880
    01882         Real getMaxPixelError() { return mMaxPixelError; }
    01883
    01889         void setMaxPixelError(Real pixerr) { mMaxPixelError = pixerr; }
    01890
    01892         uint8 getRenderQueueGroup(void) { return mRenderQueueGroup; }
    01897         void setRenderQueueGroup(uint8 grp) { mRenderQueueGroup = grp; }
    01898
    01900         uint32 getVisibilityFlags(void) { return mVisibilityFlags; }
    01905         void setVisibilityFlags(uint32 flags) { mVisibilityFlags = flags; }
    01906
    01911         void  setQueryFlags(uint32 flags) { mQueryFlags = flags; }
    01914         uint32 getQueryFlags(void) { return mQueryFlags; }
    01915
    01917         void addQueryFlags(uint32 flags) { mQueryFlags |= flags; }
    01918
    01919         /* As setQueryFlags, except the flags passed as parameters are removed from the existing flags on this object. */
    01920         void removeQueryFlags(uint32 flags) { mQueryFlags &= ~flags; }
    01921
    01926         bool getUseRayBoxDistanceCalculation() { return mUseRayBoxDistanceCalculation; }
    01927
    01939         void setUseRayBoxDistanceCalculation(bool rb) { mUseRayBoxDistanceCalculation = rb; }
    01940
    01943         TerrainMaterialGeneratorPtr getDefaultMaterialGenerator();
    01944
    01947         void setDefaultMaterialGenerator(TerrainMaterialGeneratorPtr gen);
    01948
    01951         uint16 getLayerBlendMapSize() { return mLayerBlendMapSize; }
    01952
    01957         void setLayerBlendMapSize(uint16 sz) { mLayerBlendMapSize = sz;}
    01958
    01961         Real getDefaultLayerTextureWorldSize() { return mDefaultLayerTextureWorldSize; }
    01962
    01965         void setDefaultLayerTextureWorldSize(Real sz) { mDefaultLayerTextureWorldSize = sz; }
    01966
    01969         uint16 getDefaultGlobalColourMapSize() { return mDefaultGlobalColourMapSize; }
    01970
    01974         void setDefaultGlobalColourMapSize(uint16 sz) { mDefaultGlobalColourMapSize = sz;}
    01975
    01976
    01979         uint16 getLightMapSize() { return mLightmapSize; }
    01980
    01983         void setLightMapSize(uint16 sz) { mLightmapSize = sz;}
    01984
    01987         uint16 getCompositeMapSize() { return mCompositeMapSize; }
    01988
    01991         void setCompositeMapSize(uint16 sz) { mCompositeMapSize = sz;}
    01992
    01995         void setDefaultResourceGroup(const String& grp) { mResourceGroup = grp; }
    01996
    01999         const String& getDefaultResourceGroup() { return mResourceGroup; }
    02000
    02016         static TerrainGlobalOptions& getSingleton(void);
    02032         static TerrainGlobalOptions* getSingletonPtr(void);
    02033
    02034
    02035     };
    02036
    02037
    02040 }
    02041
    02042
    02043
    02044
    02045 #endif

Copyright © 2008 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Wed Nov 3 2010 19:24:52