1 files changed, 330 insertions, 0 deletions
diff --git a/src/others/irrlicht-1.8.1/source/Irrlicht/CTerrainSceneNode.h b/src/others/irrlicht-1.8.1/source/Irrlicht/CTerrainSceneNode.h
new file mode 100644
index 0000000..1d92f66
--- /dev/null
+++ b/src/others/irrlicht-1.8.1/source/Irrlicht/CTerrainSceneNode.h
@@ -0,0 +1,330 @@
+// Copyright (C) 2002-2012 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+// The code for the TerrainSceneNode is based on the GeoMipMapSceneNode
+// developed by Spintz. He made it available for Irrlicht and allowed it to be
+// distributed under this licence. I only modified some parts. A lot of thanks go to him.
+#ifndef __C_TERRAIN_SCENE_NODE_H__
+#define __C_TERRAIN_SCENE_NODE_H__
+#include "ITerrainSceneNode.h"
+#include "IDynamicMeshBuffer.h"
+#include "path.h"
+namespace irr
+{
+namespace io
+{
+        class IFileSystem;
+        class IReadFile;
+}
+namespace scene
+{
+        struct SMesh;
+        class ITextSceneNode;
+        //! A scene node for displaying terrain using the geo mip map algorithm.
+        class CTerrainSceneNode : public ITerrainSceneNode
+        {
+        public:
+                //! constructor
+                //! \param parent: The node which this node is a child of.  Making this node a child of another node, or
+                //! making it a parent of another node is yet untested and most likely does not work properly.
+                //! \param mgr: Pointer to the scene manager.
+                //! \param id: The id of the node
+                //! \param maxLOD: The maximum LOD ( Level of Detail ) for the node.
+                //! \param patchSize: An E_GEOMIPMAP_PATCH_SIZE enumeration defining the size of each patch of the terrain.
+                //! \param position: The absolute position of this node.
+                //! \param rotation: The absolute rotation of this node. ( NOT YET IMPLEMENTED )
+                //! \param scale: The scale factor for the terrain.  If you're using a heightmap of size 128x128 and would like
+                //! your terrain to be 12800x12800 in game units, then use a scale factor of ( core::vector ( 100.0f, 100.0f, 100.0f ).
+                //! If you use a Y scaling factor of 0.0f, then your terrain will be flat.
+                CTerrainSceneNode(ISceneNode* parent, ISceneManager* mgr, io::IFileSystem* fs, s32 id,
+                        s32 maxLOD = 4, E_TERRAIN_PATCH_SIZE patchSize = ETPS_17,
+                        const core::vector3df& position = core::vector3df(0.0f, 0.0f, 0.0f),
+                        const core::vector3df& rotation = core::vector3df(0.0f, 0.0f, 0.0f),
+                        const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f));
+                virtual ~CTerrainSceneNode();
+                //! Initializes the terrain data.  Loads the vertices from the heightMapFile.
+                virtual bool loadHeightMap(io::IReadFile* file,
+                        video::SColor vertexColor = video::SColor ( 255, 255, 255, 255 ), s32 smoothFactor = 0 );
+                //! Initializes the terrain data.  Loads the vertices from the heightMapFile.
+                virtual bool loadHeightMapRAW(io::IReadFile* file, s32 bitsPerPixel = 16,
+                        bool signedData=true, bool floatVals=false, s32 width=0, video::SColor vertexColor = video::SColor ( 255, 255, 255, 255 ), s32 smoothFactor = 0 );
+                //! Returns the material based on the zero based index i. This scene node only uses
+                //! 1 material.
+                //! \param i: Zero based index i. UNUSED, left in for virtual purposes.
+                //! \return Returns the single material this scene node uses.
+                virtual video::SMaterial& getMaterial(u32 i);
+                //! Returns amount of materials used by this scene node ( always 1 )
+                //! \return Returns current count of materials used by this scene node ( always 1 )
+                virtual u32 getMaterialCount() const;
+                //! Gets the last scaling factor applied to the scene node.  This value only represents the
+                //! last scaling factor presented to the node.  For instance, if you make create the node
+                //! with a scale factor of ( 1.0f, 1.0f, 1.0f ) then call setScale ( 50.0f, 5.0f, 50.0f ),
+                //! then make another call to setScale with the values ( 2.0f, 2.0f, 2.0f ), this will return
+                //! core::vector3df ( 2.0f, 2.0f, 2.0f ), although the total scaling of the scene node is
+                //! core::vector3df ( 100.0f, 10.0f, 100.0f ).
+                //! \return Returns the last scaling factor passed to the scene node.
+                virtual const core::vector3df& getScale() const
+                {
+                        return TerrainData.Scale;
+                }
+                //! Scales the scene nodes vertices by the vector specified.
+                //! \param scale: Scaling factor to apply to the node.
+                virtual void setScale(const core::vector3df& scale);
+                //! Gets the last rotation factor applied to the scene node.
+                //! \return Returns the last rotation factor applied to the scene node.
+                virtual const core::vector3df& getRotation() const
+                {
+                        return TerrainData.Rotation;
+                }
+                //! Rotates the node. This only modifies the relative rotation of the node.
+                //! \param rotation: New rotation of the node in degrees.
+                virtual void setRotation(const core::vector3df& rotation);
+                //! Sets the pivot point for rotation of this node.
+                //! NOTE: The default for the RotationPivot will be the center of the individual tile.
+                virtual void setRotationPivot( const core::vector3df& pivot );
+                //! Gets the last positioning vector applied to the scene node.
+                //! \return Returns the last position vector applied to the scene node.
+                virtual const core::vector3df& getPosition() const
+                {
+                        return TerrainData.Position;
+                }
+                //! Moves the scene nodes vertices by the vector specified.
+                //! \param newpos: Vector specifying how much to move each vertex of the scene node.
+                virtual void setPosition(const core::vector3df& newpos);
+                //! Updates the scene nodes indices if the camera has moved or rotated by a certain
+                //! threshold, which can be changed using the SetCameraMovementDeltaThreshold and
+                //! SetCameraRotationDeltaThreshold functions.  This also determines if a given patch
+                //! for the scene node is within the view frustum and if it's not the indices are not
+                //! generated for that patch.
+                virtual void OnRegisterSceneNode();
+                //! Render the scene node
+                virtual void render();
+                //! Return the bounding box of the entire terrain.
+                virtual const core::aabbox3d<f32>& getBoundingBox() const;
+                //! Return the bounding box of a patch
+                virtual const core::aabbox3d<f32>& getBoundingBox(s32 patchX, s32 patchZ) const;
+                //! Return the number of indices currently used to draw the scene node.
+                virtual u32 getIndexCount() const { return IndicesToRender; }
+                //! Returns the mesh
+                virtual IMesh* getMesh();
+                //! Returns a pointer to the buffer used by the terrain (most users will not need this)
+                virtual IMeshBuffer* getRenderBuffer() { return RenderBuffer; }
+                //! Gets the meshbuffer data based on a specified Level of Detail.
+                //! \param mb: A reference to an IDynamicMeshBuffer object
+                //! \param LOD: The Level Of Detail you want the indices from.
+                virtual void getMeshBufferForLOD(IDynamicMeshBuffer& mb, s32 LOD=0) const;
+                //! Gets the indices for a specified patch at a specified Level of Detail.
+                //! \param indices: A reference to an array of u32 indices.
+                //! \param patchX: Patch x coordinate.
+                //! \param patchZ: Patch z coordinate.
+                //! \param LOD: The level of detail to get for that patch.  If -1, then get
+                //! the CurrentLOD.  If the CurrentLOD is set to -1, meaning it's not shown,
+                //! then it will retrieve the triangles at the highest LOD (0).
+                //! \return: Number of indices put into the buffer.
+                virtual s32 getIndicesForPatch(core::array<u32>& indices,
+                        s32 patchX, s32 patchZ, s32 LOD=0);
+                //! Populates an array with the CurrentLOD of each patch.
+                //! \param LODs: A reference to a core::array<s32> to hold the values
+                //! \return Returns the number of elements in the array
+                virtual s32 getCurrentLODOfPatches(core::array<s32>& LODs) const;
+                //! Manually sets the LOD of a patch
+                //! \param patchX: Patch x coordinate.
+                //! \param patchZ: Patch z coordinate.
+                //! \param LOD: The level of detail to set the patch to.
+                virtual void setLODOfPatch(s32 patchX, s32 patchZ, s32 LOD=0);
+                //! Returns center of terrain.
+                virtual const core::vector3df& getTerrainCenter() const
+                {
+                        return TerrainData.Center;
+                }
+                //! Returns center of terrain.
+                virtual f32 getHeight( f32 x, f32 y ) const;
+                //! Sets the movement camera threshold which is used to determine when to recalculate
+                //! indices for the scene node.  The default value is 10.0f.
+                virtual void setCameraMovementDelta(f32 delta)
+                {
+                        CameraMovementDelta = delta;
+                }
+                //! Sets the rotation camera threshold which is used to determine when to recalculate
+                //! indices for the scene node.  The default value is 1.0f.
+                virtual void setCameraRotationDelta(f32 delta)
+                {
+                        CameraRotationDelta = delta;
+                }
+                //! Sets whether or not the node should dynamically update it its associated selector when
+                //! the geomipmap data changes.
+                //! param bVal: Boolean value representing whether or not to update selector dynamically.
+                //! NOTE: Temporarily disabled while working out issues with DynamicSelectorUpdate
+                virtual void setDynamicSelectorUpdate(bool bVal ) { DynamicSelectorUpdate = false; }
+                //! Override the default generation of distance thresholds for determining the LOD a patch
+                //! is rendered at. If any LOD is overridden, then the scene node will no longer apply
+                //! scaling factors to these values. If you override these distances and then apply
+                //! a scale to the scene node, it is your responsibility to update the new distances to
+                //! work best with your new terrain size.
+                virtual bool overrideLODDistance( s32 LOD, f64 newDistance );
+                //! Scales the two textures
+                virtual void scaleTexture(f32 scale = 1.0f, f32 scale2 = 0.0f);
+                //! Returns type of the scene node
+                virtual ESCENE_NODE_TYPE getType() const {return ESNT_TERRAIN;}
+                //! Writes attributes of the scene node.
+                virtual void serializeAttributes(io::IAttributes* out,
+                                io::SAttributeReadWriteOptions* options=0) const;
+                //! Reads attributes of the scene node.
+                virtual void deserializeAttributes(io::IAttributes* in,
+                                io::SAttributeReadWriteOptions* options=0);
+                //! Creates a clone of this scene node and its children.
+                virtual ISceneNode* clone(ISceneNode* newParent,
+                                ISceneManager* newManager);
+        private:
+                friend class CTerrainTriangleSelector;
+                struct SPatch
+                {
+                        SPatch()
+                        : Top(0), Bottom(0), Right(0), Left(0), CurrentLOD(-1)
+                        {
+                        }
+                        SPatch* Top;
+                        SPatch* Bottom;
+                        SPatch* Right;
+                        SPatch* Left;
+                        s32 CurrentLOD;
+                        core::aabbox3df BoundingBox;
+                        core::vector3df Center;
+                };
+                struct STerrainData
+                {
+                        STerrainData(s32 patchSize, s32 maxLOD, const core::vector3df& position, const core::vector3df& rotation, const core::vector3df& scale)
+                        : Patches(0), Size(0), Position(position), Rotation(rotation),
+                                Scale(scale), PatchSize(patchSize), CalcPatchSize(patchSize-1),
+                                PatchCount(0), MaxLOD(maxLOD)
+                        {
+                        }
+                        SPatch*         Patches;
+                        s32             Size;
+                        core::vector3df Position;
+                        core::vector3df Rotation;
+                        core::vector3df RotationPivot;
+                        core::vector3df Scale;
+                        core::vector3df Center;
+                        s32             PatchSize;
+                        s32             CalcPatchSize;
+                        s32             PatchCount;
+                        s32             MaxLOD;
+                        core::aabbox3df BoundingBox;
+                        core::array<f64> LODDistanceThreshold;
+                };
+    
+    
+    virtual void preRenderCalculationsIfNeeded();
+    
+                virtual void preRenderLODCalculations();
+                virtual void preRenderIndicesCalculations();
+                //! get indices when generating index data for patches at varying levels of detail.
+                u32 getIndex(const s32 PatchX, const s32 PatchZ, const s32 PatchIndex, u32 vX, u32 vZ) const;
+                //! smooth the terrain
+                void smoothTerrain(IDynamicMeshBuffer* mb, s32 smoothFactor);
+                //! calculate smooth normals
+                void calculateNormals(IDynamicMeshBuffer* mb);
+                //! create patches, stuff that needs to only be done once for patches goes here.
+                void createPatches();
+                //! calculate the internal STerrainData structure
+                void calculatePatchData();
+                //! calculate or recalculate the distance thresholds
+                void calculateDistanceThresholds(bool scalechanged = false);
+                //! sets the CurrentLOD of all patches to the specified LOD
+                void setCurrentLODOfPatches(s32 i);
+                //! sets the CurrentLOD of TerrainData patches to the LODs specified in the array
+                void setCurrentLODOfPatches(const core::array<s32>& lodarray);
+                //! Apply transformation changes( scale, position, rotation )
+                void applyTransformation();
+                STerrainData TerrainData;
+                SMesh* Mesh;
+                IDynamicMeshBuffer *RenderBuffer;
+                u32 VerticesToRender;
+                u32 IndicesToRender;
+                bool DynamicSelectorUpdate;
+                bool OverrideDistanceThreshold;
+                bool UseDefaultRotationPivot;
+                bool ForceRecalculation;
+                core::vector3df OldCameraPosition;
+                core::vector3df OldCameraRotation;
+                core::vector3df OldCameraUp;
+                f32             OldCameraFOV;
+                f32 CameraMovementDelta;
+                f32 CameraRotationDelta;
+                f32 CameraFOVDelta;
+                // needed for (de)serialization
+                f32 TCoordScale1;
+                f32 TCoordScale2;
+                s32 SmoothFactor;
+                io::path HeightmapFile;
+                io::IFileSystem* FileSystem;
+        };
+} // end namespace scene
+} // end namespace irr
+#endif // __C_TERRAIN_SCENE_NODE_H__

