746 lines
40 KiB
C++
746 lines
40 KiB
C++
// Copyright (C) 2002-2006 Nikolaus Gebhardt
|
|
// This file is part of the "Irrlicht Engine".
|
|
// For conditions of distribution and use, see copyright notice in irrlicht.h
|
|
|
|
#pragma once
|
|
|
|
#using <mscorlib.dll>
|
|
using namespace System;
|
|
|
|
#pragma unmanaged
|
|
#include "..\\..\\include\\irrlicht.h"
|
|
#pragma managed
|
|
|
|
#include "Color.h"
|
|
#include "Vector3D.h"
|
|
#include "Matrix4.h"
|
|
#include "ITexture.h"
|
|
#include "Material.h"
|
|
#include "Position2D.h"
|
|
#include "Rect.h"
|
|
#include "Vertex3D.h"
|
|
#include "Triangle3D.h"
|
|
#include "Box3D.h"
|
|
#include "Light.h"
|
|
#include "IAnimatedMesh.h"
|
|
#include "ISceneNode.h"
|
|
#include "ICameraSceneNode.h"
|
|
#include "IAnimatedMeshSceneNode.h"
|
|
#include "ILightSceneNode.h"
|
|
#include "IBillboardSceneNode.h"
|
|
#include "IParticleSystemSceneNode.h"
|
|
#include "IGUIFont.h"
|
|
|
|
namespace Irrlicht
|
|
{
|
|
public __gc class IrrlichtDevice;
|
|
|
|
namespace Scene
|
|
{
|
|
public __gc class ITriangleSelector;
|
|
public __gc class IMetaTriangleSelector;
|
|
public __gc class ISceneCollisionManager;
|
|
public __gc class ITerrainSceneNode;
|
|
public __gc class IMeshManipulator;
|
|
|
|
public __gc class ISceneManager
|
|
{
|
|
public:
|
|
|
|
/// <summary>
|
|
/// You should access the ISceneManager
|
|
/// through the Irrlicht::IrrlichtDevice.SceneMAnager property. Simply don't use
|
|
/// this constructor.
|
|
///</summary>
|
|
///<param name="manager">The real, unmanaged C++ scene manager</param>
|
|
ISceneManager(irr::scene::ISceneManager* manager);
|
|
|
|
/// <summary>
|
|
/// Gets pointer to an animateable mesh. Loads it if needed.
|
|
/// Currently there are the following mesh formats supported:
|
|
/// .obj(Alias Wavefront Maya), .ms3d(Milkshape3D), .bsp(Quake3 Level),
|
|
/// .md2(Quake2 Model), .3ds(3D Studio), .x(Microsoft DirectX) More formats coming soon,
|
|
/// make a feature request on the Irrlicht Engine homepage if you like.
|
|
/// Special thanks go to Dean P. Macri who extended the Quake 3
|
|
/// .bsp loader with the curved surfaces feature.
|
|
/// </summary>
|
|
/// <param name="filename"> Filename of the mesh to load.</param>
|
|
/// <returns> Returns NULL if failed and the pointer to the mesh if
|
|
/// successful. </returns>
|
|
IAnimatedMesh* GetMesh(System::String* filename);
|
|
|
|
/// <summary>
|
|
/// Adds a cube scene node to the scene. It is of (1,1,1) size.
|
|
/// </summary>
|
|
/// <param name="size"> Size of the cube.</param>
|
|
/// <param name="parent"> Parent of the scene node. Can be NULL if no parent.</param>
|
|
/// <param name="id"> Id of the node. This id can be used to identify the scene node.</param>
|
|
/// <param name="position"> Position of the space relative to its parent where the
|
|
/// scene node will be placed.</param>
|
|
/// <param name="rotation"> Initital rotation of the scene node.</param>
|
|
/// <param name="scale"> Initial scale of the scene node.</param>
|
|
/// <returns> Returns pointer to the created test scene node.</returns>
|
|
ISceneNode* AddCubeSceneNode(float size, ISceneNode* parent, int id,
|
|
Core::Vector3D position, Core::Vector3D rotation, Core::Vector3D scale);
|
|
ISceneNode* AddCubeSceneNode(float size, ISceneNode* parent, int id, Core::Vector3D position);
|
|
|
|
/// <summary>
|
|
/// Adds a scene node for rendering an animated mesh model.
|
|
/// </summary>
|
|
/// <param name="mesh"> Pointer to the loaded animated mesh to be displayed.</param>
|
|
/// <param name="parent"> Parent of the scene node. Can be NULL if no parent.</param>
|
|
/// <param name="id"> Id of the node. This id can be used to identify the scene node.</param>
|
|
/// <param name="position"> Position of the space relative to its parent where the
|
|
/// scene node will be placed.</param>
|
|
/// <param name="rotation"> Initital rotation of the scene node.</param>
|
|
/// <param name="scale">: Initial scale of the scene node.</param>
|
|
/// <returns> Returns pointer to the created scene node.</returns>
|
|
IAnimatedMeshSceneNode* AddAnimatedMeshSceneNode(IAnimatedMesh* mesh, ISceneNode* parent, int id,
|
|
Core::Vector3D position, Core::Vector3D rotation, Core::Vector3D scale);
|
|
IAnimatedMeshSceneNode* AddAnimatedMeshSceneNode(IAnimatedMesh* mesh, ISceneNode* parent, int id);
|
|
|
|
/// <summary>
|
|
/// Adds a scene node for rendering a static mesh.
|
|
/// </summary>
|
|
/// <param name="mesh"> Pointer to the loaded static mesh to be displayed.</param>
|
|
/// <param name="parent"> Parent of the scene node. Can be NULL if no parent.</param>
|
|
/// <param name="id"> Id of the node. This id can be used to identify the scene node.</param>
|
|
/// <param name="position"> Position of the space relative to its parent where the
|
|
/// scene node will be placed.</param>
|
|
/// <param name="rotation"> Initital rotation of the scene node.</param>
|
|
/// <param name="scale"> Initial scale of the scene node.</param>
|
|
/// <returns> Returns pointer to the created scene node.</returns>
|
|
ISceneNode* AddMeshSceneNode(IMesh* mesh, ISceneNode* parent, int id);
|
|
|
|
/// <summary>
|
|
/// Adds a scene node for rendering a static mesh.
|
|
/// </summary>
|
|
/// <param name="mesh"> Pointer to the loaded static mesh to be displayed.</param>
|
|
/// <param name="parent"> Parent of the scene node. Can be NULL if no parent.</param>
|
|
/// <param name="id"> Id of the node. This id can be used to identify the scene node.</param>
|
|
/// <param name="position"> Position of the space relative to its parent where the
|
|
/// scene node will be placed.</param>
|
|
/// <param name="rotation"> Initital rotation of the scene node.</param>
|
|
/// <param name="scale"> Initial scale of the scene node.</param>
|
|
/// <returns> Returns pointer to the created scene node.</returns>
|
|
ISceneNode* AddMeshSceneNode(IMesh* mesh, ISceneNode* parent, int id,
|
|
Core::Vector3D position, Core::Vector3D rotation, Core::Vector3D scale);
|
|
|
|
/// <summary>
|
|
/// Adds a scene node for rendering a animated water surface mesh.
|
|
/// Looks really good when the Material type EMT_TRANSPARENT_REFLECTION
|
|
/// is used.
|
|
/// </summary>
|
|
/// <param name="waveHeight"> Height of the water waves. A good value would be 2.0</param>
|
|
/// <param name="waveSpeed"> Speed of the water waves. A good value would be 300.0.</param>
|
|
/// <param name="waveLenght"> Lenght of a water wave. A good value would be 10.0</param>
|
|
/// <param name="mesh"> Pointer to the loaded static mesh to be displayed with water waves on it.</param>
|
|
/// <param name="parent"> Parent of the scene node. Can be NULL if no parent.</param>
|
|
/// <param name="id"> Id of the node. This id can be used to identify the scene node.</param>
|
|
/// <param name="position"> Position of the space relative to its parent where the
|
|
/// scene node will be placed.</param>
|
|
/// <param name="rotation"> Initital rotation of the scene node.</param>
|
|
/// <param name="scale"> Initial scale of the scene node.</param>
|
|
/// <returns> Returns pointer to the created scene node.</returns>
|
|
ISceneNode* AddWaterSurfaceSceneNode(IMesh* mesh,
|
|
float waveHeight, float waveSpeed, float waveLenght,
|
|
ISceneNode* parent, int id);
|
|
|
|
/// <summary>
|
|
/// Adds a scene node for rendering using a octtree to the scene graph. This a good method for rendering
|
|
/// scenes with lots of geometry. The Octree is built on the fly from the mesh, much
|
|
/// faster then a bsp tree.
|
|
/// </summary>
|
|
/// <param name="mesh"> The mesh containing all geometry from which the octtree will be build.
|
|
/// If this animated mesh has more than one frames in it, the first frame is taken.</param>
|
|
/// <param name="parent"> Parent node of the octtree node. Can be null for no parent.</param>
|
|
/// <param name="id"> id of the node. This id can be used to identify the node.</param>
|
|
/// <param name="minimalPolysPerNode"> Specifies the minimal polygons contained a octree node.
|
|
/// If a node gets less polys the this value, it will not be splitted into
|
|
/// smaller nodes. (Default: 128)</param>
|
|
/// <returns> Returns the pointer to the octtree if successful, otherwise 0.
|
|
/// </returns>
|
|
ISceneNode* AddOctTreeSceneNode(IAnimatedMesh* mesh, ISceneNode* parent,
|
|
int id);
|
|
ISceneNode* AddOctTreeSceneNode(IAnimatedMesh* mesh, ISceneNode* parent,
|
|
int id, int minimalPolysPerNode);
|
|
|
|
/// <summary>
|
|
/// Adds a scene node for rendering using a octtree to the scene graph. This a good method for rendering
|
|
/// scenes with lots of geometry. The Octree is built on the fly from the mesh, much
|
|
/// faster then a bsp tree.
|
|
/// </summary>
|
|
/// <param name="mesh"> The mesh containing all geometry from which the octtree will be build.</param>
|
|
/// <param name="parent"> Parent node of the octtree node. Can be null for no parent.</param>
|
|
/// <param name="id"> id of the node. This id can be used to identify the node.</param>
|
|
/// <param name="minimalPolysPerNode"> Specifies the minimal polygons contained a octree node.
|
|
/// If a node gets less polys the this value, it will not be splitted into
|
|
/// smaller nodes. (Default: 128)</param>
|
|
/// <returns> Returns the pointer to the octtree if successful, otherwise 0.
|
|
/// </returns>
|
|
ISceneNode* AddOctTreeSceneNode(IMesh* mesh, ISceneNode* parent, int id);
|
|
|
|
/// <summary>
|
|
/// Adds a scene node for rendering using a octtree to the scene graph. This a good method for rendering
|
|
/// scenes with lots of geometry. The Octree is built on the fly from the mesh, much
|
|
/// faster then a bsp tree.
|
|
/// </summary>
|
|
/// <param name="mesh"> The mesh containing all geometry from which the octtree will be build.</param>
|
|
/// <param name="parent"> Parent node of the octtree node. Can be null for no parent.</param>
|
|
/// <param name="id"> id of the node. This id can be used to identify the node.</param>
|
|
/// <param name="minimalPolysPerNode"> Specifies the minimal polygons contained a octree node.
|
|
/// If a node gets less polys the this value, it will not be splitted into
|
|
/// smaller nodes. (Default: 128)</param>
|
|
/// <returns> Returns the pointer to the octtree if successful, otherwise 0.
|
|
/// </returns>
|
|
ISceneNode* AddOctTreeSceneNode(IMesh* mesh, ISceneNode* parent, int id, int minimalPolysPerNode);
|
|
|
|
/// <summary>
|
|
/// Adds a camera scene node to the scene graph and sets it as active camera.
|
|
/// </summary>
|
|
/// <param name="position"> Position of the space relative to its parent where the camera will be placed.</param>
|
|
/// <param name="lookat"> Position where the camera will look at. Also known as target.</param>
|
|
/// <param name="parent"> Parent scene node of the camera. Can be null. If the parent moves,
|
|
/// the camera will move too.</param>
|
|
/// <param name="id"> id of the camera. This id can be used to identify the camera.</param>
|
|
/// <returns> Returns pointer to interface to camera if successful, otherwise 0.</returns>
|
|
ICameraSceneNode* AddCameraSceneNode(ISceneNode* parent,
|
|
Core::Vector3D position, Core::Vector3D lookat, int id);
|
|
|
|
/// <summary>
|
|
/// Adds a camera scene node which is able to be controlled with the mouse similar
|
|
/// like in the 3D Software Maya by Alias Wavefront.
|
|
/// </summary>
|
|
/// <param name="parent"> Parent scene node of the camera. Can be null.</param>
|
|
/// <param name="rotateSpeed"> Rotation speed of the camera. Default value is -1500.0f.</param>
|
|
/// <param name="zoomSpeed"> Zoom speed of the camera. Default is 200.0f.</param>
|
|
/// <param name="tranlationSpeed"> TranslationSpeed of the camera. Default is 1500.0f</param>
|
|
/// <param name="id"> id of the camera. This id can be used to identify the camera.</param>
|
|
/// <returns> Returns a pointer to the interface of the camera if successful, otherwise 0.</returns>
|
|
ICameraSceneNode* AddCameraSceneNodeMaya(ISceneNode* parent,
|
|
float rotateSpeed, float zoomSpeed, float translationSpeed, int id);
|
|
|
|
/// <summary>
|
|
/// Adds a camera scene node which is able to be controled with the mouse and keys
|
|
/// like in most first person shooters (FPS):
|
|
/// Look with the mouse, move with cursor keys. If you do not like the default
|
|
/// key layout, you may want to specify your own. For example to make the camera
|
|
/// be controlled by the cursor keys AND the keys W,A,S, and D, do something
|
|
/// like this:
|
|
/// </summary>
|
|
/// <param name="parent"> Parent scene node of the camera. Can be null.</param>
|
|
/// <param name="rotateSpeed"> Speed with wich the camera is rotated. This can be done
|
|
/// only with the mouse. (Default 100)</param>
|
|
/// <param name="movespeed"> Speed with which the camera is moved. Movement is done with
|
|
/// the cursor keys. (Default: 500)</param>
|
|
/// <param name="id"/> id of the camera. This id can be used to identify the camera.
|
|
/// <param name="keyMapArray"/> Optional pointer to an array of a keymap, specifying what
|
|
/// keys should be used to move the camera. If this is null, the default keymap
|
|
/// is used. You can define actions more then one time in the array, to bind
|
|
/// multiple keys to the same action.
|
|
/// <param name="keyMapSize"> Amount of items in the keymap array.</param>
|
|
/// <returns> Returns a pointer to the interface of the camera if successful, otherwise 0.
|
|
/// This pointer should not be dropped. See IUnknown::drop() for more information.</returns>
|
|
ICameraSceneNode* AddCameraSceneNodeFPS();
|
|
|
|
/// <summary>
|
|
/// Adds a camera scene node which is able to be controled with the mouse and keys
|
|
/// like in most first person shooters (FPS):
|
|
/// Look with the mouse, move with cursor keys. If you do not like the default
|
|
/// key layout, you may want to specify your own. For example to make the camera
|
|
/// be controlled by the cursor keys AND the keys W,A,S, and D, do something
|
|
/// like this:
|
|
/// </summary>
|
|
/// <param name="parent"> Parent scene node of the camera. Can be null.</param>
|
|
/// <param name="rotateSpeed"> Speed with wich the camera is rotated. This can be done
|
|
/// only with the mouse. (Default 100)</param>
|
|
/// <param name="movespeed"> Speed with which the camera is moved. Movement is done with
|
|
/// the cursor keys. (Default: 500)</param>
|
|
/// <param name="id"/> id of the camera. This id can be used to identify the camera.
|
|
/// <param name="keyMapArray"/> Optional pointer to an array of a keymap, specifying what
|
|
/// keys should be used to move the camera. If this is null, the default keymap
|
|
/// is used. You can define actions more then one time in the array, to bind
|
|
/// multiple keys to the same action.
|
|
/// <param name="keyMapSize"> Amount of items in the keymap array.</param>
|
|
/// <returns> Returns a pointer to the interface of the camera if successful, otherwise 0.
|
|
/// This pointer should not be dropped. See IUnknown::drop() for more information.</returns>
|
|
ICameraSceneNode* AddCameraSceneNodeFPS(ISceneNode* parent,
|
|
float rotateSpeed, float moveSpeed, int id);
|
|
|
|
/// <summary>
|
|
/// Adds a dynamic light scene node to the scene graph. The light will cast dynamic light on all
|
|
/// other scene nodes in the scene, which have the material flag LIGHTING
|
|
/// turned on. (This is the default setting in most scene nodes).
|
|
/// </summary>
|
|
/// <param name="parent"> Parent scene node of the light. Can be null. If the parent moves,
|
|
/// the light will move too.</param>
|
|
/// <param name="position"> Position of the space relative to its parent where the light will be placed.</param>
|
|
/// <param name="color"> Diffuse color of the light. Ambient or Specular colors can be set manually with
|
|
/// the ILightSceneNode::getLightData() method.</param>
|
|
/// <param name="radius"> Radius of the light. Default is 100.</param>
|
|
/// <param name="id"> id of the node. This id can be used to identify the node.</param>
|
|
/// <returns> Returns pointer to the interface of the light if successful, otherwise NULL.</returns>
|
|
ILightSceneNode* AddLightSceneNode(ISceneNode* parent,
|
|
Core::Vector3D position,
|
|
Video::Colorf color, float radius, int id);
|
|
|
|
/// <summary>
|
|
/// Adds a billboard scene node to the scene graph. A billboard is like a 3d sprite: A 2d element,
|
|
/// which always looks to the camera. It is usually used for things like explosions, fire,
|
|
/// lensflares and things like that.
|
|
/// </summary>
|
|
/// <param name="parent"> Parent scene node of the billboard. Can be null. If the parent moves,
|
|
/// the billboard will move too.</param>
|
|
/// <param name="position"> Position of the space relative to its parent where the billboard will be placed.</param>
|
|
/// <param name="size"> Size of the billboard. This size is 2 dimensional because a billboard only has
|
|
/// width and height.</param>
|
|
/// <param name="id"> An id of the node. This id can be used to identify the node.</param>
|
|
/// <returns> Returns pointer to the billboard if successful, otherwise NULL.</returns>
|
|
IBillboardSceneNode* AddBillboardSceneNode(ISceneNode* parent,
|
|
Core::Dimension2Df size, Core::Vector3D position, int id);
|
|
|
|
/// <summary>
|
|
/// Adds a skybox scene node to the scene graph. A skybox is a big cube with 6 textures on it and
|
|
/// is drawed around the camera position.
|
|
/// </summary>
|
|
/// <param name="top"> Texture for the top plane of the box.</param>
|
|
/// <param name="bottom"> Texture for the bottom plane of the box.</param>
|
|
/// <param name="left"> Texture for the left plane of the box.</param>
|
|
/// <param name="right"> Texture for the right plane of the box.</param>
|
|
/// <param name="front"> Texture for the front plane of the box.</param>
|
|
/// <param name="parent"> Parent scene node of the skybox. A skybox usually has no parent,
|
|
/// so this should be null. Note: If a parent is set to the skybox, the box will not
|
|
/// change how it is drawed.</param>
|
|
/// <param name="id"> An id of the node. This id can be used to identify the node.</param>
|
|
/// <returns> Returns a pointer to the sky box if successful, otherwise NULL.</returns>
|
|
ISceneNode* AddSkyBoxSceneNode(Video::ITexture* top, Video::ITexture* bottom,
|
|
Video::ITexture* left, Video::ITexture* right, Video::ITexture* front,
|
|
Video::ITexture* back, ISceneNode* parent, int id);
|
|
|
|
/// <summary>
|
|
/// Adds a terrain scene node to the scene graph.
|
|
/// This node
|
|
/// implements is a simple terrain renderer which uses
|
|
/// a technique known as geo mip mapping
|
|
/// for reducing the detail of triangle blocks which are far away.
|
|
/// The code for the TerrainSceneNode is based on the terrain renderer by Soconne and
|
|
/// the GeoMipMapSceneNode developed by Spinz. They made their code available for Irrlicht
|
|
/// and allowed it to be distributed under this licence. I only modified some parts.
|
|
/// A lot of thanks go to them.
|
|
///
|
|
/// This scene node is capable of very quickly loading
|
|
/// terrains and updating the indices at runtime to enable viewing very large terrains. It uses a
|
|
/// CLOD (Continuous Level of Detail) algorithm which updates the indices for each patch based on
|
|
/// a LOD (Level of Detail) which is determined based on a patch's distance from the camera.
|
|
///
|
|
/// The patch size of the terrain must always be a size of ( 2^N+1, i.e. 8+1(9), 16+1(17), etc. ).
|
|
/// The MaxLOD available is directly dependent on the patch size of the terrain. LOD 0 contains all
|
|
/// of the indices to draw all the triangles at the max detail for a patch. As each LOD goes up by 1
|
|
/// the step taken, in generating indices increases by - 2^LOD, so for LOD 1, the step taken is 2, for
|
|
/// LOD 2, the step taken is 4, LOD 3 - 8, etc. The step can be no larger than the size of the patch,
|
|
/// so having a LOD of 8, with a patch size of 17, is asking the algoritm to generate indices every
|
|
/// 2^8 ( 256 ) vertices, which is not possible with a patch size of 17. The maximum LOD for a patch
|
|
/// size of 17 is 2^4 ( 16 ). So, with a MaxLOD of 5, you'll have LOD 0 ( full detail ), LOD 1 ( every
|
|
/// 2 vertices ), LOD 2 ( every 4 vertices ), LOD 3 ( every 8 vertices ) and LOD 4 ( every 16 vertices ).
|
|
/// </summary>
|
|
/// <param name="heightMapFile"> The location of the file on disk, to read vertex data from. This should
|
|
/// be a gray scale bitmap.</param>
|
|
/// <param name="position"> The absolute position of this node.</param>
|
|
/// <param name="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.</param>
|
|
/// <param name="vertexColor"> The default color of all the vertices. If no texture is associated
|
|
/// with the scene node, then all vertices will be this color. Defaults to white.</param>
|
|
/// <returns>Returns pointer to the created scene node. Can be null if the
|
|
/// terrain could not be created, for example because the heightmap could not be loaded.</returns>
|
|
ITerrainSceneNode* AddTerrainSceneNode(
|
|
System::String* heightMapFileName,
|
|
ISceneNode* parent, int id,
|
|
Core::Vector3D position,
|
|
Core::Vector3D scale,
|
|
Video::Color color );
|
|
|
|
/// <summary>
|
|
/// Adds a particle system scene node to the scene graph.</summary>
|
|
/// <param name="withDefaultEmitter"> Creates a default working point emitter
|
|
/// which emitts some particles. Set this to true to see a particle system
|
|
/// in action. If set to false, you'll have to set the emitter you want by
|
|
/// calling IParticleSystemSceneNode::setEmitter().</param>
|
|
/// <param name="parent"> Parent of the scene node. Can be NULL if no parent.</param>
|
|
/// <param name="id"> Id of the node. This id can be used to identify the scene node.</param>
|
|
/// <param name="position"> Position of the space relative to its parent where the
|
|
/// scene node will be placed.</param>
|
|
/// <param name="rotation"> Initital rotation of the scene node.</param>
|
|
/// <param name="scale"> Initial scale of the scene node.</param>
|
|
/// <returns> Returns pointer to the created scene node.</returns>
|
|
IParticleSystemSceneNode* AddParticleSystemSceneNode(
|
|
bool withDefaultEmitter, ISceneNode* parent, int id,
|
|
Core::Vector3D position,
|
|
Core::Vector3D rotation,
|
|
Core::Vector3D scale );
|
|
|
|
/// <summary>
|
|
/// Adds an empty scene node. Can be used for doing advanced transformations
|
|
/// or structuring the scene graph.
|
|
/// </summary>
|
|
/// <returns> Returns pointer to the created scene node.</returns>
|
|
ISceneNode* AddEmptySceneNode(ISceneNode* parent, int id);
|
|
|
|
/// <summary>
|
|
/// Adds a text scene node, which is able to display 2d text at a position in three dimensional space
|
|
/// </summary>
|
|
ISceneNode* AddTextSceneNode(GUI::IGUIFont* font, System::String* text,
|
|
Video::Color color, ISceneNode* parent, const Core::Vector3D position, int id);
|
|
|
|
/// <summary>
|
|
/// Adds a Hill Plane mesh to the mesh pool. The mesh is generated on the fly
|
|
/// and looks like a plane with some hills on it. It is uses mostly for quick
|
|
/// tests of the engine only. You can specify how many hills there should be
|
|
/// on the plane and how high they should be. Also you must specify a name for
|
|
/// the mesh, because the mesh is added to the mesh pool, and can be retieved
|
|
/// again using ISceneManager::getMesh() with the name as parameter.
|
|
/// </summary>
|
|
/// <param name="name"> The name of this mesh which must be specified in order
|
|
/// to be able to retrieve the mesh later with ISceneManager::getMesh().</param>
|
|
/// <param name="tileSize"> Size of a tile of the mesh. (10.0f, 10.0f) would be a
|
|
/// good value to start, for example.</param>
|
|
/// <param name="tileCount"> Specifies how much tiles there will be. If you specifiy
|
|
/// for example that a tile has the size (10.0f, 10.0f) and the tileCount is
|
|
/// (10,10), than you get a field of 100 tiles wich has the dimension 100.0fx100.0f.</param>
|
|
/// <param name="material"/> Material of the hill mesh.</param>
|
|
/// <param name="hillHeight"/> Height of the hills. If you specify a negative value
|
|
/// you will get holes instead of hills. If the height is 0, no hills will be
|
|
/// created.</param>
|
|
/// <param name="countHills"> Amount of hills on the plane. There will be countHills.X
|
|
/// hills along the X axis and countHills.Y along the Y axis. So in total there
|
|
/// will be countHills.X * countHills.Y hills.</param>
|
|
/// <param name="textureRepeatCount"> Defines how often the texture will be repeated in
|
|
/// x and y direction.</param>
|
|
/// <returns> Returns null if the creation failed. The reason could be that you
|
|
/// specified some invalid parameters or that a mesh with that name already
|
|
/// exists. </returns>
|
|
IAnimatedMesh* ISceneManager::AddHillPlaneMesh(System::String* name,
|
|
Core::Dimension2Df tileSize, Core::Dimension2D tileCount,
|
|
Video::Material material, float hillHeight, Core::Dimension2Df countHills,
|
|
Core::Dimension2Df textureRepeatCount );
|
|
|
|
/// <summary>
|
|
/// Adds a dummy transformation scene node to the scene graph.
|
|
/// This scene node does not render itself, and does not respond to set/getPosition,
|
|
/// set/getRotation and set/getScale. Its just a simple scene node that takes a
|
|
/// matrix as relative transformation, making it possible to insert any transformation
|
|
/// anywhere into the scene graph.
|
|
/// </summary>
|
|
/// <returns> Returns pointer to the created scene node.</returns>
|
|
//IDummyTransformationSceneNode* addDummyTransformationSceneNode(
|
|
// ISceneNode* parent, int id);
|
|
|
|
|
|
/// <summary>
|
|
/// Adds a static terrain mesh to the mesh pool. The mesh is generated on the fly
|
|
/// from a texture file and a height map file. Both files may be huge
|
|
/// (8000x8000 pixels would be no problem) because the generator splits the
|
|
/// files into smaller textures if necessary.
|
|
/// You must specify a name for the mesh, because the mesh is added to the mesh pool,
|
|
/// and can be retieved again using ISceneManager::getMesh() with the name as parameter.
|
|
/// <param name="meshname"/> The name of this mesh which must be specified in order
|
|
/// to be able to retrieve the mesh later with ISceneManager::getMesh().
|
|
/// <param name="texture"/> Texture for the terrain. Please note that this is not a
|
|
/// hardware texture as usual (ITexture), but an IImage software texture.
|
|
/// You can load this texture with IVideoDriver::createImageFromFile().
|
|
/// <param name="heightmap"/> A grayscaled heightmap image. Like the texture,
|
|
/// it can be created with IVideoDriver::createImageFromFile(). The amount
|
|
/// of triangles created depends on the size of this texture, so use a small
|
|
/// heightmap to increase rendering speed.
|
|
/// <param name="stretchSize"/> Parameter defining how big a is pixel on the heightmap.
|
|
/// <param name="maxHeight"/> Defines how height a white pixel on the heighmap is.
|
|
/// \return Returns null if the creation failed. The reason could be that you
|
|
/// specified some invalid parameters, that a mesh with that name already
|
|
/// exists, or that a texture could not be found. If successful, a pointer to the mesh is returned.
|
|
/// This pointer should not be dropped. See IUnknown::drop() for more information.
|
|
//IAnimatedMesh* addTerrainMesh( c8* meshname,
|
|
// video::IImage* texture, video::IImage* heightmap,
|
|
// core::dimension2d<float>& stretchSize = core::dimension2d<float>(10.0f,10.0f),
|
|
// float maxHeight=200.0f,
|
|
// core::dimension2d<int>& defaultVertexBlockSize = core::dimension2d<int>(64,64)) = 0;
|
|
|
|
/// <summary>
|
|
/// Sets or returns the current active camera.
|
|
/// </summary>
|
|
/// <returns>The active camera is returned. Note that this can be NULL, if there
|
|
/// was no camera created yet.</returns>
|
|
__property ICameraSceneNode* get_ActiveCamera();
|
|
|
|
/// <summary>
|
|
/// Sets the active camera. The previous active camera will be deactivated.
|
|
/// </summary>
|
|
/// <param name="camera"> The new camera which should be active.</param>
|
|
__property void set_ActiveCamera(ICameraSceneNode* camera);
|
|
|
|
/// <summary>
|
|
/// Returns or sets the color of stencil buffers shadows drawn by the scene manager.
|
|
/// Usually you should set this to black with a little alpha like (150,0,0,0).
|
|
/// </summary>
|
|
__property void set_ShadowColor(Video::Color color);
|
|
|
|
/// <summary>
|
|
/// Returns or sets the color of stencil buffers shadows drawn by the scene manager.
|
|
/// Usually you should set this to black with a little alpha like (150,0,0,0).
|
|
/// </summary>
|
|
__property Video::Color get_ShadowColor();
|
|
|
|
/// <summary>
|
|
/// Returns the root scene node. This is the scene node wich is parent
|
|
/// of all scene nodes. The root scene node is a special scene node which
|
|
/// only exists to manage all scene nodes. It is not rendered and cannot
|
|
/// be removed from the scene.
|
|
/// </summary>
|
|
__property ISceneNode* get_RootSceneNode();
|
|
|
|
/// <summary>
|
|
/// Returns the first scene node with the specified id.
|
|
/// <param name="id"/> The id to search for
|
|
/// <param name="start"/> Scene node to start from. All children of this scene
|
|
/// node are searched. If null is specified, the root scene node is
|
|
/// taken.
|
|
/// \return Returns pointer to the first scene node with this id,
|
|
/// and null if no scene node could be found.
|
|
//ISceneNode* getSceneNodeFromId(int id, ISceneNode* start=0) = 0;
|
|
|
|
/// <summary>
|
|
/// Registers a node for rendering it at a specific time.
|
|
/// This method should only be used by SceneNodes when they get a
|
|
/// ISceneNode::OnPreRender() call.
|
|
//void registerNodeForRendering(ISceneNode* node, ESceneNodeRenderTime time = SNRT_DEFAULT) = 0;
|
|
|
|
/// <summary>
|
|
/// Draws all the scene nodes. This can only be invoked between
|
|
/// IVideoDriver::BeginScene() and IVideoDriver::EndScene().
|
|
/// </summary>
|
|
void DrawAll();
|
|
|
|
/// <summary>
|
|
/// Creates a rotation animator, which rotates the attached scene node around itself.
|
|
/// </summary>
|
|
/// <param name="rotationPerSecond"> Specifies the speed of the animation </param>
|
|
/// <returns> Returns the animator. Attach it to a scene node with ISceneNode::AddAnimator()
|
|
/// and the animator will animate it.</returns>
|
|
ISceneNodeAnimator* CreateRotationAnimator(Core::Vector3D rotationPerSecond);
|
|
|
|
/// <summary>
|
|
/// Creates a fly circle animator, which lets the attached scene node fly
|
|
/// around a center.
|
|
/// </summary>
|
|
/// <param name="center"> Center of the circle.</param>
|
|
/// <param name="radius"> Radius of the circle.</param>
|
|
/// <param name="speed"> Specifies the speed of the flight. Default: 0.001f</param>
|
|
/// <returns> Returns the animator. Attach it to a scene node with ISceneNode::addAnimator()
|
|
/// and the animator will animate it.
|
|
/// </returns>
|
|
ISceneNodeAnimator* CreateFlyCircleAnimator( Core::Vector3D center,
|
|
float radius, float speed);
|
|
|
|
/// <summary>
|
|
/// Creates a fly straight animator, which lets the attached scene node
|
|
/// fly or move along a line between two points.
|
|
/// </summary>
|
|
/// <param name="startPoint"> Start point of the line.</param>
|
|
/// <param name="endPoint"> End point of the line.</param>
|
|
/// <param name="timeForWay"> Time in milli seconds how long the node should need to
|
|
/// move from the start point to the end point.</param>
|
|
/// <param name="loop"> If set to false, the node stops when the end point is reached.
|
|
/// If loop is true, the node begins again at the start.</param>
|
|
/// <returns> Returns the animator. Attach it to a scene node with ISceneNode::addAnimator()
|
|
/// and the animator will animate it.</returns>
|
|
ISceneNodeAnimator* CreateFlyStraightAnimator( Core::Vector3D startPoint,
|
|
Core::Vector3D endPoint, int timeForWay, bool loop);
|
|
|
|
/// <summary>
|
|
/// Creates a texture animator, which switches the textures of the target scene
|
|
/// node based on a list of textures.
|
|
/// </summary>
|
|
/// <param name="textures"> List of textures to use.</param>
|
|
/// <param name="timePerFrame"> Time in milliseconds, how long any texture in the list
|
|
/// should be visible.</param>
|
|
/// <param name="loop"> If set to to false, the last texture remains set, and the animation
|
|
/// stops. If set to true, the animation restarts with the first texture.</param>
|
|
/// <returns> Returns the animator. Attach it to a scene node with ISceneNode::addAnimator()
|
|
/// and the animator will animate it.</returns>
|
|
ISceneNodeAnimator* CreateTextureAnimator( Video::ITexture* textures[],
|
|
int timePerFrame, bool loop);
|
|
|
|
/// <summary>
|
|
/// Creates a scene node animator, which deletes the scene node after
|
|
/// some time automaticly.
|
|
/// </summary>
|
|
/// <param name="when"> Time in milliseconds, after when the node will be deleted.</param>
|
|
/// <returns> Returns the animator. Attach it to a scene node with ISceneNode::addAnimator()
|
|
/// and the animator will animate it.</returns>
|
|
ISceneNodeAnimator* CreateDeleteAnimator(int timeMs);
|
|
|
|
/// <summary>
|
|
/// Creates a special scene node animator for doing automatic collision detection
|
|
/// and response. See ISceneNodeAnimatorCollisionResponse for details.
|
|
/// </summary>
|
|
/// <param name="world"> Triangle selector holding all triangles of the world with which
|
|
/// the scene node may collide. You can create a triangle selector with
|
|
/// ISceneManager::createTriangleSelector();</param>
|
|
/// <param name="sceneNode"> SceneNode which should be manipulated. After you added this animator
|
|
/// to the scene node, the scene node will not be able to move through walls and is
|
|
/// affected by gravity.</param>
|
|
/// <param name="ellipsoidRadius"> Radius of the ellipsoid with which collision detection and
|
|
/// response is done. </param>
|
|
/// <param name="gravityPerSecond"> Sets the gravity of the environment. A good example value would be
|
|
/// Core::Vector3D(0,-100.0f,0) for letting gravity affect all object to
|
|
/// fall down. For bigger gravity, make increase the length of the vector.
|
|
/// You can disable gravity by setting it to Core::Vector3D(0,0,0).</param>
|
|
/// <param name="ellipsoidTranslation"> By default, the ellipsoid for collision detection is created around
|
|
/// the center of the scene node, which means that the ellipsoid surrounds
|
|
/// it completely. If this is not what you want, you may specify a translation
|
|
/// for the ellipsoid.</param>
|
|
/// <param name="slidingValue">Value for sliding, default: 0.0005f</param>
|
|
/// <returns> Returns the animator. Attach it to a scene node with ISceneNode::addAnimator()
|
|
/// and the animator will cause it to do collision detection and response.
|
|
/// </returns>
|
|
ISceneNodeAnimator* CreateCollisionResponseAnimator(
|
|
ITriangleSelector* world, ISceneNode* sceneNode,
|
|
Core::Vector3D ellipsoidRadius,
|
|
Core::Vector3D gravityPerSecond,
|
|
Core::Vector3D ellipsoidTranslation,
|
|
float slidingValue);
|
|
|
|
/// <summary>
|
|
/// Creates a follow spline animator. The animator modifies the position of
|
|
/// the attached scene node to make it follow a hermite spline.
|
|
/// The code of the is based on a scene node
|
|
/// Matthias Gall sent in. Thanks! I adapted the code just a little bit. Matthias
|
|
/// wrote:
|
|
/// Uses a subset of hermite splines: either cardinal splines (tightness != 0.5) or catmull-rom-splines (tightness == 0.5)
|
|
/// but this is just my understanding of this stuff, I'm not a mathematician, so this might be wrong ;)
|
|
/// </summary>
|
|
ISceneNodeAnimator* CreateFollowSplineAnimator(int startTime,
|
|
Core::Vector3D points[],
|
|
float speed, float tightness);
|
|
|
|
/// <summary>
|
|
/// Creates a simple ITriangleSelector, based on a mesh. Triangle selectors
|
|
/// can be used for doing collision detection. Don't use this selector
|
|
/// for a huge amount of triangles like in Quake3 maps.
|
|
/// Instead, use for example ISceneManager::createOctTreeTriangleSelector().
|
|
/// Please note that the created triangle selector is not automaticly attached
|
|
/// to the scene node. You will have to call ISceneNode::setTriangleSelector()
|
|
/// for this.
|
|
/// </summary>
|
|
/// <param name="mesh"> Mesh of which the triangles are taken.</param>
|
|
/// <param name="node"> Scene node of which visibility and transformation is used.</param>
|
|
/// <returns> Returns the selector, or null if not successful.
|
|
/// If you no longer need the selector, you should call ITriangleSelector::drop().</returns>
|
|
ITriangleSelector* CreateTriangleSelector(IMesh* mesh, ISceneNode* node);
|
|
|
|
/// <summary>
|
|
/// Creates a simple dynamic ITriangleSelector, based on a axis aligned bounding box. Triangle selectors
|
|
/// can be used for doing collision detection. Every time when triangles are
|
|
/// queried, the triangle selector gets the bounding box of the scene node,
|
|
/// an creates new triangles. In this way, it works good with animated scene nodes.
|
|
/// </summary>
|
|
/// <param name="node"> Scene node of which the bounding box, visibility and
|
|
/// transformation is used.</param>
|
|
/// <returns> Returns the selector, or null if not successful.</param>
|
|
ITriangleSelector* CreateTriangleSelectorFromBoundingBox(ISceneNode* node);
|
|
|
|
/// <summary>
|
|
/// Creates a simple ITriangleSelector, based on a mesh. Triangle selectors
|
|
/// can be used for doing collision detection. This triangle selector is
|
|
/// optimized for huge amounts of triangle, it organizes them in an octtree.
|
|
/// Please note that the created triangle selector is not automaticly attached
|
|
/// to the scene node. You will have to call ISceneNode::setTriangleSelector()
|
|
/// for this.
|
|
/// </summary>
|
|
/// <param name="mesh"> Mesh of which the triangles are taken.</param>
|
|
/// <param name="node"> Scene node of which visibility and transformation is used.</param>
|
|
/// <param name="minimalPolysPerNode"> Specifies the minimal polygons contained a octree node.
|
|
/// If a node gets less polys the this value, it will not be splitted into
|
|
/// smaller nodes. Defaukt value: 32</param>
|
|
/// <returns> Returns the selector, or null if not successful.</returns>
|
|
ITriangleSelector* CreateOctTreeTriangleSelector(IMesh* mesh,
|
|
ISceneNode* node, int minimalPolysPerNode);
|
|
|
|
/// <summary>
|
|
/// Creates a meta triangle selector which is nothing more than a
|
|
/// collection of one or more triangle selectors providing together
|
|
/// the interface of one triangle selector. In this way,
|
|
/// collision tests can be done with different triangle soups in one pass.
|
|
/// </summary>
|
|
/// <returns> Returns the selector, or null if not successful.</returns>
|
|
IMetaTriangleSelector* CreateMetaTriangleSelector();
|
|
|
|
/// <summary>
|
|
/// Creates a triangle selector which can select triangles from a terrain scene node.
|
|
/// </summary>
|
|
/// <param name="node">Pointer to the created terrain scene node</param>
|
|
/// <param name="LOD">Level of detail, 0 for highest detail.</param>
|
|
ITriangleSelector* CreateTerrainTriangleSelector(
|
|
ITerrainSceneNode* node, int LOD);
|
|
|
|
/// <summary>
|
|
/// Returns a pointer to the scene collision manager.
|
|
/// </summary>
|
|
__property ISceneCollisionManager* get_SceneCollisionManager();
|
|
|
|
/// <summary>
|
|
/// Adds an external mesh loader. If you want the engine to be extended with
|
|
/// file formats it currently is not able to load (e.g. .cob), just implement
|
|
/// the IMeshLoader interface in your loading class and add it with this method.
|
|
/// </summary>
|
|
/// <param name="externalLoader"/> Implementation of a new mesh loader.</param>
|
|
// void addExternalMeshLoader(IMeshLoader* externalLoader) = 0;
|
|
|
|
/// <summary>
|
|
/// Returns a pointer to the mesh manipulator.
|
|
/// </summary>
|
|
__property IMeshManipulator* get_MeshManipulator();
|
|
|
|
/// <summary>
|
|
/// Adds a scene node to the deletion queue. The scene node is immediatly
|
|
/// deleted when it's secure. Which means when the scene node does not
|
|
/// execute animators and things like that. This method is for example
|
|
/// used for deleting scene nodes by their scene node animators. In
|
|
/// most other cases, a ISceneNode::remove() call is enough, using this
|
|
/// deletion queue is not necessary.
|
|
/// See ISceneManager::createDeleteAnimator() for details.
|
|
/// </summary>
|
|
/// <param name="node"> Node to detete.</param>
|
|
//void addToDeletionQueue(ISceneNode* node) = 0;
|
|
|
|
/// <summary>
|
|
/// Posts an input event to the environment. Usually you do not have to
|
|
/// use this method, it is used by the internal engine.
|
|
/// </summary>
|
|
// bool postEventFromUser(SEvent event) = 0;
|
|
|
|
/// <summary>
|
|
/// Clears the whole scene. All scene nodes are removed.
|
|
/// </summary>
|
|
void Clear();
|
|
|
|
/// <summary>
|
|
/// Loads a scene from an .irr file, the Irrlicht editor file format.
|
|
/// </summary>
|
|
void LoadScene(System::String* filename);
|
|
|
|
/// <summary>
|
|
/// Saves a scene to an .irr file, the Irrlicht editor file format.
|
|
/// </summary>
|
|
void SaveScene(System::String* filename);
|
|
|
|
private:
|
|
|
|
irr::scene::ISceneManager* Manager;
|
|
ISceneCollisionManager* SCM;
|
|
IMeshManipulator* Manipulator;
|
|
ISceneNode* Root;
|
|
};
|
|
|
|
}
|
|
}
|