#include "vector3d.h"\r
#include "dimension2d.h"\r
#include "SColor.h"\r
-#include "ETerrainElements.h"\r
#include "ESceneNodeTypes.h"\r
-#include "ESceneNodeAnimatorTypes.h"\r
#include "EMeshWriterEnums.h"\r
#include "SceneParameters.h"\r
-#include "IGeometryCreator.h"\r
#include "ISkinnedMesh.h"\r
-#include "IXMLWriter.h"\r
\r
namespace irr\r
{\r
class IAnimatedMesh;\r
class IAnimatedMeshSceneNode;\r
class IBillboardSceneNode;\r
- class IBillboardTextSceneNode;\r
class ICameraSceneNode;\r
class IDummyTransformationSceneNode;\r
- class ILightManager;\r
- class ILightSceneNode;\r
class IMesh;\r
class IMeshBuffer;\r
class IMeshCache;\r
+ class ISceneCollisionManager;\r
class IMeshLoader;\r
class IMeshManipulator;\r
class IMeshSceneNode;\r
class IMeshWriter;\r
- class IMetaTriangleSelector;\r
- class IOctreeSceneNode;\r
- class IParticleSystemSceneNode;\r
- class ISceneCollisionManager;\r
- class ISceneLoader;\r
class ISceneNode;\r
- class ISceneNodeAnimator;\r
- class ISceneNodeAnimatorCollisionResponse;\r
- class ISceneNodeAnimatorFactory;\r
class ISceneNodeFactory;\r
- class ISceneUserDataSerializer;\r
- class IShadowVolumeSceneNode;\r
- class ITerrainSceneNode;\r
- class ITextSceneNode;\r
- class ITriangleSelector;\r
- class IVolumeLightSceneNode;\r
-\r
- namespace quake3\r
- {\r
- struct IShader;\r
- } // end namespace quake3\r
\r
//! The Scene Manager manages scene nodes, mesh resources, cameras and all the other stuff.\r
- /** All Scene nodes can be created only here. There is a always growing\r
- list of scene nodes for lots of purposes: Indoor rendering scene nodes\r
- like the Octree (addOctreeSceneNode()) or the terrain renderer\r
- (addTerrainSceneNode()), different Camera scene nodes\r
- (addCameraSceneNode(), addCameraSceneNodeMaya()), scene nodes for Light\r
- (addLightSceneNode()), Billboards (addBillboardSceneNode()) and so on.\r
+ /** All Scene nodes can be created only here.\r
A scene node is a node in the hierarchical scene graph. Every scene node\r
may have children, which are other scene nodes. Children move relative\r
the their parents position. If the parent of a node is not visible, its\r
* directly in Irrlicht.\r
* </TR>\r
* <TR>\r
- * <TD>COLLADA (.dae, .xml)</TD>\r
- * <TD>COLLADA is an open Digital Asset Exchange Schema for\r
- * the interactive 3D industry. There are exporters and\r
- * importers for this format available for most of the\r
- * big 3d packagesat http://collada.org. Irrlicht can\r
- * import COLLADA files by using the\r
- * ISceneManager::getMesh() method. COLLADA files need\r
- * not contain only one single mesh but multiple meshes\r
- * and a whole scene setup with lights, cameras and mesh\r
- * instances, this loader can set up a scene as\r
- * described by the COLLADA file instead of loading and\r
- * returning one single mesh. By default, this loader\r
- * behaves like the other loaders and does not create\r
- * instances, but it can be switched into this mode by\r
- * using\r
- * SceneManager->getParameters()->setAttribute(COLLADA_CREATE_SCENE_INSTANCES, true);\r
- * Created scene nodes will be named as the names of the\r
- * nodes in the COLLADA file. The returned mesh is just\r
- * a dummy object in this mode. Meshes included in the\r
- * scene will be added into the scene manager with the\r
- * following naming scheme:\r
- * "path/to/file/file.dea#meshname". The loading of such\r
- * meshes is logged. Currently, this loader is able to\r
-\r
-\r
- * create meshes (made of only polygons), lights, and\r
- * cameras. Materials and animations are currently not\r
- * supported but this will change with future releases.\r
- * </TD>\r
- * </TR>\r
- * <TR>\r
* <TD>Delgine DeleD (.dmf)</TD>\r
* <TD>DeleD (delgine.com) is a 3D editor and level-editor\r
* combined into one and is specifically designed for 3D\r
* by Fabio Concas and adapted by Thomas Alten.</TD>\r
* </TR>\r
* <TR>\r
- * <TD>Irrlicht Mesh (.irrMesh)</TD>\r
- * <TD>This is a static mesh format written in XML, native\r
- * to Irrlicht and written by the irr mesh writer.\r
- * This format is exported by the CopperCube engine's\r
- * lightmapper.</TD>\r
- * </TR>\r
- * <TR>\r
* <TD>LightWave (.lwo)</TD>\r
* <TD>Native to NewTek's LightWave 3D, the LWO format is well\r
* known and supported by many exporters. This loader will\r
* \endcode\r
* If you would like to implement and add your own file format loader to Irrlicht,\r
* see addExternalMeshLoader().\r
- * \param filename: Filename of the mesh to load.\r
- * \param alternativeCacheName: In case you want to have the mesh under another name in the cache (to create real copies)\r
+ * \param file File handle of the mesh to load.\r
* \return Null if failed, otherwise pointer to the mesh.\r
* This pointer should not be dropped. See IReferenceCounted::drop() for more information.\r
**/\r
- virtual IAnimatedMesh* getMesh(const io::path& filename, const io::path& alternativeCacheName=io::path("")) = 0;\r
-\r
- //! Get pointer to an animateable mesh. Loads the file if not loaded already.\r
- /** Works just as getMesh(const char* filename). If you want to\r
- remove a loaded mesh from the cache again, use removeMesh().\r
- \param file File handle of the mesh to load.\r
- \return NULL if failed and pointer to the mesh if successful.\r
- This pointer should not be dropped. See\r
- IReferenceCounted::drop() for more information. */\r
virtual IAnimatedMesh* getMesh(io::IReadFile* file) = 0;\r
\r
//! Get interface to the mesh cache which is shared between all existing scene managers.\r
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
virtual video::IVideoDriver* getVideoDriver() = 0;\r
\r
- //! Get the active GUIEnvironment\r
- /** \return Pointer to the GUIEnvironment\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual gui::IGUIEnvironment* getGUIEnvironment() = 0;\r
-\r
- //! Get the active FileSystem\r
- /** \return Pointer to the FileSystem\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual io::IFileSystem* getFileSystem() = 0;\r
-\r
- //! adds Volume Lighting Scene Node.\r
- /** Example Usage:\r
- scene::IVolumeLightSceneNode * n = smgr->addVolumeLightSceneNode(0, -1,\r
- 32, 32, //Subdivide U/V\r
- video::SColor(0, 180, 180, 180), //foot color\r
- video::SColor(0, 0, 0, 0) //tail color\r
- );\r
- if (n)\r
- {\r
- n->setScale(core::vector3df(46.0f, 45.0f, 46.0f));\r
- n->getMaterial(0).setTexture(0, smgr->getVideoDriver()->getTexture("lightFalloff.png"));\r
- }\r
- \return Pointer to the volumeLight if successful, otherwise NULL.\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual IVolumeLightSceneNode* addVolumeLightSceneNode(ISceneNode* parent=0, s32 id=-1,\r
- const u32 subdivU = 32, const u32 subdivV = 32,\r
- const video::SColor foot = video::SColor(51, 0, 230, 180),\r
- const video::SColor tail = video::SColor(0, 0, 0, 0),\r
- const core::vector3df& position = core::vector3df(0,0,0),\r
- const core::vector3df& rotation = core::vector3df(0,0,0),\r
- const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f)) = 0;\r
-\r
- //! Adds a cube scene node\r
- /** \param size: Size of the cube, uniformly in each dimension.\r
- \param parent: Parent of the scene node. Can be 0 if no parent.\r
- \param id: Id of the node. This id can be used to identify the scene node.\r
- \param position: Position of the space relative to its parent\r
- where the scene node will be placed.\r
- \param rotation: Initial rotation of the scene node.\r
- \param scale: Initial scale of the scene node.\r
- \return Pointer to the created test scene node. This\r
- pointer should not be dropped. See IReferenceCounted::drop()\r
- for more information. */\r
- virtual IMeshSceneNode* addCubeSceneNode(f32 size=10.0f, ISceneNode* parent=0, s32 id=-1,\r
- const core::vector3df& position = core::vector3df(0,0,0),\r
- const core::vector3df& rotation = core::vector3df(0,0,0),\r
- const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f)) = 0;\r
-\r
- //! Adds a sphere scene node of the given radius and detail\r
- /** \param radius: Radius of the sphere.\r
- \param polyCount: The number of vertices in horizontal and\r
- vertical direction. The total polyCount of the sphere is\r
- polyCount*polyCount. This parameter must be less than 256 to\r
- stay within the 16-bit limit of the indices of a meshbuffer.\r
- \param parent: Parent of the scene node. Can be 0 if no parent.\r
- \param id: Id of the node. This id can be used to identify the scene node.\r
- \param position: Position of the space relative to its parent\r
- where the scene node will be placed.\r
- \param rotation: Initial rotation of the scene node.\r
- \param scale: Initial scale of the scene node.\r
- \return Pointer to the created test scene node. This\r
- pointer should not be dropped. See IReferenceCounted::drop()\r
- for more information. */\r
- virtual IMeshSceneNode* addSphereSceneNode(f32 radius=5.0f, s32 polyCount=16,\r
- ISceneNode* parent=0, s32 id=-1,\r
- const core::vector3df& position = core::vector3df(0,0,0),\r
- const core::vector3df& rotation = core::vector3df(0,0,0),\r
- const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f)) = 0;\r
-\r
//! Adds a scene node for rendering an animated mesh model.\r
/** \param mesh: Pointer to the loaded animated mesh to be displayed.\r
\param parent: Parent of the scene node. Can be NULL if no parent.\r
const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f),\r
bool alsoAddIfMeshPointerZero=false) = 0;\r
\r
- //! Adds a scene node for rendering a animated water surface mesh.\r
- /** Looks really good when the Material type EMT_TRANSPARENT_REFLECTION\r
- is used.\r
- \param waveHeight: Height of the water waves.\r
- \param waveSpeed: Speed of the water waves.\r
- \param waveLength: Length of a water wave.\r
- \param mesh: Pointer to the loaded static mesh to be displayed with water waves on it.\r
- \param parent: Parent of the scene node. Can be NULL if no parent.\r
- \param id: Id of the node. This id can be used to identify the scene node.\r
- \param position: Position of the space relative to its parent where the\r
- scene node will be placed.\r
- \param rotation: Initial rotation of the scene node.\r
- \param scale: Initial scale of the scene node.\r
- \return Pointer to the created scene node.\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual ISceneNode* addWaterSurfaceSceneNode(IMesh* mesh,\r
- f32 waveHeight=2.0f, f32 waveSpeed=300.0f, f32 waveLength=10.0f,\r
- ISceneNode* parent=0, s32 id=-1,\r
- const core::vector3df& position = core::vector3df(0,0,0),\r
- const core::vector3df& rotation = core::vector3df(0,0,0),\r
- const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f)) = 0;\r
-\r
-\r
- //! Adds a scene node for rendering using a octree to the scene graph.\r
- /** This a good method for rendering\r
- scenes with lots of geometry. The octree is built on the fly from the mesh.\r
- \param mesh: The mesh containing all geometry from which the octree will be build.\r
- If this animated mesh has more than one frames in it, the first frame is taken.\r
- \param parent: Parent node of the octree node.\r
- \param id: id of the node. This id can be used to identify the node.\r
- \param minimalPolysPerNode: Specifies the minimal polygons contained a octree node.\r
- If a node gets less polys than this value it will not be split into\r
- smaller nodes.\r
- \param alsoAddIfMeshPointerZero: Add the scene node even if a 0 pointer is passed.\r
- \return Pointer to the octree if successful, otherwise 0.\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual IOctreeSceneNode* addOctreeSceneNode(IAnimatedMesh* mesh, ISceneNode* parent=0,\r
- s32 id=-1, s32 minimalPolysPerNode=512, bool alsoAddIfMeshPointerZero=false) = 0;\r
-\r
- //! Adds a scene node for rendering using a octree to the scene graph.\r
- /** This a good method for rendering scenes with lots of\r
- geometry. The octree is built on the fly from the mesh, much\r
- faster then a bsp tree.\r
- \param mesh: The mesh containing all geometry from which the octree will be build.\r
- \param parent: Parent node of the octree node.\r
- \param id: id of the node. This id can be used to identify the node.\r
- \param minimalPolysPerNode: Specifies the minimal polygons contained a octree node.\r
- If a node gets less polys than this value it will not be split into\r
- smaller nodes.\r
- \param alsoAddIfMeshPointerZero: Add the scene node even if a 0 pointer is passed.\r
- \return Pointer to the octree if successful, otherwise 0.\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual IOctreeSceneNode* addOctreeSceneNode(IMesh* mesh, ISceneNode* parent=0,\r
- s32 id=-1, s32 minimalPolysPerNode=256, bool alsoAddIfMeshPointerZero=false) = 0;\r
-\r
//! Adds a camera scene node to the scene graph and sets it as active camera.\r
- /** This camera does not react on user input like for example the one created with\r
- addCameraSceneNodeFPS(). If you want to move or animate it, use animators or the\r
- ISceneNode::setPosition(), ICameraSceneNode::setTarget() etc methods.\r
+ /** This camera does not react on user input.\r
+ If you want to move or animate it, use ISceneNode::setPosition(),\r
+ ICameraSceneNode::setTarget() etc methods.\r
By default, a camera's look at position (set with setTarget()) and its scene node\r
rotation (set with setRotation()) are independent. If you want to be able to\r
control the direction that the camera looks by using setRotation() then call\r
const core::vector3df& lookat = core::vector3df(0,0,100),\r
s32 id=-1, bool makeActive=true) = 0;\r
\r
- //! Adds a maya style user controlled camera scene node to the scene graph.\r
- /** This is a standard camera with an animator that provides mouse control similar\r
- to camera in the 3D Software Maya by Alias Wavefront.\r
- The camera does not react on setPosition anymore after applying this animator. Instead\r
- use setTarget, to fix the target the camera the camera hovers around. And setDistance\r
- to set the current distance from that target, i.e. the radius of the orbit the camera\r
- hovers on.\r
- \param parent: Parent scene node of the camera. Can be null.\r
- \param rotateSpeed: Rotation speed of the camera.\r
- \param zoomSpeed: Zoom speed of the camera.\r
- \param translationSpeed: TranslationSpeed of the camera.\r
- \param id: id of the camera. This id can be used to identify the camera.\r
- \param distance Initial distance of the camera from the object\r
- \param makeActive Flag whether this camera should become the active one.\r
- Make sure you always have one active camera.\r
- \return Returns a pointer to the interface of the camera if successful, otherwise 0.\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual ICameraSceneNode* addCameraSceneNodeMaya(ISceneNode* parent=0,\r
- f32 rotateSpeed=-1500.f, f32 zoomSpeed=200.f,\r
- f32 translationSpeed=1500.f, s32 id=-1, f32 distance=70.f,\r
- bool makeActive=true) =0;\r
-\r
- //! Adds a camera scene node with an animator which provides mouse and keyboard control appropriate for first person shooters (FPS).\r
- /** This FPS camera is intended to provide a demonstration of a\r
- camera that behaves like a typical First Person Shooter. It is\r
- useful for simple demos and prototyping but is not intended to\r
- provide a full solution for a production quality game. It binds\r
- the camera scene node rotation to the look-at target; @see\r
- ICameraSceneNode::bindTargetAndRotation(). With this camera,\r
- you look with the mouse, and move with cursor keys. If you want\r
- to change the key layout, you can specify your own keymap. For\r
- example to make the camera be controlled by the cursor keys AND\r
- the keys W,A,S, and D, do something like this:\r
- \code\r
- SKeyMap keyMap[8];\r
- keyMap[0].Action = EKA_MOVE_FORWARD;\r
- keyMap[0].KeyCode = KEY_UP;\r
- keyMap[1].Action = EKA_MOVE_FORWARD;\r
- keyMap[1].KeyCode = KEY_KEY_W;\r
-\r
- keyMap[2].Action = EKA_MOVE_BACKWARD;\r
- keyMap[2].KeyCode = KEY_DOWN;\r
- keyMap[3].Action = EKA_MOVE_BACKWARD;\r
- keyMap[3].KeyCode = KEY_KEY_S;\r
-\r
- keyMap[4].Action = EKA_STRAFE_LEFT;\r
- keyMap[4].KeyCode = KEY_LEFT;\r
- keyMap[5].Action = EKA_STRAFE_LEFT;\r
- keyMap[5].KeyCode = KEY_KEY_A;\r
-\r
- keyMap[6].Action = EKA_STRAFE_RIGHT;\r
- keyMap[6].KeyCode = KEY_RIGHT;\r
- keyMap[7].Action = EKA_STRAFE_RIGHT;\r
- keyMap[7].KeyCode = KEY_KEY_D;\r
-\r
- camera = sceneManager->addCameraSceneNodeFPS(0, 100, 500, -1, keyMap, 8);\r
- \endcode\r
- \param parent: Parent scene node of the camera. Can be null.\r
- \param rotateSpeed: Speed in degrees with which the camera is\r
- rotated. This can be done only with the mouse.\r
- \param moveSpeed: Speed in units per millisecond with which\r
- the camera is moved. Movement is done with the cursor keys.\r
- \param id: id of the camera. This id can be used to identify\r
- the camera.\r
- \param keyMapArray: Optional pointer to an array of a keymap,\r
- specifying what keys should be used to move the camera. If this\r
- is null, the default keymap is used. You can define actions\r
- more then one time in the array, to bind multiple keys to the\r
- same action.\r
- \param keyMapSize: Amount of items in the keymap array.\r
- \param noVerticalMovement: Setting this to true makes the\r
- camera only move within a horizontal plane, and disables\r
- vertical movement as known from most ego shooters. Default is\r
- 'false', with which it is possible to fly around in space, if\r
- no gravity is there.\r
- \param jumpSpeed: Speed with which the camera is moved when\r
- jumping.\r
- \param invertMouse: Setting this to true makes the camera look\r
- up when the mouse is moved down and down when the mouse is\r
- moved up, the default is 'false' which means it will follow the\r
- movement of the mouse cursor.\r
- \param makeActive Flag whether this camera should become the active one.\r
- Make sure you always have one active camera.\r
- \return Pointer to the interface of the camera if successful,\r
- otherwise 0. This pointer should not be dropped. See\r
- IReferenceCounted::drop() for more information. */\r
- virtual ICameraSceneNode* addCameraSceneNodeFPS(ISceneNode* parent = 0,\r
- f32 rotateSpeed = 100.0f, f32 moveSpeed = 0.5f, s32 id=-1,\r
- SKeyMap* keyMapArray=0, s32 keyMapSize=0, bool noVerticalMovement=false,\r
- f32 jumpSpeed = 0.f, bool invertMouse=false,\r
- bool makeActive=true) = 0;\r
-\r
- //! Adds a dynamic light scene node to the scene graph.\r
- /** The light will cast dynamic light on all\r
- other scene nodes in the scene, which have the material flag video::MTF_LIGHTING\r
- turned on. (This is the default setting in most scene nodes).\r
- \param parent: Parent scene node of the light. Can be null. If the parent moves,\r
- the light will move too.\r
- \param position: Position of the space relative to its parent where the light will be placed.\r
- \param color: Diffuse color of the light. Ambient or Specular colors can be set manually with\r
- the ILightSceneNode::getLightData() method.\r
- \param radius: Radius of the light.\r
- \param id: id of the node. This id can be used to identify the node.\r
- \return Pointer to the interface of the light if successful, otherwise NULL.\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual ILightSceneNode* addLightSceneNode(ISceneNode* parent = 0,\r
- const core::vector3df& position = core::vector3df(0,0,0),\r
- video::SColorf color = video::SColorf(1.0f, 1.0f, 1.0f),\r
- f32 radius=100.0f, s32 id=-1) = 0;\r
-\r
//! Adds a billboard scene node to the scene graph.\r
/** A billboard is like a 3d sprite: A 2d element,\r
which always looks to the camera. It is usually used for things\r
const core::vector3df& position = core::vector3df(0,0,0), s32 id=-1,\r
video::SColor colorTop = 0xFFFFFFFF, video::SColor colorBottom = 0xFFFFFFFF) = 0;\r
\r
- //! Adds a skybox scene node to the scene graph.\r
- /** A skybox is a big cube with 6 textures on it and\r
- is drawn around the camera position.\r
- \param top: Texture for the top plane of the box.\r
- \param bottom: Texture for the bottom plane of the box.\r
- \param left: Texture for the left plane of the box.\r
- \param right: Texture for the right plane of the box.\r
- \param front: Texture for the front plane of the box.\r
- \param back: Texture for the back plane of the box.\r
- \param parent: Parent scene node of the skybox. A skybox usually has no parent,\r
- so this should be null. Note: If a parent is set to the skybox, the box will not\r
- change how it is drawn.\r
- \param id: An id of the node. This id can be used to identify the node.\r
- \return Pointer to the sky box if successful, otherwise NULL.\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual ISceneNode* addSkyBoxSceneNode(video::ITexture* top, video::ITexture* bottom,\r
- video::ITexture* left, video::ITexture* right, video::ITexture* front,\r
- video::ITexture* back, ISceneNode* parent = 0, s32 id=-1) = 0;\r
-\r
- //! Adds a skydome scene node to the scene graph.\r
- /** A skydome is a large (half-) sphere with a panoramic texture\r
- on the inside and is drawn around the camera position.\r
- \param texture: Texture for the dome.\r
- \param horiRes: Number of vertices of a horizontal layer of the sphere.\r
- \param vertRes: Number of vertices of a vertical layer of the sphere.\r
- \param texturePercentage: How much of the height of the\r
- texture is used. Should be between 0 and 1.\r
- \param spherePercentage: How much of the sphere is drawn.\r
- Value should be between 0 and 2, where 1 is an exact\r
- half-sphere and 2 is a full sphere.\r
- \param radius The Radius of the sphere\r
- \param parent: Parent scene node of the dome. A dome usually has no parent,\r
- so this should be null. Note: If a parent is set, the dome will not\r
- change how it is drawn.\r
- \param id: An id of the node. This id can be used to identify the node.\r
- \return Pointer to the sky dome if successful, otherwise NULL.\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual ISceneNode* addSkyDomeSceneNode(video::ITexture* texture,\r
- u32 horiRes=16, u32 vertRes=8,\r
- f32 texturePercentage=0.9, f32 spherePercentage=2.0,f32 radius = 1000.f,\r
- ISceneNode* parent=0, s32 id=-1) = 0;\r
-\r
- //! Adds a particle system scene node to the scene graph.\r
- /** \param withDefaultEmitter: Creates a default working point emitter\r
- which emits some particles. Set this to true to see a particle system\r
- in action. If set to false, you'll have to set the emitter you want by\r
- calling IParticleSystemSceneNode::setEmitter().\r
- \param parent: Parent of the scene node. Can be NULL if no parent.\r
- \param id: Id of the node. This id can be used to identify the scene node.\r
- \param position: Position of the space relative to its parent where the\r
- scene node will be placed.\r
- \param rotation: Initial rotation of the scene node.\r
- \param scale: Initial scale of the scene node.\r
- \return Pointer to the created scene node.\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual IParticleSystemSceneNode* addParticleSystemSceneNode(\r
- bool withDefaultEmitter=true, ISceneNode* parent=0, s32 id=-1,\r
- const core::vector3df& position = core::vector3df(0,0,0),\r
- const core::vector3df& rotation = core::vector3df(0,0,0),\r
- const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f)) = 0;\r
-\r
- //! Adds a terrain scene node to the scene graph.\r
- /** This node implements is a simple terrain renderer which uses\r
- a technique known as geo mip mapping\r
- for reducing the detail of triangle blocks which are far away.\r
- The code for the TerrainSceneNode is based on the terrain\r
- renderer by Soconne and the GeoMipMapSceneNode developed by\r
- Spintz. They made their code available for Irrlicht and allowed\r
- it to be distributed under this licence. I only modified some\r
- parts. A lot of thanks go to them.\r
-\r
- This scene node is capable of loading terrains and updating\r
- the indices at runtime to enable viewing very large terrains\r
- very quickly. It uses a CLOD (Continuous Level of Detail)\r
- algorithm which updates the indices for each patch based on\r
- a LOD (Level of Detail) which is determined based on a patch's\r
- distance from the camera.\r
-\r
- The patch size of the terrain must always be a size of 2^N+1,\r
- i.e. 8+1(9), 16+1(17), etc.\r
- The MaxLOD available is directly dependent on the patch size\r
- of the terrain. LOD 0 contains all of the indices to draw all\r
- the triangles at the max detail for a patch. As each LOD goes\r
- up by 1 the step taken, in generating indices increases by\r
- -2^LOD, so for LOD 1, the step taken is 2, for LOD 2, the step\r
- taken is 4, LOD 3 - 8, etc. The step can be no larger than\r
- the size of the patch, so having a LOD of 8, with a patch size\r
- of 17, is asking the algorithm to generate indices every 2^8 (\r
- 256 ) vertices, which is not possible with a patch size of 17.\r
- The maximum LOD for a patch size of 17 is 2^4 ( 16 ). So,\r
- with a MaxLOD of 5, you'll have LOD 0 ( full detail ), LOD 1 (\r
- every 2 vertices ), LOD 2 ( every 4 vertices ), LOD 3 ( every\r
- 8 vertices ) and LOD 4 ( every 16 vertices ).\r
- \param heightMapFileName: The name of the file on disk, to read vertex data from. This should\r
- be a gray scale bitmap.\r
- \param parent: Parent of the scene node. Can be 0 if no parent.\r
- \param id: Id of the node. This id can be used to identify the scene node.\r
- \param position: The absolute position of this node.\r
- \param rotation: The absolute rotation of this node. ( NOT YET IMPLEMENTED )\r
- \param scale: The scale factor for the terrain. If you're\r
- using a heightmap of size 129x129 and would like your terrain\r
- to be 12900x12900 in game units, then use a scale factor of (\r
- core::vector ( 100.0f, 100.0f, 100.0f ). If you use a Y\r
- scaling factor of 0.0f, then your terrain will be flat.\r
- \param vertexColor: The default color of all the vertices. If no texture is associated\r
- with the scene node, then all vertices will be this color. Defaults to white.\r
- \param maxLOD: The maximum LOD (level of detail) for the node. Only change if you\r
- know what you are doing, this might lead to strange behavior.\r
- \param patchSize: patch size of the terrain. Only change if you\r
- know what you are doing, this might lead to strange behavior.\r
- \param smoothFactor: The number of times the vertices are smoothed.\r
- \param addAlsoIfHeightmapEmpty: Add terrain node even with empty heightmap.\r
- \return Pointer to the created scene node. Can be null\r
- if the terrain could not be created, for example because the\r
- heightmap could not be loaded. The returned pointer should\r
- not be dropped. See IReferenceCounted::drop() for more\r
- information. */\r
- virtual ITerrainSceneNode* addTerrainSceneNode(\r
- const io::path& heightMapFileName,\r
- ISceneNode* parent=0, s32 id=-1,\r
- const core::vector3df& position = core::vector3df(0.0f,0.0f,0.0f),\r
- const core::vector3df& rotation = core::vector3df(0.0f,0.0f,0.0f),\r
- const core::vector3df& scale = core::vector3df(1.0f,1.0f,1.0f),\r
- video::SColor vertexColor = video::SColor(255,255,255,255),\r
- s32 maxLOD=5, E_TERRAIN_PATCH_SIZE patchSize=ETPS_17, s32 smoothFactor=0,\r
- bool addAlsoIfHeightmapEmpty = false) = 0;\r
-\r
- //! Adds a terrain scene node to the scene graph.\r
- /** Just like the other addTerrainSceneNode() method, but takes an IReadFile\r
- pointer as parameter for the heightmap. For more information take a look\r
- at the other function.\r
- \param heightMapFile: The file handle to read vertex data from. This should\r
- be a gray scale bitmap.\r
- \param parent: Parent of the scene node. Can be 0 if no parent.\r
- \param id: Id of the node. This id can be used to identify the scene node.\r
- \param position: The absolute position of this node.\r
- \param rotation: The absolute rotation of this node. ( NOT YET IMPLEMENTED )\r
- \param scale: The scale factor for the terrain. If you're\r
- using a heightmap of size 129x129 and would like your terrain\r
- to be 12900x12900 in game units, then use a scale factor of (\r
- core::vector ( 100.0f, 100.0f, 100.0f ). If you use a Y\r
- scaling factor of 0.0f, then your terrain will be flat.\r
- \param vertexColor: The default color of all the vertices. If no texture is associated\r
- with the scene node, then all vertices will be this color. Defaults to white.\r
- \param maxLOD: The maximum LOD (level of detail) for the node. Only change if you\r
- know what you are doing, this might lead to strange behavior.\r
- \param patchSize: patch size of the terrain. Only change if you\r
- know what you are doing, this might lead to strange behavior.\r
- \param smoothFactor: The number of times the vertices are smoothed.\r
- \param addAlsoIfHeightmapEmpty: Add terrain node even with empty heightmap.\r
- \return Pointer to the created scene node. Can be null\r
- if the terrain could not be created, for example because the\r
- heightmap could not be loaded. The returned pointer should\r
- not be dropped. See IReferenceCounted::drop() for more\r
- information. */\r
- virtual ITerrainSceneNode* addTerrainSceneNode(\r
- io::IReadFile* heightMapFile,\r
- ISceneNode* parent=0, s32 id=-1,\r
- const core::vector3df& position = core::vector3df(0.0f,0.0f,0.0f),\r
- const core::vector3df& rotation = core::vector3df(0.0f,0.0f,0.0f),\r
- const core::vector3df& scale = core::vector3df(1.0f,1.0f,1.0f),\r
- video::SColor vertexColor = video::SColor(255,255,255,255),\r
- s32 maxLOD=5, E_TERRAIN_PATCH_SIZE patchSize=ETPS_17, s32 smoothFactor=0,\r
- bool addAlsoIfHeightmapEmpty = false) = 0;\r
-\r
- //! Adds a quake3 scene node to the scene graph.\r
- /** A Quake3 Scene renders multiple meshes for a specific HighLanguage Shader (Quake3 Style )\r
- \return Pointer to the quake3 scene node if successful, otherwise NULL.\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual IMeshSceneNode* addQuake3SceneNode(const IMeshBuffer* meshBuffer, const quake3::IShader * shader,\r
- ISceneNode* parent=0, s32 id=-1\r
- ) = 0;\r
-\r
-\r
//! Adds an empty scene node to the scene graph.\r
/** Can be used for doing advanced transformations\r
or structuring the scene graph.\r
virtual IDummyTransformationSceneNode* addDummyTransformationSceneNode(\r
ISceneNode* parent=0, s32 id=-1) = 0;\r
\r
- //! Adds a text scene node, which is able to display 2d text at a position in three dimensional space\r
- virtual ITextSceneNode* addTextSceneNode(gui::IGUIFont* font, const wchar_t* text,\r
- video::SColor color=video::SColor(100,255,255,255),\r
- ISceneNode* parent = 0, const core::vector3df& position = core::vector3df(0,0,0),\r
- s32 id=-1) = 0;\r
-\r
- //! Adds a text scene node, which uses billboards. The node, and the text on it, will scale with distance.\r
- /**\r
- \param font The font to use on the billboard. Pass 0 to use the GUI environment's default font.\r
- \param text The text to display on the billboard.\r
- \param parent The billboard's parent. Pass 0 to use the root scene node.\r
- \param size The billboard's width and height.\r
- \param position The billboards position relative to its parent.\r
- \param id: An id of the node. This id can be used to identify the node.\r
- \param colorTop: The color of the vertices at the top of the billboard (default: white).\r
- \param colorBottom: The color of the vertices at the bottom of the billboard (default: white).\r
- \return Pointer to the billboard if successful, otherwise NULL.\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual IBillboardTextSceneNode* addBillboardTextSceneNode( gui::IGUIFont* font, const wchar_t* text,\r
- ISceneNode* parent = 0,\r
- const core::dimension2d<f32>& size = core::dimension2d<f32>(10.0f, 10.0f),\r
- const core::vector3df& position = core::vector3df(0,0,0), s32 id=-1,\r
- video::SColor colorTop = 0xFFFFFFFF, video::SColor colorBottom = 0xFFFFFFFF) = 0;\r
-\r
- //! Adds a Hill Plane mesh to the mesh pool.\r
- /** The mesh is generated on the fly\r
- and looks like a plane with some hills on it. It is uses mostly for quick\r
- tests of the engine only. You can specify how many hills there should be\r
- on the plane and how high they should be. Also you must specify a name for\r
- the mesh, because the mesh is added to the mesh pool, and can be retrieved\r
- again using ISceneManager::getMesh() with the name as parameter.\r
- \param name: The name of this mesh which must be specified in order\r
- to be able to retrieve the mesh later with ISceneManager::getMesh().\r
- \param tileSize: Size of a tile of the mesh. (10.0f, 10.0f) would be a\r
- good value to start, for example.\r
- \param tileCount: Specifies how much tiles there will be. If you specify\r
- for example that a tile has the size (10.0f, 10.0f) and the tileCount is\r
- (10,10), than you get a field of 100 tiles which has the dimension 100.0f x 100.0f.\r
- \param material: Material of the hill mesh.\r
- \param hillHeight: Height of the hills. If you specify a negative value\r
- you will get holes instead of hills. If the height is 0, no hills will be\r
- created.\r
- \param countHills: Amount of hills on the plane. There will be countHills.X\r
- hills along the X axis and countHills.Y along the Y axis. So in total there\r
- will be countHills.X * countHills.Y hills.\r
- \param textureRepeatCount: Defines how often the texture will be repeated in\r
- x and y direction.\r
- return Null if the creation failed. The reason could be that you\r
- specified some invalid parameters or that a mesh with that name already\r
- exists. If successful, a pointer to the mesh is returned.\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual IAnimatedMesh* addHillPlaneMesh(const io::path& name,\r
- const core::dimension2d<f32>& tileSize, const core::dimension2d<u32>& tileCount,\r
- video::SMaterial* material = 0, f32 hillHeight = 0.0f,\r
- const core::dimension2d<f32>& countHills = core::dimension2d<f32>(0.0f, 0.0f),\r
- const core::dimension2d<f32>& textureRepeatCount = core::dimension2d<f32>(1.0f, 1.0f)) = 0;\r
-\r
- //! Adds a static terrain mesh to the mesh pool.\r
- /** The mesh is generated on the fly\r
- from a texture file and a height map file. Both files may be huge\r
- (8000x8000 pixels would be no problem) because the generator splits the\r
- files into smaller textures if necessary.\r
- You must specify a name for the mesh, because the mesh is added to the mesh pool,\r
- and can be retrieved again using ISceneManager::getMesh() with the name as parameter.\r
- \param meshname: The name of this mesh which must be specified in order\r
- to be able to retrieve the mesh later with ISceneManager::getMesh().\r
- \param texture: Texture for the terrain. Please note that this is not a\r
- hardware texture as usual (ITexture), but an IImage software texture.\r
- You can load this texture with IVideoDriver::createImageFromFile().\r
- \param heightmap: A grayscaled heightmap image. Like the texture,\r
- it can be created with IVideoDriver::createImageFromFile(). The amount\r
- of triangles created depends on the size of this texture, so use a small\r
- heightmap to increase rendering speed.\r
- \param stretchSize: Parameter defining how big a is pixel on the heightmap.\r
- \param maxHeight: Defines how high a white pixel on the heightmap is.\r
- \param defaultVertexBlockSize: Defines the initial dimension between vertices.\r
- \return Null if the creation failed. The reason could be that you\r
- specified some invalid parameters, that a mesh with that name already\r
- exists, or that a texture could not be found. If successful, a pointer to the mesh is returned.\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual IAnimatedMesh* addTerrainMesh(const io::path& meshname,\r
- video::IImage* texture, video::IImage* heightmap,\r
- const core::dimension2d<f32>& stretchSize = core::dimension2d<f32>(10.0f,10.0f),\r
- f32 maxHeight=200.0f,\r
- const core::dimension2d<u32>& defaultVertexBlockSize = core::dimension2d<u32>(64,64)) = 0;\r
-\r
- //! add a static arrow mesh to the meshpool\r
- /** \param name Name of the mesh\r
- \param vtxColorCylinder color of the cylinder\r
- \param vtxColorCone color of the cone\r
- \param tesselationCylinder Number of quads the cylinder side consists of\r
- \param tesselationCone Number of triangles the cone's roof consists of\r
- \param height Total height of the arrow\r
- \param cylinderHeight Total height of the cylinder, should be lesser than total height\r
- \param widthCylinder Diameter of the cylinder\r
- \param widthCone Diameter of the cone's base, should be not smaller than the cylinder's diameter\r
- \return Pointer to the arrow mesh if successful, otherwise 0.\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual IAnimatedMesh* addArrowMesh(const io::path& name,\r
- video::SColor vtxColorCylinder=0xFFFFFFFF,\r
- video::SColor vtxColorCone=0xFFFFFFFF,\r
- u32 tesselationCylinder=4, u32 tesselationCone=8,\r
- f32 height=1.f, f32 cylinderHeight=0.6f,\r
- f32 widthCylinder=0.05f, f32 widthCone=0.3f) = 0;\r
-\r
- //! add a static sphere mesh to the meshpool\r
- /** \param name Name of the mesh\r
- \param radius Radius of the sphere\r
- \param polyCountX Number of quads used for the horizontal tiling\r
- \param polyCountY Number of quads used for the vertical tiling\r
- \return Pointer to the sphere mesh if successful, otherwise 0.\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual IAnimatedMesh* addSphereMesh(const io::path& name,\r
- f32 radius=5.f, u32 polyCountX = 16,\r
- u32 polyCountY = 16) = 0;\r
-\r
- //! Add a volume light mesh to the meshpool\r
- /** \param name Name of the mesh\r
- \param SubdivideU Horizontal subdivision count\r
- \param SubdivideV Vertical subdivision count\r
- \param FootColor Color of the bottom of the light\r
- \param TailColor Color of the top of the light\r
- \return Pointer to the volume light mesh if successful, otherwise 0.\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information.\r
- */\r
- virtual IAnimatedMesh* addVolumeLightMesh(const io::path& name,\r
- const u32 SubdivideU = 32, const u32 SubdivideV = 32,\r
- const video::SColor FootColor = video::SColor(51, 0, 230, 180),\r
- const video::SColor TailColor = video::SColor(0, 0, 0, 0)) = 0;\r
-\r
//! Gets the root scene node.\r
/** This is the scene node which is parent\r
of all scene nodes. The root scene node is a special scene node which\r
\param camera: The new camera which should be active. */\r
virtual void setActiveCamera(ICameraSceneNode* camera) = 0;\r
\r
- //! Sets the color of stencil buffers shadows drawn by the scene manager.\r
- virtual void setShadowColor(video::SColor color = video::SColor(150,0,0,0)) = 0;\r
-\r
- //! Get the current color of shadows.\r
- virtual video::SColor getShadowColor() const = 0;\r
-\r
- //! Create a shadow volume scene node to be used with custom nodes\r
- /** Use this if you implement your own SceneNodes and need shadow volumes in them.\r
- Otherwise you should generally use addShadowVolumeSceneNode functions from IMeshSceneNode or IAnimatedMeshSceneNode.*/\r
- virtual IShadowVolumeSceneNode* createShadowVolumeSceneNode(const IMesh* shadowMesh, ISceneNode* parent, s32 id, bool zfailmethod, f32 infinity) = 0;\r
-\r
//! Registers a node for rendering it at a specific time.\r
/** This method should only be used by SceneNodes when they get a\r
ISceneNode::OnRegisterSceneNode() call.\r
by existing scene node animators, culling of scene nodes is done, etc. */\r
virtual void drawAll() = 0;\r
\r
- //! Creates a rotation animator, which rotates the attached scene node around itself.\r
- /** \param rotationSpeed Specifies the speed of the animation in degree per 10 milliseconds.\r
- \return The animator. Attach it to a scene node with ISceneNode::addAnimator()\r
- and the animator will animate it.\r
- If you no longer need the animator, you should call ISceneNodeAnimator::drop().\r
- See IReferenceCounted::drop() for more information. */\r
- virtual ISceneNodeAnimator* createRotationAnimator(const core::vector3df& rotationSpeed) = 0;\r
-\r
- //! Creates a fly circle animator, which lets the attached scene node fly around a center.\r
- /** \param center: Center of the circle.\r
- \param radius: Radius of the circle.\r
- \param speed: The orbital speed, in radians per millisecond.\r
- \param direction: Specifies the upvector used for alignment of the mesh.\r
- \param startPosition: The position on the circle where the animator will\r
- begin. Value is in multiples of a circle, i.e. 0.5 is half way around. (phase)\r
- \param radiusEllipsoid: if radiusEllipsoid != 0 then radius2 from a ellipsoid\r
- begin. Value is in multiples of a circle, i.e. 0.5 is half way around. (phase)\r
- \return The animator. Attach it to a scene node with ISceneNode::addAnimator()\r
- and the animator will animate it.\r
- If you no longer need the animator, you should call ISceneNodeAnimator::drop().\r
- See IReferenceCounted::drop() for more information. */\r
- virtual ISceneNodeAnimator* createFlyCircleAnimator(\r
- const core::vector3df& center=core::vector3df(0.f,0.f,0.f),\r
- f32 radius=100.f, f32 speed=0.001f,\r
- const core::vector3df& direction=core::vector3df(0.f, 1.f, 0.f),\r
- f32 startPosition = 0.f,\r
- f32 radiusEllipsoid = 0.f) = 0;\r
-\r
- //! Creates a fly straight animator, which lets the attached scene node fly or move along a line between two points.\r
- /** \param startPoint: Start point of the line.\r
- \param endPoint: End point of the line.\r
- \param timeForWay: Time in milliseconds how long the node should need to\r
- move from the start point to the end point.\r
- \param loop: If set to false, the node stops when the end point is reached.\r
- If loop is true, the node begins again at the start.\r
- \param pingpong Flag to set whether the animator should fly\r
- back from end to start again.\r
- \return The animator. Attach it to a scene node with ISceneNode::addAnimator()\r
- and the animator will animate it.\r
- If you no longer need the animator, you should call ISceneNodeAnimator::drop().\r
- See IReferenceCounted::drop() for more information. */\r
- virtual ISceneNodeAnimator* createFlyStraightAnimator(const core::vector3df& startPoint,\r
- const core::vector3df& endPoint, u32 timeForWay, bool loop=false, bool pingpong = false) = 0;\r
-\r
- //! Creates a texture animator, which switches the textures of the target scene node based on a list of textures.\r
- /** \param textures: List of textures to use.\r
- \param timePerFrame: Time in milliseconds, how long any texture in the list\r
- should be visible.\r
- \param loop: If set to to false, the last texture remains set, and the animation\r
- stops. If set to true, the animation restarts with the first texture.\r
- \return The animator. Attach it to a scene node with ISceneNode::addAnimator()\r
- and the animator will animate it.\r
- If you no longer need the animator, you should call ISceneNodeAnimator::drop().\r
- See IReferenceCounted::drop() for more information. */\r
- virtual ISceneNodeAnimator* createTextureAnimator(const core::array<video::ITexture*>& textures,\r
- s32 timePerFrame, bool loop=true) = 0;\r
-\r
- //! Creates a scene node animator, which deletes the scene node after some time automatically.\r
- /** \param timeMs: Time in milliseconds, after when the node will be deleted.\r
- \return The animator. Attach it to a scene node with ISceneNode::addAnimator()\r
- and the animator will animate it.\r
- If you no longer need the animator, you should call ISceneNodeAnimator::drop().\r
- See IReferenceCounted::drop() for more information. */\r
- virtual ISceneNodeAnimator* createDeleteAnimator(u32 timeMs) = 0;\r
-\r
- //! Creates a special scene node animator for doing automatic collision detection and response.\r
- /** See ISceneNodeAnimatorCollisionResponse for details.\r
- \param world: Triangle selector holding all triangles of the world with which\r
- the scene node may collide. You can create a triangle selector with\r
- ISceneManager::createTriangleSelector();\r
- \param sceneNode: SceneNode which should be manipulated. After you added this animator\r
- to the scene node, the scene node will not be able to move through walls and is\r
- affected by gravity. If you need to teleport the scene node to a new position without\r
- it being effected by the collision geometry, then call sceneNode->setPosition(); then\r
- animator->setTargetNode(sceneNode);\r
- \param ellipsoidRadius: Radius of the ellipsoid with which collision detection and\r
- response is done. If you have got a scene node, and you are unsure about\r
- how big the radius should be, you could use the following code to determine\r
- it:\r
- \code\r
- const core::aabbox3d<f32>& box = yourSceneNode->getBoundingBox();\r
- core::vector3df radius = box.MaxEdge - box.getCenter();\r
- \endcode\r
- \param gravityPerSecond: Sets the gravity of the environment, as an acceleration in\r
- units per second per second. If your units are equivalent to meters, then\r
- core::vector3df(0,-10.0f,0) would give an approximately realistic gravity.\r
- You can disable gravity by setting it to core::vector3df(0,0,0).\r
- \param ellipsoidTranslation: By default, the ellipsoid for collision detection is created around\r
- the center of the scene node, which means that the ellipsoid surrounds\r
- it completely. If this is not what you want, you may specify a translation\r
- for the ellipsoid.\r
- \param slidingValue: DOCUMENTATION NEEDED.\r
- \return The animator. Attach it to a scene node with ISceneNode::addAnimator()\r
- and the animator will cause it to do collision detection and response.\r
- If you no longer need the animator, you should call ISceneNodeAnimator::drop().\r
- See IReferenceCounted::drop() for more information. */\r
- virtual ISceneNodeAnimatorCollisionResponse* createCollisionResponseAnimator(\r
- ITriangleSelector* world, ISceneNode* sceneNode,\r
- const core::vector3df& ellipsoidRadius = core::vector3df(30,60,30),\r
- const core::vector3df& gravityPerSecond = core::vector3df(0,-10.0f,0),\r
- const core::vector3df& ellipsoidTranslation = core::vector3df(0,0,0),\r
- f32 slidingValue = 0.0005f) = 0;\r
-\r
- //! Creates a follow spline animator.\r
- /** The animator modifies the position of\r
- the attached scene node to make it follow a Hermite spline.\r
- It uses a subset of Hermite splines: either cardinal splines\r
- (tightness != 0.5) or Catmull-Rom-splines (tightness == 0.5).\r
- The animator moves from one control point to the next in\r
- 1/speed seconds. This code was sent in by Matthias Gall.\r
- If you no longer need the animator, you should call ISceneNodeAnimator::drop().\r
- See IReferenceCounted::drop() for more information. */\r
- virtual ISceneNodeAnimator* createFollowSplineAnimator(s32 startTime,\r
- const core::array< core::vector3df >& points,\r
- f32 speed = 1.0f, f32 tightness = 0.5f, bool loop=true, bool pingpong=false) = 0;\r
-\r
- //! Creates a simple ITriangleSelector, based on a mesh.\r
- /** Triangle selectors\r
- can be used for doing collision detection. Don't use this selector\r
- for a huge amount of triangles like in Quake3 maps.\r
- Instead, use for example ISceneManager::createOctreeTriangleSelector().\r
- Please note that the created triangle selector is not automatically attached\r
- to the scene node. You will have to call ISceneNode::setTriangleSelector()\r
- for this. To create and attach a triangle selector is done like this:\r
- \code\r
- ITriangleSelector* s = sceneManager->createTriangleSelector(yourMesh,\r
- yourSceneNode);\r
- yourSceneNode->setTriangleSelector(s);\r
- s->drop();\r
- \endcode\r
- \param mesh: Mesh of which the triangles are taken.\r
- \param node: Scene node of which transformation is used.\r
- \param separateMeshbuffers: When true it's possible to get information which meshbuffer\r
- got hit in collision tests. But has a slight speed cost.\r
- \return The selector, or null if not successful.\r
- If you no longer need the selector, you should call ITriangleSelector::drop().\r
- See IReferenceCounted::drop() for more information. */\r
- virtual ITriangleSelector* createTriangleSelector(IMesh* mesh, ISceneNode* node, bool separateMeshbuffers=false) = 0;\r
-\r
- //! Creates a simple ITriangleSelector, based on a meshbuffer.\r
- /**\r
- This is a static selector which won't update when the mesh changes.\r
- \param meshBuffer Triangles of that meshbuffer are used\r
- \param materialIndex If you pass a material index that index can be returned by the triangle selector.\r
- \para node: Scene node of which transformation is used.\r
- */\r
- virtual ITriangleSelector* createTriangleSelector(const IMeshBuffer* meshBuffer, irr::u32 materialIndex, ISceneNode* node) = 0;\r
-\r
- //! Creates a simple ITriangleSelector, based on an animated mesh scene node.\r
- /** Details of the mesh associated with the node will be extracted internally.\r
- \param node The animated mesh scene node from which to build the selector\r
- \param separateMeshbuffers: When true it's possible to get information which meshbuffer\r
- got hit in collision tests. But has a slight speed cost.\r
- */\r
- virtual ITriangleSelector* createTriangleSelector(IAnimatedMeshSceneNode* node, bool separateMeshbuffers=false) = 0;\r
-\r
-\r
- //! Creates a simple dynamic ITriangleSelector, based on a axis aligned bounding box.\r
- /** Triangle selectors\r
- can be used for doing collision detection. Every time when triangles are\r
- queried, the triangle selector gets the bounding box of the scene node,\r
- an creates new triangles. In this way, it works good with animated scene nodes.\r
- \param node: Scene node of which the bounding box, visibility and transformation is used.\r
- \return The selector, or null if not successful.\r
- If you no longer need the selector, you should call ITriangleSelector::drop().\r
- See IReferenceCounted::drop() for more information. */\r
- virtual ITriangleSelector* createTriangleSelectorFromBoundingBox(ISceneNode* node) = 0;\r
-\r
- //! Creates a Triangle Selector, optimized by an octree.\r
- /** Triangle selectors\r
- can be used for doing collision detection. This triangle selector is\r
- optimized for huge amounts of triangle, it organizes them in an octree.\r
- Please note that the created triangle selector is not automatically attached\r
- to the scene node. You will have to call ISceneNode::setTriangleSelector()\r
- for this. To create and attach a triangle selector is done like this:\r
- \code\r
- ITriangleSelector* s = sceneManager->createOctreeTriangleSelector(yourMesh,\r
- yourSceneNode);\r
- yourSceneNode->setTriangleSelector(s);\r
- s->drop();\r
- \endcode\r
- For more information and examples on this, take a look at the collision\r
- tutorial in the SDK.\r
- \param mesh: Mesh of which the triangles are taken.\r
- \param node: Scene node of which visibility and transformation is used.\r
- \param minimalPolysPerNode: Specifies the minimal polygons contained a octree node.\r
- If a node gets less polys than this value, it will not be split into\r
- smaller nodes.\r
- \return The selector, or null if not successful.\r
- If you no longer need the selector, you should call ITriangleSelector::drop().\r
- See IReferenceCounted::drop() for more information. */\r
- virtual ITriangleSelector* createOctreeTriangleSelector(IMesh* mesh,\r
- ISceneNode* node, s32 minimalPolysPerNode=32) = 0;\r
-\r
- //! Creates a Triangle Selector for a single meshbuffer, optimized by an octree.\r
- /** Triangle selectors\r
- can be used for doing collision detection. This triangle selector is\r
- optimized for huge amounts of triangle, it organizes them in an octree.\r
- Please note that the created triangle selector is not automatically attached\r
- to the scene node. You will have to call ISceneNode::setTriangleSelector()\r
- for this. To create and attach a triangle selector is done like this:\r
- \code\r
- ITriangleSelector* s = sceneManager->createOctreeTriangleSelector(yourMesh,\r
- yourSceneNode);\r
- yourSceneNode->setTriangleSelector(s);\r
- s->drop();\r
- \endcode\r
- For more information and examples on this, take a look at the collision\r
- tutorial in the SDK.\r
- \param meshBuffer: Meshbuffer of which the triangles are taken.\r
- \param materialIndex: Setting this value allows the triangle selector to return the material index\r
- \param node: Scene node of which visibility and transformation is used.\r
- \param minimalPolysPerNode: Specifies the minimal polygons contained a octree node.\r
- If a node gets less polys than this value, it will not be split into\r
- smaller nodes.\r
- \return The selector, or null if not successful.\r
- If you no longer need the selector, you should call ITriangleSelector::drop().\r
- See IReferenceCounted::drop() for more information. */\r
- virtual ITriangleSelector* createOctreeTriangleSelector(IMeshBuffer* meshBuffer, irr::u32 materialIndex,\r
- ISceneNode* node, s32 minimalPolysPerNode=32) = 0;\r
-\r
- //! //! Creates a Triangle Selector, optimized by an octree.\r
- /** \deprecated Use createOctreeTriangleSelector instead. This method may be removed by Irrlicht 1.9. */\r
- _IRR_DEPRECATED_ ITriangleSelector* createOctTreeTriangleSelector(IMesh* mesh,\r
- ISceneNode* node, s32 minimalPolysPerNode=32)\r
- {\r
- return createOctreeTriangleSelector(mesh, node, minimalPolysPerNode);\r
- }\r
-\r
- //! Creates a meta triangle selector.\r
- /** A meta triangle selector is nothing more than a\r
- collection of one or more triangle selectors providing together\r
- the interface of one triangle selector. In this way,\r
- collision tests can be done with different triangle soups in one pass.\r
- \return The selector, or null if not successful.\r
- If you no longer need the selector, you should call ITriangleSelector::drop().\r
- See IReferenceCounted::drop() for more information. */\r
- virtual IMetaTriangleSelector* createMetaTriangleSelector() = 0;\r
-\r
- //! Creates a triangle selector which can select triangles from a terrain scene node.\r
- /** \param node: Pointer to the created terrain scene node\r
- \param LOD: Level of detail, 0 for highest detail.\r
- \return The selector, or null if not successful.\r
- If you no longer need the selector, you should call ITriangleSelector::drop().\r
- See IReferenceCounted::drop() for more information. */\r
- virtual ITriangleSelector* createTerrainTriangleSelector(\r
- ITerrainSceneNode* node, s32 LOD=0) = 0;\r
-\r
//! Adds an external mesh loader for extending the engine with new file formats.\r
/** If you want the engine to be extended with\r
file formats it currently is not able to load (e.g. .cob), just implement\r
\return A pointer to the specified loader, 0 if the index is incorrect. */\r
virtual IMeshLoader* getMeshLoader(u32 index) const = 0;\r
\r
- //! Adds an external scene loader for extending the engine with new file formats.\r
- /** If you want the engine to be extended with\r
- file formats it currently is not able to load (e.g. .vrml), just implement\r
- the ISceneLoader interface in your loading class and add it with this method.\r
- Using this method it is also possible to override the built-in scene loaders\r
- with newer or updated versions without the need to recompile the engine.\r
- \param externalLoader: Implementation of a new mesh loader. */\r
- virtual void addExternalSceneLoader(ISceneLoader* externalLoader) = 0;\r
-\r
- //! Returns the number of scene loaders supported by Irrlicht at this time\r
- virtual u32 getSceneLoaderCount() const = 0;\r
-\r
- //! Retrieve the given scene loader\r
- /** \param index The index of the loader to retrieve. This parameter is an 0-based\r
- array index.\r
- \return A pointer to the specified loader, 0 if the index is incorrect. */\r
- virtual ISceneLoader* getSceneLoader(u32 index) const = 0;\r
-\r
//! Get pointer to the scene collision manager.\r
/** \return Pointer to the collision manager\r
This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
pass currently is active they can render the correct part of their geometry. */\r
virtual E_SCENE_NODE_RENDER_PASS getSceneNodeRenderPass() const = 0;\r
\r
- //! Get the default scene node factory which can create all built in scene nodes\r
- /** \return Pointer to the default scene node factory\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual ISceneNodeFactory* getDefaultSceneNodeFactory() = 0;\r
-\r
- //! Adds a scene node factory to the scene manager.\r
- /** Use this to extend the scene manager with new scene node types which it should be\r
- able to create automatically, for example when loading data from xml files. */\r
- virtual void registerSceneNodeFactory(ISceneNodeFactory* factoryToAdd) = 0;\r
-\r
- //! Get amount of registered scene node factories.\r
- virtual u32 getRegisteredSceneNodeFactoryCount() const = 0;\r
-\r
- //! Get a scene node factory by index\r
- /** \return Pointer to the requested scene node factory, or 0 if it does not exist.\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual ISceneNodeFactory* getSceneNodeFactory(u32 index) = 0;\r
-\r
- //! Get the default scene node animator factory which can create all built-in scene node animators\r
- /** \return Pointer to the default scene node animator factory\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual ISceneNodeAnimatorFactory* getDefaultSceneNodeAnimatorFactory() = 0;\r
-\r
- //! Adds a scene node animator factory to the scene manager.\r
- /** Use this to extend the scene manager with new scene node animator types which it should be\r
- able to create automatically, for example when loading data from xml files. */\r
- virtual void registerSceneNodeAnimatorFactory(ISceneNodeAnimatorFactory* factoryToAdd) = 0;\r
-\r
- //! Get amount of registered scene node animator factories.\r
- virtual u32 getRegisteredSceneNodeAnimatorFactoryCount() const = 0;\r
-\r
- //! Get scene node animator factory by index\r
- /** \return Pointer to the requested scene node animator factory, or 0 if it does not exist.\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual ISceneNodeAnimatorFactory* getSceneNodeAnimatorFactory(u32 index) = 0;\r
-\r
- //! Get typename from a scene node type or null if not found\r
- virtual const c8* getSceneNodeTypeName(ESCENE_NODE_TYPE type) = 0;\r
-\r
- //! Returns a typename from a scene node animator type or null if not found\r
- virtual const c8* getAnimatorTypeName(ESCENE_NODE_ANIMATOR_TYPE type) = 0;\r
-\r
- //! Adds a scene node to the scene by name\r
- /** \return Pointer to the scene node added by a factory\r
- This pointer should not be dropped. See IReferenceCounted::drop() for more information. */\r
- virtual ISceneNode* addSceneNode(const char* sceneNodeTypeName, ISceneNode* parent=0) = 0;\r
-\r
- //! creates a scene node animator based on its type name\r
- /** \param typeName: Type of the scene node animator to add.\r
- \param target: Target scene node of the new animator.\r
- \return Returns pointer to the new scene node animator or null if not successful. You need to\r
- drop this pointer after calling this, see IReferenceCounted::drop() for details. */\r
- virtual ISceneNodeAnimator* createSceneNodeAnimator(const char* typeName, ISceneNode* target=0) = 0;\r
-\r
//! Creates a new scene manager.\r
/** This can be used to easily draw and/or store two\r
independent scenes at the same time. The mesh cache will be\r
See IReferenceCounted::drop() for more information. */\r
virtual ISceneManager* createNewSceneManager(bool cloneContent=false) = 0;\r
\r
- //! Saves the current scene into a file.\r
- /** Scene nodes with the option isDebugObject set to true are\r
- not being saved. The scene is usually written to an .irr file,\r
- an xml based format. .irr files can Be edited with the Irrlicht\r
- Engine Editor, irrEdit (http://www.ambiera.com/irredit/). To\r
- load .irr files again, see ISceneManager::loadScene().\r
- \param filename Name of the file.\r
- \param userDataSerializer If you want to save some user data\r
- for every scene node into the file, implement the\r
- ISceneUserDataSerializer interface and provide it as parameter\r
- here. Otherwise, simply specify 0 as this parameter.\r
- \param node Node which is taken as the top node of the scene.\r
- This node and all of its descendants are saved into the scene\r
- file. Pass 0 or the scene manager to save the full scene (which\r
- is also the default).\r
- \return True if successful. */\r
- virtual bool saveScene(const io::path& filename, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* node=0) = 0;\r
-\r
- //! Saves the current scene into a file.\r
- /** Scene nodes with the option isDebugObject set to true are\r
- not being saved. The scene is usually written to an .irr file,\r
- an xml based format. .irr files can Be edited with the Irrlicht\r
- Engine Editor, irrEdit (http://www.ambiera.com/irredit/). To\r
- load .irr files again, see ISceneManager::loadScene().\r
- \param file File where the scene is saved into.\r
- \param userDataSerializer If you want to save some user data\r
- for every scene node into the file, implement the\r
- ISceneUserDataSerializer interface and provide it as parameter\r
- here. Otherwise, simply specify 0 as this parameter.\r
- \param node Node which is taken as the top node of the scene.\r
- This node and all of its descendants are saved into the scene\r
- file. Pass 0 or the scene manager to save the full scene (which\r
- is also the default).\r
- \return True if successful. */\r
- virtual bool saveScene(io::IWriteFile* file, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* node=0) = 0;\r
-\r
- //! Saves the current scene into a file.\r
- /** Scene nodes with the option isDebugObject set to true are\r
- not being saved. The scene is usually written to an .irr file,\r
- an xml based format. .irr files can Be edited with the Irrlicht\r
- Engine Editor, irrEdit (http://www.ambiera.com/irredit/). To\r
- load .irr files again, see ISceneManager::loadScene().\r
- \param writer XMLWriter with which the scene is saved.\r
- \param currentPath Path which is used for relative file names.\r
- Usually the directory of the file written into.\r
- \param userDataSerializer If you want to save some user data\r
- for every scene node into the file, implement the\r
- ISceneUserDataSerializer interface and provide it as parameter\r
- here. Otherwise, simply specify 0 as this parameter.\r
- \param node Node which is taken as the top node of the scene.\r
- This node and all of its descendants are saved into the scene\r
- file. Pass 0 or the scene manager to save the full scene (which\r
- is also the default).\r
- \return True if successful. */\r
- virtual bool saveScene(io::IXMLWriter* writer, const io::path& currentPath, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* node=0) = 0;\r
-\r
- //! Loads a scene. Note that the current scene is not cleared before.\r
- /** The scene is usually loaded from an .irr file, an xml based\r
- format, but other scene formats can be added to the engine via\r
- ISceneManager::addExternalSceneLoader. .irr files can Be edited\r
- with the Irrlicht Engine Editor, irrEdit\r
- (http://www.ambiera.com/irredit/) or saved directly by the engine\r
- using ISceneManager::saveScene().\r
- \param filename Name of the file to load from.\r
- \param userDataSerializer If you want to load user data\r
- possibily saved in that file for some scene nodes in the file,\r
- implement the ISceneUserDataSerializer interface and provide it\r
- as parameter here. Otherwise, simply specify 0 as this\r
- parameter.\r
- \param rootNode Node which is taken as the root node of the\r
- scene. Pass 0 to add the scene directly to the scene manager\r
- (which is also the default).\r
- \return True if successful. */\r
- virtual bool loadScene(const io::path& filename, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* rootNode=0) = 0;\r
-\r
- //! Loads a scene. Note that the current scene is not cleared before.\r
- /** The scene is usually loaded from an .irr file, an xml based\r
- format, but other scene formats can be added to the engine via\r
- ISceneManager::addExternalSceneLoader. .irr files can Be edited\r
- with the Irrlicht Engine Editor, irrEdit\r
- (http://www.ambiera.com/irredit/) or saved directly by the engine\r
- using ISceneManager::saveScene().\r
- \param file File where the scene is loaded from.\r
- \param userDataSerializer If you want to load user data\r
- saved in that file for some scene nodes in the file,\r
- implement the ISceneUserDataSerializer interface and provide it\r
- as parameter here. Otherwise, simply specify 0 as this\r
- parameter.\r
- \param rootNode Node which is taken as the root node of the\r
- scene. Pass 0 to add the scene directly to the scene manager\r
- (which is also the default).\r
- \return True if successful. */\r
- virtual bool loadScene(io::IReadFile* file, ISceneUserDataSerializer* userDataSerializer=0, ISceneNode* rootNode=0) = 0;\r
-\r
//! Get a mesh writer implementation if available\r
/** Note: You need to drop() the pointer after use again, see IReferenceCounted::drop()\r
for details. */\r
//! Get ambient color of the scene\r
virtual const video::SColorf& getAmbientLight() const = 0;\r
\r
- //! Register a custom callbacks manager which gets callbacks during scene rendering.\r
- /** \param[in] lightManager: the new callbacks manager. You may pass 0 to remove the\r
- current callbacks manager and restore the default behavior. */\r
- virtual void setLightManager(ILightManager* lightManager) = 0;\r
-\r
//! Get current render pass.\r
virtual E_SCENE_NODE_RENDER_PASS getCurrentRenderPass() const =0;\r
\r
//! Set current render pass.\r
virtual void setCurrentRenderPass(E_SCENE_NODE_RENDER_PASS nextPass) =0;\r
\r
- //! Get an instance of a geometry creator.\r
- /** The geometry creator provides some helper methods to create various types of\r
- basic geometry. This can be useful for custom scene nodes. */\r
- virtual const IGeometryCreator* getGeometryCreator(void) const = 0;\r
-\r
//! Check if node is culled in current view frustum\r
/** Please note that depending on the used culling method this\r
check can be rather coarse, or slow. A positive result is\r
projects / irrlicht.git / blobdiff