diff --git a/src/others/irrlicht-1.8.1/source/Irrlicht/CTerrainSceneNode.h b/src/others/irrlicht-1.8.1/source/Irrlicht/CTerrainSceneNode.h new file mode 100644 index 0000000..1d92f66 --- /dev/null +++ b/src/others/irrlicht-1.8.1/source/Irrlicht/CTerrainSceneNode.h
@@ -0,0 +1,330 @@
	1	// Copyright (C) 2002-2012 Nikolaus Gebhardt
	2	// This file is part of the "Irrlicht Engine".
	3	// For conditions of distribution and use, see copyright notice in irrlicht.h
	4
	5	// The code for the TerrainSceneNode is based on the GeoMipMapSceneNode
	6	// developed by Spintz. He made it available for Irrlicht and allowed it to be
	7	// distributed under this licence. I only modified some parts. A lot of thanks go to him.
	8
	9	#ifndef __C_TERRAIN_SCENE_NODE_H__
	10	#define __C_TERRAIN_SCENE_NODE_H__
	11
	12	#include "ITerrainSceneNode.h"
	13	#include "IDynamicMeshBuffer.h"
	14	#include "path.h"
	15
	16	namespace irr
	17	{
	18	namespace io
	19	{
	20	class IFileSystem;
	21	class IReadFile;
	22	}
	23	namespace scene
	24	{
	25	struct SMesh;
	26	class ITextSceneNode;
	27
	28	//! A scene node for displaying terrain using the geo mip map algorithm.
	29	class CTerrainSceneNode : public ITerrainSceneNode
	30	{
	31	public:
	32
	33	//! constructor
	34	//! \param parent: The node which this node is a child of. Making this node a child of another node, or
	35	//! making it a parent of another node is yet untested and most likely does not work properly.
	36	//! \param mgr: Pointer to the scene manager.
	37	//! \param id: The id of the node
	38	//! \param maxLOD: The maximum LOD ( Level of Detail ) for the node.
	39	//! \param patchSize: An E_GEOMIPMAP_PATCH_SIZE enumeration defining the size of each patch of the terrain.
	40	//! \param position: The absolute position of this node.
	41	//! \param rotation: The absolute rotation of this node. ( NOT YET IMPLEMENTED )
	42	//! \param scale: The scale factor for the terrain. If you're using a heightmap of size 128x128 and would like
	43	//! your terrain to be 12800x12800 in game units, then use a scale factor of ( core::vector ( 100.0f, 100.0f, 100.0f ).
	44	//! If you use a Y scaling factor of 0.0f, then your terrain will be flat.
	45	CTerrainSceneNode(ISceneNode* parent, ISceneManager* mgr, io::IFileSystem* fs, s32 id,
	46	s32 maxLOD = 4, E_TERRAIN_PATCH_SIZE patchSize = ETPS_17,
	47	const core::vector3df& position = core::vector3df(0.0f, 0.0f, 0.0f),
	48	const core::vector3df& rotation = core::vector3df(0.0f, 0.0f, 0.0f),
	49	const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f));
	50
	51	virtual ~CTerrainSceneNode();
	52
	53	//! Initializes the terrain data. Loads the vertices from the heightMapFile.
	54	virtual bool loadHeightMap(io::IReadFile* file,
	55	video::SColor vertexColor = video::SColor ( 255, 255, 255, 255 ), s32 smoothFactor = 0 );
	56
	57	//! Initializes the terrain data. Loads the vertices from the heightMapFile.
	58	virtual bool loadHeightMapRAW(io::IReadFile* file, s32 bitsPerPixel = 16,
	59	bool signedData=true, bool floatVals=false, s32 width=0, video::SColor vertexColor = video::SColor ( 255, 255, 255, 255 ), s32 smoothFactor = 0 );
	60
	61	//! Returns the material based on the zero based index i. This scene node only uses
	62	//! 1 material.
	63	//! \param i: Zero based index i. UNUSED, left in for virtual purposes.
	64	//! \return Returns the single material this scene node uses.
	65	virtual video::SMaterial& getMaterial(u32 i);
	66
	67	//! Returns amount of materials used by this scene node ( always 1 )
	68	//! \return Returns current count of materials used by this scene node ( always 1 )
	69	virtual u32 getMaterialCount() const;
	70
	71	//! Gets the last scaling factor applied to the scene node. This value only represents the
	72	//! last scaling factor presented to the node. For instance, if you make create the node
	73	//! with a scale factor of ( 1.0f, 1.0f, 1.0f ) then call setScale ( 50.0f, 5.0f, 50.0f ),
	74	//! then make another call to setScale with the values ( 2.0f, 2.0f, 2.0f ), this will return
	75	//! core::vector3df ( 2.0f, 2.0f, 2.0f ), although the total scaling of the scene node is
	76	//! core::vector3df ( 100.0f, 10.0f, 100.0f ).
	77	//! \return Returns the last scaling factor passed to the scene node.
	78	virtual const core::vector3df& getScale() const
	79	{
	80	return TerrainData.Scale;
	81	}
	82
	83	//! Scales the scene nodes vertices by the vector specified.
	84	//! \param scale: Scaling factor to apply to the node.
	85	virtual void setScale(const core::vector3df& scale);
	86
	87	//! Gets the last rotation factor applied to the scene node.
	88	//! \return Returns the last rotation factor applied to the scene node.
	89	virtual const core::vector3df& getRotation() const
	90	{
	91	return TerrainData.Rotation;
	92	}
	93
	94	//! Rotates the node. This only modifies the relative rotation of the node.
	95	//! \param rotation: New rotation of the node in degrees.
	96	virtual void setRotation(const core::vector3df& rotation);
	97
	98	//! Sets the pivot point for rotation of this node.
	99	//! NOTE: The default for the RotationPivot will be the center of the individual tile.
	100	virtual void setRotationPivot( const core::vector3df& pivot );
	101
	102	//! Gets the last positioning vector applied to the scene node.
	103	//! \return Returns the last position vector applied to the scene node.
	104	virtual const core::vector3df& getPosition() const
	105	{
	106	return TerrainData.Position;
	107	}
	108
	109	//! Moves the scene nodes vertices by the vector specified.
	110	//! \param newpos: Vector specifying how much to move each vertex of the scene node.
	111	virtual void setPosition(const core::vector3df& newpos);
	112
	113	//! Updates the scene nodes indices if the camera has moved or rotated by a certain
	114	//! threshold, which can be changed using the SetCameraMovementDeltaThreshold and
	115	//! SetCameraRotationDeltaThreshold functions. This also determines if a given patch
	116	//! for the scene node is within the view frustum and if it's not the indices are not
	117	//! generated for that patch.
	118	virtual void OnRegisterSceneNode();
	119
	120	//! Render the scene node
	121	virtual void render();
	122
	123	//! Return the bounding box of the entire terrain.
	124	virtual const core::aabbox3d<f32>& getBoundingBox() const;
	125
	126	//! Return the bounding box of a patch
	127	virtual const core::aabbox3d<f32>& getBoundingBox(s32 patchX, s32 patchZ) const;
	128
	129	//! Return the number of indices currently used to draw the scene node.
	130	virtual u32 getIndexCount() const { return IndicesToRender; }
	131
	132	//! Returns the mesh
	133	virtual IMesh* getMesh();
	134
	135	//! Returns a pointer to the buffer used by the terrain (most users will not need this)
	136	virtual IMeshBuffer* getRenderBuffer() { return RenderBuffer; }
	137
	138	//! Gets the meshbuffer data based on a specified Level of Detail.
	139	//! \param mb: A reference to an IDynamicMeshBuffer object
	140	//! \param LOD: The Level Of Detail you want the indices from.
	141	virtual void getMeshBufferForLOD(IDynamicMeshBuffer& mb, s32 LOD=0) const;
	142
	143	//! Gets the indices for a specified patch at a specified Level of Detail.
	144	//! \param indices: A reference to an array of u32 indices.
	145	//! \param patchX: Patch x coordinate.
	146	//! \param patchZ: Patch z coordinate.
	147	//! \param LOD: The level of detail to get for that patch. If -1, then get
	148	//! the CurrentLOD. If the CurrentLOD is set to -1, meaning it's not shown,
	149	//! then it will retrieve the triangles at the highest LOD (0).
	150	//! \return: Number of indices put into the buffer.
	151	virtual s32 getIndicesForPatch(core::array<u32>& indices,
	152	s32 patchX, s32 patchZ, s32 LOD=0);
	153
	154	//! Populates an array with the CurrentLOD of each patch.
	155	//! \param LODs: A reference to a core::array<s32> to hold the values
	156	//! \return Returns the number of elements in the array
	157	virtual s32 getCurrentLODOfPatches(core::array<s32>& LODs) const;
	158
	159	//! Manually sets the LOD of a patch
	160	//! \param patchX: Patch x coordinate.
	161	//! \param patchZ: Patch z coordinate.
	162	//! \param LOD: The level of detail to set the patch to.
	163	virtual void setLODOfPatch(s32 patchX, s32 patchZ, s32 LOD=0);
	164
	165	//! Returns center of terrain.
	166	virtual const core::vector3df& getTerrainCenter() const
	167	{
	168	return TerrainData.Center;
	169	}
	170
	171	//! Returns center of terrain.
	172	virtual f32 getHeight( f32 x, f32 y ) const;
	173
	174	//! Sets the movement camera threshold which is used to determine when to recalculate
	175	//! indices for the scene node. The default value is 10.0f.
	176	virtual void setCameraMovementDelta(f32 delta)
	177	{
	178	CameraMovementDelta = delta;
	179	}
	180
	181	//! Sets the rotation camera threshold which is used to determine when to recalculate
	182	//! indices for the scene node. The default value is 1.0f.
	183	virtual void setCameraRotationDelta(f32 delta)
	184	{
	185	CameraRotationDelta = delta;
	186	}
	187
	188	//! Sets whether or not the node should dynamically update it its associated selector when
	189	//! the geomipmap data changes.
	190	//! param bVal: Boolean value representing whether or not to update selector dynamically.
	191	//! NOTE: Temporarily disabled while working out issues with DynamicSelectorUpdate
	192	virtual void setDynamicSelectorUpdate(bool bVal ) { DynamicSelectorUpdate = false; }
	193
	194	//! Override the default generation of distance thresholds for determining the LOD a patch
	195	//! is rendered at. If any LOD is overridden, then the scene node will no longer apply
	196	//! scaling factors to these values. If you override these distances and then apply
	197	//! a scale to the scene node, it is your responsibility to update the new distances to
	198	//! work best with your new terrain size.
	199	virtual bool overrideLODDistance( s32 LOD, f64 newDistance );
	200
	201	//! Scales the two textures
	202	virtual void scaleTexture(f32 scale = 1.0f, f32 scale2 = 0.0f);
	203
	204	//! Returns type of the scene node
	205	virtual ESCENE_NODE_TYPE getType() const {return ESNT_TERRAIN;}
	206
	207	//! Writes attributes of the scene node.
	208	virtual void serializeAttributes(io::IAttributes* out,
	209	io::SAttributeReadWriteOptions* options=0) const;
	210
	211	//! Reads attributes of the scene node.
	212	virtual void deserializeAttributes(io::IAttributes* in,
	213	io::SAttributeReadWriteOptions* options=0);
	214
	215	//! Creates a clone of this scene node and its children.
	216	virtual ISceneNode* clone(ISceneNode* newParent,
	217	ISceneManager* newManager);
	218
	219	private:
	220	friend class CTerrainTriangleSelector;
	221
	222	struct SPatch
	223	{
	224	SPatch()
	225	: Top(0), Bottom(0), Right(0), Left(0), CurrentLOD(-1)
	226	{
	227	}
	228
	229	SPatch* Top;
	230	SPatch* Bottom;
	231	SPatch* Right;
	232	SPatch* Left;
	233	s32 CurrentLOD;
	234	core::aabbox3df BoundingBox;
	235	core::vector3df Center;
	236	};
	237
	238	struct STerrainData
	239	{
	240	STerrainData(s32 patchSize, s32 maxLOD, const core::vector3df& position, const core::vector3df& rotation, const core::vector3df& scale)
	241	: Patches(0), Size(0), Position(position), Rotation(rotation),
	242	Scale(scale), PatchSize(patchSize), CalcPatchSize(patchSize-1),
	243	PatchCount(0), MaxLOD(maxLOD)
	244	{
	245	}
	246
	247	SPatch* Patches;
	248	s32 Size;
	249	core::vector3df Position;
	250	core::vector3df Rotation;
	251	core::vector3df RotationPivot;
	252	core::vector3df Scale;
	253	core::vector3df Center;
	254	s32 PatchSize;
	255	s32 CalcPatchSize;
	256	s32 PatchCount;
	257	s32 MaxLOD;
	258	core::aabbox3df BoundingBox;
	259	core::array<f64> LODDistanceThreshold;
	260	};
	261
	262
	263	virtual void preRenderCalculationsIfNeeded();
	264
	265	virtual void preRenderLODCalculations();
	266	virtual void preRenderIndicesCalculations();
	267
	268	//! get indices when generating index data for patches at varying levels of detail.
	269	u32 getIndex(const s32 PatchX, const s32 PatchZ, const s32 PatchIndex, u32 vX, u32 vZ) const;
	270
	271	//! smooth the terrain
	272	void smoothTerrain(IDynamicMeshBuffer* mb, s32 smoothFactor);
	273
	274	//! calculate smooth normals
	275	void calculateNormals(IDynamicMeshBuffer* mb);
	276
	277	//! create patches, stuff that needs to only be done once for patches goes here.
	278	void createPatches();
	279
	280	//! calculate the internal STerrainData structure
	281	void calculatePatchData();
	282
	283	//! calculate or recalculate the distance thresholds
	284	void calculateDistanceThresholds(bool scalechanged = false);
	285
	286	//! sets the CurrentLOD of all patches to the specified LOD
	287	void setCurrentLODOfPatches(s32 i);
	288
	289	//! sets the CurrentLOD of TerrainData patches to the LODs specified in the array
	290	void setCurrentLODOfPatches(const core::array<s32>& lodarray);
	291
	292	//! Apply transformation changes( scale, position, rotation )
	293	void applyTransformation();
	294
	295	STerrainData TerrainData;
	296	SMesh* Mesh;
	297
	298	IDynamicMeshBuffer *RenderBuffer;
	299
	300	u32 VerticesToRender;
	301	u32 IndicesToRender;
	302
	303	bool DynamicSelectorUpdate;
	304	bool OverrideDistanceThreshold;
	305	bool UseDefaultRotationPivot;
	306	bool ForceRecalculation;
	307
	308	core::vector3df OldCameraPosition;
	309	core::vector3df OldCameraRotation;
	310	core::vector3df OldCameraUp;
	311	f32 OldCameraFOV;
	312	f32 CameraMovementDelta;
	313	f32 CameraRotationDelta;
	314	f32 CameraFOVDelta;
	315
	316	// needed for (de)serialization
	317	f32 TCoordScale1;
	318	f32 TCoordScale2;
	319	s32 SmoothFactor;
	320	io::path HeightmapFile;
	321	io::IFileSystem* FileSystem;
	322	};
	323
	324
	325	} // end namespace scene
	326	} // end namespace irr
	327
	328	#endif // __C_TERRAIN_SCENE_NODE_H__
	329
	330