Description

Runtime visualization with Irrlicht.

This module can be used to provide 3D realtime rendering in Chrono::Engine.

For additional information, see:

Namespaces

 chrono::irrlicht
 Namespace with classes for the Irrlicht module.
 

Classes

class  chrono::irrlicht::ChBodySceneNode
 Irrlicht scene node for a body. More...
 
class  chrono::irrlicht::ChIrrApp
 Class to add some GUI to Irrlicht+Chrono::Engine applications. More...
 
class  chrono::irrlicht::ChIrrAppInterface
 Class to add some GUI to Irrlicht + Chrono::Engine applications. More...
 
class  chrono::irrlicht::ChIrrAssetConverter
 Class with static functions which allow creation of Irrlicht frequent 'scene nodes' like lights, camera, sky box etc. More...
 
class  chrono::irrlicht::RTSCamera
 Class to create an interactive videocamera in Irrlicht, that is similar to the Maya camera but hasn't the problems that the Maya camera has in Irrlicht 1.5. More...
 
class  chrono::irrlicht::CShaderPreprocessor
 CShaderPreprocessor. More...
 
class  chrono::irrlicht::DepthShaderCB
 DepthShaderCB. More...
 
class  chrono::irrlicht::ShadowShaderCB
 ShadowShaderCB. More...
 
class  chrono::irrlicht::ScreenQuadCB
 ScreenQuadCB. More...
 
class  chrono::irrlicht::CScreenQuad
 CScreenQuad. More...
 
class  chrono::irrlicht::EffectHandler
 Main effect handling class, use this to apply shadows and effects. More...
 
class  chrono::irrlicht::ChIrrNode
 Class for Irrlicht visualization. More...
 
class  chrono::irrlicht::ChIrrNodeAsset
 Class for adding Irrlicht visualization to a ChPhysicsItem. More...
 
class  chrono::irrlicht::ChIrrNodeProxyToAsset
 Class for proxy to ChAsset, it is a node with mesh in Irrlicht system and a shared pointer to the ChAsset to whom it corresponds. More...
 
class  chrono::irrlicht::ChIrrParticlesSceneNode
 Definition of an Irrlicht scene node for particles. More...
 
class  chrono::irrlicht::ChIrrTools
 Class with static functions which help with the integration of Chrono::Engine and Irrlicht 3D rendering library. More...
 
class  chrono::irrlicht::ChIrrWizard
 Class with static functions which allow creation of Irrlicht frequent 'scene nodes' like lights, camera, sky box etc. More...
 

Enumerations

enum  E_SHADER_EXTENSION { ESE_GLSL, ESE_HLSL, ESE_COUNT }
 
enum  chrono::irrlicht::E_SHADOW_MODE {
  ESM_RECEIVE, ESM_CAST, ESM_BOTH, ESM_EXCLUDE,
  ESM_COUNT
}
 Shadow mode enums, sets whether a node recieves shadows, casts shadows, or both. More...
 
enum  chrono::irrlicht::E_FILTER_TYPE {
  EFT_NONE, EFT_4PCF, EFT_8PCF, EFT_12PCF,
  EFT_16PCF, EFT_COUNT
}
 Various filter types, up to 16 samples PCF.
 

Functions

ChApiIrr irr::scene::ISceneNode * chrono::irrlicht::addChBodySceneNode (ChSystem *asystem, irr::scene::ISceneManager *amanager, irr::scene::IAnimatedMesh *amesh, double mmass=1.0, const ChVector<> &position=ChVector<>(0, 0, 0), const ChQuaternion<> &rotation=ChQuaternion<>(1, 0, 0, 0), irr::scene::ISceneNode *aparent=0, irr::s32 mid=-1)
 Easy-to-use function which creates a ChBodySceneNode with given position of COG, inserts it into the Irrlicht scene etc. More...
 
ChApiIrr irr::scene::ISceneNode * chrono::irrlicht::addChBodySceneNode_offsetCOG (ChSystem *asystem, irr::scene::ISceneManager *amanager, irr::scene::IAnimatedMesh *amesh, double mmass=1.0, const ChVector<> &mesh_position=ChVector<>(0, 0, 0), const ChQuaternion<> &rotation=ChQuaternion<>(1, 0, 0, 0), const ChVector<> &COG_offset=ChVector<>(0, 0, 0), irr::scene::ISceneNode *aparent=0, irr::s32 mid=-1)
 Same as above, but allow user to specify an offset distance between COG and mesh location. More...
 
ChApiIrr irr::scene::ISceneNode * chrono::irrlicht::addChBodySceneNode_easySphere (ChSystem *asystem, irr::scene::ISceneManager *amanager, double mmass=1.0, const ChVector<> &position=ChVector<>(0, 0, 0), double mradius=1.0, int Hslices=15, int Vslices=8, irr::scene::ISceneNode *aparent=0, irr::s32 mid=-1)
 Easy-to-use function which creates a ChBodySceneNode representing a sphere, ready to use for collisions (otherwise you could use addChBodySceneNode() and add collision geometry by hand, but the following is easier). More...
 
ChApiIrr irr::scene::ISceneNode * chrono::irrlicht::addChBodySceneNode_easyBox (ChSystem *asystem, irr::scene::ISceneManager *amanager, double mmass=1.0, const ChVector<> &position=ChVector<>(0, 0, 0), const ChQuaternion<> &rotation=ChQuaternion<>(1, 0, 0, 0), const ChVector<> &size=ChVector<>(1, 1, 1), irr::scene::ISceneNode *aparent=0, irr::s32 mid=-1)
 Easy-to-use function which creates a ChBodySceneNode representing a box, ready to use for collisions (otherwise you could use addChBodySceneNode() and add collision geometry by hand, but the following is easier). More...
 
ChApiIrr irr::scene::ISceneNode * chrono::irrlicht::addChBodySceneNode_easyCylinder (ChSystem *asystem, irr::scene::ISceneManager *amanager, double mmass=1.0, const ChVector<> &position=ChVector<>(0, 0, 0), const ChQuaternion<> &rotation=ChQuaternion<>(1, 0, 0, 0), const ChVector<> &size=ChVector<>(1, 1, 1), irr::scene::ISceneNode *aparent=0, irr::s32 mid=-1)
 Easy-to-use function which creates a ChBodySceneNode representing a cylinder, ready to use for collisions (otherwise you could use addChBodySceneNode() and add collision geometry by hand, but the following is easier). More...
 
ChApiIrr irr::scene::ISceneNode * chrono::irrlicht::addChBodySceneNode_easyBarrel (ChSystem *asystem, irr::scene::ISceneManager *amanager, double mmass=1.0, const ChVector<> &position=ChVector<>(0, 0, 0), double mradiusH=1.0, double mradiusV=1.0, double mYlow=-0.5, double mYhigh=0.8, double mOffset=0.0, int Hslices=15, int Vslices=10, irr::scene::ISceneNode *aparent=0, irr::s32 mid=-1)
 Easy-to-use function which creates a ChBodySceneNode representing a barrel, ready to use for collisions (otherwise you could use addChBodySceneNode() and add collision geometry by hand, but the following is easier). More...
 
ChApiIrr irr::scene::ISceneNode * chrono::irrlicht::addChBodySceneNode_easyClone (ChSystem *asystem, irr::scene::ISceneManager *amanager, ChBodySceneNode *source, const ChVector<> &position=ChVector<>(0, 0, 0), const ChQuaternion<> &rotation=ChQuaternion<>(1, 0, 0, 0), irr::scene::ISceneNode *aparent=0, irr::s32 mid=-1)
 Easy-to-use function that creates a ChBodySceneNode representing a clone of another ChBodySceneNode, but at a different position and rotation. More...
 
ChApiIrr irr::scene::ISceneNode * chrono::irrlicht::addChBodySceneNode_easyGenericMesh (ChSystem *asystem, irr::scene::ISceneManager *amanager, double mmass=1.0, const ChVector<> &position=ChVector<>(0, 0, 0), const ChQuaternion<> &rotation=ChQuaternion<>(1, 0, 0, 0), const char *mesh_filemane=0, bool is_static=true, bool is_convex=true, irr::scene::ISceneNode *aparent=0, irr::s32 mid=-1)
 Easy-to-use function which creates a ChBodySceneNode representing a GENERIC mesh of arbitrary shape, loaded from file using the Irrlicht formats (.obj, .3ds, .X, etc) ready to use for collisions. More...
 
ChApiIrr irr::scene::ISceneNode * chrono::irrlicht::addChBodySceneNode_easyStaticMesh (ChSystem *asystem, irr::scene::ISceneManager *amanager, const char *mesh_filename, const ChVector<> &position=ChVector<>(0, 0, 0), const ChQuaternion<> &rotation=ChQuaternion<>(1, 0, 0, 0), irr::scene::ISceneNode *aparent=0, irr::s32 mid=-1)
 Easy-to-use function which creates a ChBodySceneNode representing a STATIC shape, as a mesh loaded from file using the Irrlicht formats (.obj, .3ds, .X, etc). More...
 
ChApiIrr irr::scene::ISceneNode * chrono::irrlicht::addChBodySceneNode_easyConvexMesh (ChSystem *asystem, irr::scene::ISceneManager *amanager, const char *mesh_filename, double mmass, const ChVector<> &position=ChVector<>(0, 0, 0), const ChQuaternion<> &rotation=ChQuaternion<>(1, 0, 0, 0), irr::scene::ISceneNode *aparent=0, irr::s32 mid=-1)
 Easy-to-use function which creates a ChBodySceneNode representing a CONVEX shape, as a mesh loaded from file using the Irrlicht formats (.obj, .3ds, .X, etc). More...
 
ChApiIrr irr::scene::ISceneNode * chrono::irrlicht::addChBodySceneNode_easyConcaveMesh (ChSystem *asystem, irr::scene::ISceneManager *amanager, const char *mesh_filename, double mmass, const ChVector<> &position=ChVector<>(0, 0, 0), const ChQuaternion<> &rotation=ChQuaternion<>(1, 0, 0, 0), irr::scene::ISceneNode *aparent=0, irr::s32 mid=-1)
 Easy-to-use function which creates a ChBodySceneNode representing a CONCAVE shape, as a mesh loaded from file using the Irrlicht formats (.obj, .3ds, .X, etc). More...
 
irr::core::array< SDefineExp > chrono::irrlicht::grabDefineExpressions (irr::core::stringc &shaderProgram)
 
std::string chrono::irrlicht::getFileContent (const std::string pFile)
 
ChApiIrr
irr::scene::IAnimatedMesh * 
chrono::irrlicht::createEllipticalMesh (irr::f32 radiusH, irr::f32 radiusV, irr::f32 Ylow, irr::f32 Yhigh, irr::f32 offset, irr::u32 polyCountX, irr::u32 polyCountY)
 Some functions to allow easy creation of meshes for Irrlicht visualization.
 
IMesh * chrono::irrlicht::createCubeMesh (const irr::core::vector3df &size)
 Same as irr::CGeomentryCreator::createCubeMesh(), but with no shared normals between faces. More...
 
ChApiIrr irr::scene::IMesh * chrono::irrlicht::createCylinderMesh (irr::f32 radius, irr::f32 length, irr::u32 tesselation)
 Same as irr::CGeomentryCreator::createCylinderMesh(), but with no shared normals between caps and hull.
 
ChApiIrr void chrono::irrlicht::fillChTrimeshFromIrlichtMesh (geometry::ChTriangleMesh *chTrimesh, irr::scene::IMesh *pMesh)
 This function is based on a modified version of the irrlicht_bullet demo, see http://www.continuousphysics.com It is used to convert an Irrlicht mesh into a ChTriangleMesh, which is used for collision detection in Chrono::Engine. More...
 
ChApiIrr void chrono::irrlicht::fillIrlichtMeshFromChTrimesh (irr::scene::IMesh *pMesh, geometry::ChTriangleMesh *chTrimesh, irr::video::SColor clr=irr::video::SColor(255, 255, 255, 255))
 Given a ChTriangleMesh object, computes an Irrlicht mesh. More...
 
ChApiIrr irr::scene::ISceneNode * chrono::irrlicht::addChParticlesSceneNode (ChSystem *asystem, irr::scene::ISceneManager *amanager, irr::scene::IAnimatedMesh *amesh, irr::core::vector3df amesh_scale, double mmass=1.0, irr::scene::ISceneNode *aparent=0, irr::s32 mid=-1)
 Easy-to-use function which creates a ChIrrParticlesSceneNode and inserts it into the Irrlicht scene. More...
 
ChApiIrr irr::scene::ISceneNode * chrono::irrlicht::addChParticlesSceneNode_easySpheres (ChSystem *asystem, irr::scene::ISceneManager *amanager, double mmass=1.0, double mradius=1.0, int Hslices=12, int Vslices=6, irr::scene::ISceneNode *aparent=0, irr::s32 mid=-1)
 Easy-to-use function which creates a ChIrrParticlesSceneNode representing a cluster of particles, ready to use for collisions (otherwise you could use addChBodySceneNode() and add collision geometry by hand, but the following is easier). More...
 
 chrono::irrlicht::CShaderPreprocessor::CShaderPreprocessor (irr::video::IVideoDriver *driverIn)
 
void chrono::irrlicht::CShaderPreprocessor::addShaderDefine (const irr::core::stringc name, const irr::core::stringc value="")
 
void chrono::irrlicht::CShaderPreprocessor::removeShaderDefine (const irr::core::stringc name)
 
irr::core::stringc chrono::irrlicht::CShaderPreprocessor::ppShader (irr::core::stringc shaderProgram)
 PreProcesses a shader using Irrlicht's built-in shader preprocessor.
 
irr::core::stringc chrono::irrlicht::CShaderPreprocessor::ppShaderFF (irr::core::stringc shaderProgram)
 PreProcesses a shader using Irrlicht's built-in shader preprocessor.
 
 chrono::irrlicht::EffectHandler::EffectHandler (irr::IrrlichtDevice *irrlichtDevice, const irr::core::dimension2du &screenRTTSize=irr::core::dimension2du(0, 0), const bool useVSMShadows=false, const bool useRoundSpotLights=false, const bool use32BitDepthBuffers=false)
 
 chrono::irrlicht::EffectHandler::~EffectHandler ()
 Destructor.
 
void chrono::irrlicht::EffectHandler::setScreenRenderTargetResolution (const irr::core::dimension2du &resolution)
 Sets a new screen render target resolution.
 
void chrono::irrlicht::EffectHandler::enableDepthPass (bool enableDepthPass)
 Enables/disables an additional pass before applying post processing effects (If there are any) which records screen depth info to the depth buffer for use with post processing effects that require screen depth info, such as SSAO or DOF. More...
 
void chrono::irrlicht::EffectHandler::addPostProcessingEffect (irr::s32 MaterialType, IPostProcessingRenderCallback *callback=0)
 A very easy to use post processing function. More...
 
void chrono::irrlicht::EffectHandler::addShadowToNode (irr::scene::ISceneNode *node, E_FILTER_TYPE filterType=EFT_NONE, E_SHADOW_MODE shadowMode=ESM_BOTH)
 Adds a shadow to the scene node. More...
 
void chrono::irrlicht::EffectHandler::addNodeToDepthPass (irr::scene::ISceneNode *node)
 This function is now unrelated to shadow mapping. More...
 
void chrono::irrlicht::EffectHandler::removeNodeFromDepthPass (irr::scene::ISceneNode *node)
 This function is now unrelated to shadow mapping. More...
 
void chrono::irrlicht::EffectHandler::update (irr::video::ITexture *outputTarget=0)
 Updates the effects handler. More...
 
irr::video::ITexture * chrono::irrlicht::EffectHandler::getShadowMapTexture (const irr::u32 resolution, const bool secondary=false)
 Retrieves the shadow map texture for the specified square shadow map resolution. More...
 
irr::video::ITexture * chrono::irrlicht::EffectHandler::generateRandomVectorTexture (const irr::core::dimension2du &dimensions, const irr::core::stringc &name="randVec")
 Generates a randomized texture composed of uniformly distributed 3 dimensional vectors.
 
void chrono::irrlicht::EffectHandler::setPostProcessingEffectConstant (const irr::s32 materialType, const irr::core::stringc &name, const irr::f32 *data, const irr::u32 count)
 Sets a shader parameter for a post-processing effect. More...
 
irr::s32 chrono::irrlicht::EffectHandler::addPostProcessingEffectFromFile (const irr::core::stringc &filename, IPostProcessingRenderCallback *callback=0)
 Adds a post processing effect by reading a pixel shader from a file. More...
 
virtual void chrono::irrlicht::ScreenQuadCB::OnSetConstants (irr::video::IMaterialRendererServices *services, irr::s32 userData)
 

Variables

const char *const chrono::irrlicht::LIGHT_MODULATE_P [ESE_COUNT]
 
const char *const chrono::irrlicht::SHADOW_PASS_1P [ESE_COUNT]
 
const char *const chrono::irrlicht::SHADOW_PASS_1PT [ESE_COUNT]
 
const char *const chrono::irrlicht::SHADOW_PASS_1V [ESE_COUNT]
 
const char *const chrono::irrlicht::SHADOW_PASS_2P [ESE_COUNT]
 
const char *const chrono::irrlicht::SHADOW_PASS_2V [ESE_COUNT]
 
const char *const chrono::irrlicht::SIMPLE_P [ESE_COUNT]
 
const char *const chrono::irrlicht::WHITE_WASH_P [ESE_COUNT]
 
const char *const chrono::irrlicht::WHITE_WASH_P_ADD [ESE_COUNT]
 
const char *const chrono::irrlicht::SCREEN_QUAD_V [ESE_COUNT]
 
const char *const chrono::irrlicht::VSM_BLUR_P [ESE_COUNT]
 

Enumeration Type Documentation

Shadow mode enums, sets whether a node recieves shadows, casts shadows, or both.

If the mode is ESM_CAST, it will not be affected by shadows or lighting.

Function Documentation

ChApiIrr irr::scene::ISceneNode* chrono::irrlicht::addChBodySceneNode ( ChSystem *  asystem,
irr::scene::ISceneManager *  amanager,
irr::scene::IAnimatedMesh *  amesh,
double  mmass = 1.0,
const ChVector<> &  position = ChVector<>(0, 0, 0),
const ChQuaternion<> &  rotation = ChQuaternion<>(1, 0, 0, 0),
irr::scene::ISceneNode *  aparent = 0,
irr::s32  mid = -1 
)

Easy-to-use function which creates a ChBodySceneNode with given position of COG, inserts it into the Irrlicht scene etc.

ChApiIrr irr::scene::ISceneNode* chrono::irrlicht::addChBodySceneNode_easyBarrel ( ChSystem *  asystem,
irr::scene::ISceneManager *  amanager,
double  mmass = 1.0,
const ChVector<> &  position = ChVector<>(0, 0, 0),
double  mradiusH = 1.0,
double  mradiusV = 1.0,
double  mYlow = -0.5,
double  mYhigh = 0.8,
double  mOffset = 0.0,
int  Hslices = 15,
int  Vslices = 10,
irr::scene::ISceneNode *  aparent = 0,
irr::s32  mid = -1 
)

Easy-to-use function which creates a ChBodySceneNode representing a barrel, ready to use for collisions (otherwise you could use addChBodySceneNode() and add collision geometry by hand, but the following is easier).

The returned object has collision detection turned ON by default.

ChApiIrr irr::scene::ISceneNode* chrono::irrlicht::addChBodySceneNode_easyBox ( ChSystem *  asystem,
irr::scene::ISceneManager *  amanager,
double  mmass = 1.0,
const ChVector<> &  position = ChVector<>(0, 0, 0),
const ChQuaternion<> &  rotation = ChQuaternion<>(1, 0, 0, 0),
const ChVector<> &  size = ChVector<>(1, 1, 1),
irr::scene::ISceneNode *  aparent = 0,
irr::s32  mid = -1 
)

Easy-to-use function which creates a ChBodySceneNode representing a box, ready to use for collisions (otherwise you could use addChBodySceneNode() and add collision geometry by hand, but the following is easier).

The returned object has collision detection turned ON by default.

ChApiIrr irr::scene::ISceneNode* chrono::irrlicht::addChBodySceneNode_easyClone ( ChSystem *  asystem,
irr::scene::ISceneManager *  amanager,
ChBodySceneNode *  source,
const ChVector<> &  position = ChVector<>(0, 0, 0),
const ChQuaternion<> &  rotation = ChQuaternion<>(1, 0, 0, 0),
irr::scene::ISceneNode *  aparent = 0,
irr::s32  mid = -1 
)

Easy-to-use function that creates a ChBodySceneNode representing a clone of another ChBodySceneNode, but at a different position and rotation.

NOTE! the collision shapes (if any) in the source object will be shared with the cloned object, so if you have to create for exampe 1000 identical objects (ex. cubes) this function will allow you to replicate 999 times a single cube that you once created calling addChBodySceneNode_easyBox(): this will be more memory-efficient than calling many times the function addChBodySceneNode_easyBox(). Shared geometries will be deallocated automatically thank to shared pointers.

ChApiIrr irr::scene::ISceneNode* chrono::irrlicht::addChBodySceneNode_easyConcaveMesh ( ChSystem *  asystem,
irr::scene::ISceneManager *  amanager,
const char *  mesh_filename,
double  mmass,
const ChVector<> &  position = ChVector<>(0, 0, 0),
const ChQuaternion<> &  rotation = ChQuaternion<>(1, 0, 0, 0),
irr::scene::ISceneNode *  aparent = 0,
irr::s32  mid = -1 
)

Easy-to-use function which creates a ChBodySceneNode representing a CONCAVE shape, as a mesh loaded from file using the Irrlicht formats (.obj, .3ds, .X, etc).

The mesh can be moving. The loaded mesh is used BOTH for display in Irrlicht 3d view and for collision. The returned object has collision detection turned ON by default. Works also for convex shapes, but the performance is not as fast and robust as in case of native convex cases, so whenever possible use addChBodySceneNode_easyConvexMesh.

ChApiIrr irr::scene::ISceneNode* chrono::irrlicht::addChBodySceneNode_easyConvexMesh ( ChSystem *  asystem,
irr::scene::ISceneManager *  amanager,
const char *  mesh_filename,
double  mmass,
const ChVector<> &  position = ChVector<>(0, 0, 0),
const ChQuaternion<> &  rotation = ChQuaternion<>(1, 0, 0, 0),
irr::scene::ISceneNode *  aparent = 0,
irr::s32  mid = -1 
)

Easy-to-use function which creates a ChBodySceneNode representing a CONVEX shape, as a mesh loaded from file using the Irrlicht formats (.obj, .3ds, .X, etc).

The mesh can be moving. If mesh is not concave or has holes/gaps, its convex hull is used anyway. Best used with simple meshes, not too many points. The loaded mesh is used BOTH for display in Irrlicht 3d view and for collision. The returned object has collision detection turned ON by default.

ChApiIrr irr::scene::ISceneNode* chrono::irrlicht::addChBodySceneNode_easyCylinder ( ChSystem *  asystem,
irr::scene::ISceneManager *  amanager,
double  mmass = 1.0,
const ChVector<> &  position = ChVector<>(0, 0, 0),
const ChQuaternion<> &  rotation = ChQuaternion<>(1, 0, 0, 0),
const ChVector<> &  size = ChVector<>(1, 1, 1),
irr::scene::ISceneNode *  aparent = 0,
irr::s32  mid = -1 
)

Easy-to-use function which creates a ChBodySceneNode representing a cylinder, ready to use for collisions (otherwise you could use addChBodySceneNode() and add collision geometry by hand, but the following is easier).

The returned object has collision detection turned ON by default.

ChApiIrr irr::scene::ISceneNode* chrono::irrlicht::addChBodySceneNode_easyGenericMesh ( ChSystem *  asystem,
irr::scene::ISceneManager *  amanager,
double  mmass = 1.0,
const ChVector<> &  position = ChVector<>(0, 0, 0),
const ChQuaternion<> &  rotation = ChQuaternion<>(1, 0, 0, 0),
const char *  mesh_filemane = 0,
bool  is_static = true,
bool  is_convex = true,
irr::scene::ISceneNode *  aparent = 0,
irr::s32  mid = -1 
)

Easy-to-use function which creates a ChBodySceneNode representing a GENERIC mesh of arbitrary shape, loaded from file using the Irrlicht formats (.obj, .3ds, .X, etc) ready to use for collisions.

The loaded mesh is used BOTH for display in Irrlicht 3d view and for collision. The returned object has collision detection turned ON by default.

ChApiIrr irr::scene::ISceneNode* chrono::irrlicht::addChBodySceneNode_easySphere ( ChSystem *  asystem,
irr::scene::ISceneManager *  amanager,
double  mmass = 1.0,
const ChVector<> &  position = ChVector<>(0, 0, 0),
double  mradius = 1.0,
int  Hslices = 15,
int  Vslices = 8,
irr::scene::ISceneNode *  aparent = 0,
irr::s32  mid = -1 
)

Easy-to-use function which creates a ChBodySceneNode representing a sphere, ready to use for collisions (otherwise you could use addChBodySceneNode() and add collision geometry by hand, but the following is easier).

The returned object has collision detection turned ON by default.

ChApiIrr irr::scene::ISceneNode* chrono::irrlicht::addChBodySceneNode_easyStaticMesh ( ChSystem *  asystem,
irr::scene::ISceneManager *  amanager,
const char *  mesh_filename,
const ChVector<> &  position = ChVector<>(0, 0, 0),
const ChQuaternion<> &  rotation = ChQuaternion<>(1, 0, 0, 0),
irr::scene::ISceneNode *  aparent = 0,
irr::s32  mid = -1 
)

Easy-to-use function which creates a ChBodySceneNode representing a STATIC shape, as a mesh loaded from file using the Irrlicht formats (.obj, .3ds, .X, etc).

The mesh can be either convex or concave: it works anyway (but it should NOT move!) The loaded mesh is used BOTH for display in Irrlicht 3d view and for collision. The returned object has collision detection turned ON by default. The returned object is fixed by default (no need to do SetBodyFixed(true) ).

ChApiIrr irr::scene::ISceneNode* chrono::irrlicht::addChBodySceneNode_offsetCOG ( ChSystem *  asystem,
irr::scene::ISceneManager *  amanager,
irr::scene::IAnimatedMesh *  amesh,
double  mmass = 1.0,
const ChVector<> &  mesh_position = ChVector<>(0, 0, 0),
const ChQuaternion<> &  rotation = ChQuaternion<>(1, 0, 0, 0),
const ChVector<> &  COG_offset = ChVector<>(0, 0, 0),
irr::scene::ISceneNode *  aparent = 0,
irr::s32  mid = -1 
)

Same as above, but allow user to specify an offset distance between COG and mesh location.

Note: the mesh remains in the same location, but the COG of the rigid body changes by the offset amount.

ChApiIrr irr::scene::ISceneNode* chrono::irrlicht::addChParticlesSceneNode ( ChSystem *  asystem,
irr::scene::ISceneManager *  amanager,
irr::scene::IAnimatedMesh *  amesh,
irr::core::vector3df  amesh_scale,
double  mmass = 1.0,
irr::scene::ISceneNode *  aparent = 0,
irr::s32  mid = -1 
)

Easy-to-use function which creates a ChIrrParticlesSceneNode and inserts it into the Irrlicht scene.

ChApiIrr irr::scene::ISceneNode* chrono::irrlicht::addChParticlesSceneNode_easySpheres ( ChSystem *  asystem,
irr::scene::ISceneManager *  amanager,
double  mmass = 1.0,
double  mradius = 1.0,
int  Hslices = 12,
int  Vslices = 6,
irr::scene::ISceneNode *  aparent = 0,
irr::s32  mid = -1 
)

Easy-to-use function which creates a ChIrrParticlesSceneNode representing a cluster of particles, ready to use for collisions (otherwise you could use addChBodySceneNode() and add collision geometry by hand, but the following is easier).

The returned object has collision detection turned ON by default.

void chrono::irrlicht::EffectHandler::addNodeToDepthPass ( irr::scene::ISceneNode *  node)

This function is now unrelated to shadow mapping.

It simply adds a node to the screen space depth map render, for use with post processing effects that require screen depth info. If you want the functionality of the old method (A node that only casts but does not recieve shadows, use addShadowToNode with the ESM_CAST shadow mode.

void chrono::irrlicht::EffectHandler::addPostProcessingEffect ( irr::s32  MaterialType,
IPostProcessingRenderCallback *  callback = 0 
)

A very easy to use post processing function.

Simply add a material type to apply to the screen as a post processing effect and it will be applied. You can add as many material types as you desire, and they will be double buffered and executed in sequance.

For the material types, I recommend using "ScreenQuadCB" as the callback and refering to the texture names that are passed (When using OpenGL, in DirectX uniforms are not required to bind textures). Please note that this will only work in OpenGL on vanilla Irrlicht, DX requires the large RTT patch to be able to create sufficiently sized rendertargets for post processing. (Or you can just remove the engine check for Pow2).

The structure of the textures is as follows:

Texture1 - "ColorMapSampler" This is passed on from the previous post processing effect as they are executed in sequance. For example, if you do a horizontal blur on the first post processing material, then a vertical blur in the second material, you will use this sampler to access the post processed data of the horizontal blur when it is time to do the vertical blur. If accessed from the first post processing material, it will just contain the untainted screen map data.

Texture2 - "ScreenMapSampler" The second texture will always contain the untainted screen map data, from when the scene is first rendered. It will remain unchanged no matter how many post processing materials are applied. This kind of data is necessary, for example in bloom or DOF, you would require a copy of the blurred scene data and a copy of the normal untainted, unblurred screen data, and mix between them based on certain factors such as depth or luminance.

Texture3 - "DepthMapSampler" If a depth pass has been enabled using enableDepthPass, then this sampler will contain the screen space depth information. For better quality this is encoded to 16bits, and can be decoded like so: Texture.red + (Texture.green / 256.0f); That is by adding the red channel to the green channel which is first divided by 256. The data can still be used without decoding, in 8 bit precision, by just accessing the red component of the texture. Though this is not recommended as 8 bit precision is usually not sufficient for modern post processing effects.

Texture4 - "UserMapSampler" A custom texture that can be set by the user using setPostProcessingUserTexture(irr::video::ITexture* userTexture).

The last parameter is the render callback, you may pass 0 if you do not need one. Please see IPostProcessingRenderCallback for more info about this callback.

irr::s32 chrono::irrlicht::EffectHandler::addPostProcessingEffectFromFile ( const irr::core::stringc &  filename,
IPostProcessingRenderCallback *  callback = 0 
)

Adds a post processing effect by reading a pixel shader from a file.

The vertex shader is taken care of. The vertex shader will pass the correct screen quad texture coordinates via the TEXCOORD0 semantic in Direct3D or the gl_TexCoord[0] varying in OpenGL. See addPostProcessingEffect for more info. Returns the Irrlicht material type of the post processing effect.

void chrono::irrlicht::EffectHandler::addShadowToNode ( irr::scene::ISceneNode *  node,
E_FILTER_TYPE  filterType = EFT_NONE,
E_SHADOW_MODE  shadowMode = ESM_BOTH 
)

Adds a shadow to the scene node.

The filter type specifies how many shadow map samples to take, a higher value can produce a smoother or softer result. The shadow mode can be either ESM_BOTH, ESM_CAST, or ESM_RECEIVE. ESM_BOTH casts and receives shadows, ESM_CAST only casts shadows, and is unaffected by shadows or lighting, and ESM_RECEIVE only receives but does not cast shadows.

ChApiIrr irr::scene::IMesh * chrono::irrlicht::createCubeMesh ( const irr::core::vector3df &  size)

Same as irr::CGeomentryCreator::createCubeMesh(), but with no shared normals between faces.

void chrono::irrlicht::EffectHandler::enableDepthPass ( bool  enableDepthPass)

Enables/disables an additional pass before applying post processing effects (If there are any) which records screen depth info to the depth buffer for use with post processing effects that require screen depth info, such as SSAO or DOF.

For nodes to be rendered in this pass, they must first be added using addNodeToDepthPass(SceneNode).

ChApiIrr void chrono::irrlicht::fillChTrimeshFromIrlichtMesh ( geometry::ChTriangleMesh *  chTrimesh,
irr::scene::IMesh *  pMesh 
)

This function is based on a modified version of the irrlicht_bullet demo, see http://www.continuousphysics.com It is used to convert an Irrlicht mesh into a ChTriangleMesh, which is used for collision detection in Chrono::Engine.

ChApiIrr void chrono::irrlicht::fillIrlichtMeshFromChTrimesh ( irr::scene::IMesh *  pMesh,
geometry::ChTriangleMesh *  chTrimesh,
irr::video::SColor  clr = irr::video::SColor(255, 255, 255, 255) 
)

Given a ChTriangleMesh object, computes an Irrlicht mesh.

Note: the ChTriangleMesh is a 'triangle soup', so no connectivity is used. As a consequence, no Gourad/Phong shading is possible and all triangles will look flat.

***OBSOLETE***

irr::video::ITexture * chrono::irrlicht::EffectHandler::getShadowMapTexture ( const irr::u32  resolution,
const bool  secondary = false 
)

Retrieves the shadow map texture for the specified square shadow map resolution.

Only one shadow map is kept for each resolution, so if multiple lights are using the same resolution, you will only see the last light drawn's output. The secondary param specifies whether to retrieve the secondary shadow map used in blurring.

void chrono::irrlicht::ScreenQuadCB::OnSetConstants ( irr::video::IMaterialRendererServices *  services,
irr::s32  userData 
)
virtual

Version for Irrlicht 1.7.3

void chrono::irrlicht::EffectHandler::removeNodeFromDepthPass ( irr::scene::ISceneNode *  node)

This function is now unrelated to shadow mapping.

It simply removes a node to the screen space depth map render, for use with post processing effects that require screen depth info.

void chrono::irrlicht::EffectHandler::setPostProcessingEffectConstant ( const irr::s32  materialType,
const irr::core::stringc &  name,
const irr::f32 *  data,
const irr::u32  count 
)

Sets a shader parameter for a post-processing effect.

The first parameter is the material type, the second is the uniform paratmeter name, the third is a float pointer that points to the data and the last is the component count of the data. Please note that the float pointer must remain valid during render time. To disable the setting of a parameter you may simply pass a null float pointer.

void chrono::irrlicht::EffectHandler::update ( irr::video::ITexture *  outputTarget = 0)

Updates the effects handler.

This must be done between IVideoDriver::beginScene and IVideoDriver::endScene. This function now replaces smgr->drawAll(). So place it where smgr->drawAll() would normally go. Please note that the clear colour from IVideoDriver::beginScene is not preserved, so you must instead specify the clear colour using EffectHandler::setClearColour(Colour). A render target may be passed as the output target, else rendering will commence on the backbuffer.

Variable Documentation

const char* const chrono::irrlicht::LIGHT_MODULATE_P[ESE_COUNT]
Initial value:
= {
"uniform sampler2D ColorMapSampler;\n"
"uniform sampler2D ScreenMapSampler;\n"
""
"void main() "
"{ "
" vec4 finalCol = texture2D(ColorMapSampler, gl_TexCoord[0].xy);\n"
" vec4 lightCol = texture2D(ScreenMapSampler, gl_TexCoord[0].xy);\n"
""
" gl_FragColor = finalCol * lightCol;\n"
"}",
"sampler2D ColorMapSampler : register(s0);\n"
"sampler2D ScreenMapSampler : register(s1);\n"
""
"float4 pixelMain(float2 TexCoords : TEXCOORD0) : COLOR0"
"{ "
" float4 finalCol = tex2D(ColorMapSampler, TexCoords);\n"
" float4 lightCol = tex2D(ScreenMapSampler, TexCoords);\n"
""
" return finalCol * lightCol;\n"
"}"}
const char* const chrono::irrlicht::SHADOW_PASS_1P[ESE_COUNT]
Initial value:
= {
"void main() "
"{"
" vec4 vInfo = gl_TexCoord[0];\n"
" float depth = vInfo.z / vInfo.x;\n"
" gl_FragColor = vec4(depth, depth * depth, 0.0, 0.0);\n"
"}",
"float4 pixelMain(float4 ClipPos: TEXCOORD0) : COLOR0"
"{"
" float depth = ClipPos.z / ClipPos.x;\n"
" return float4(depth, depth * depth, 0.0, 0.0);\n"
"}"}
const char* const chrono::irrlicht::SHADOW_PASS_1PT[ESE_COUNT]
Initial value:
= {
"uniform sampler2D ColorMapSampler;\n"
""
"void main() "
"{"
" vec4 vInfo = gl_TexCoord[0];\n"
""
" float depth = vInfo.z / vInfo.x;\n"
""
" float alpha = texture2D(ColorMapSampler, gl_TexCoord[1].xy).a;\n"
""
" gl_FragColor = vec4(depth, depth * depth, 0.0, alpha);\n"
"}",
"sampler2D ColorMapSampler : register(s0);\n"
""
"float4 pixelMain(float4 Color: TEXCOORD0, float2 Texcoords: TEXCOORD1) : COLOR0"
"{"
" float depth = Color.z / Color.w;\n"
" "
" float alpha = tex2D(ColorMapSampler, Texcoords).a;\n"
" "
" return float4(depth, depth * depth, 0.0, alpha);\n"
"}"}
const char* const chrono::irrlicht::SIMPLE_P[ESE_COUNT]
Initial value:
= {
"uniform sampler2D ColorMapSampler;\n"
""
"void main() "
"{ "
" vec4 finalCol = texture2D(ColorMapSampler, gl_TexCoord[0].xy);\n"
" gl_FragColor = finalCol;\n"
"}",
"sampler2D ColorMapSampler : register(s0);\n"
""
"float4 pixelMain(float2 TexCoords : TEXCOORD0) : COLOR0"
"{ "
" float4 finalCol = tex2D(ColorMapSampler, TexCoords);\n"
" return finalCol;\n"
"}"}
const char* const chrono::irrlicht::WHITE_WASH_P[ESE_COUNT]
Initial value:
= {
"uniform sampler2D ColorMapSampler;\n"
""
"void main() "
"{"
" float alpha = texture2D(ColorMapSampler, gl_TexCoord[1].xy).a;\n"
""
" gl_FragColor = vec4(1.0, 1.0, 1.0, alpha);\n"
"}",
"sampler2D ColorMapSampler : register(s0);\n"
""
"float4 pixelMain(float4 Color: TEXCOORD0, float2 Texcoords: TEXCOORD1) : COLOR0"
"{"
" float alpha = tex2D(ColorMapSampler, Texcoords).a;\n"
""
" return float4(1.0, 1.0, 1.0, alpha);\n"
"}"}
const char* const chrono::irrlicht::WHITE_WASH_P_ADD[ESE_COUNT]
Initial value:
= {
"uniform sampler2D ColorMapSampler;\n"
"float luminance(vec3 color)"
"{"
" return clamp(color.r * 0.3 + color.g * 0.59 + color.b * 0.11, 0.0, 1.0);\n"
"}"
"void main() "
"{"
" vec4 diffuseTex = texture2D(ColorMapSampler, gl_TexCoord[1].xy);\n"
" //diffuseTex *= gl_TexCoord[2];\n"
""
" gl_FragColor = vec4(1.0, 1.0, 1.0, luminance(diffuseTex.rgb));\n"
"}",
"sampler2D ColorMapSampler : register(s0);\n"
""
"float luminance(float3 color)"
"{"
" return clamp(color.r * 0.3 + color.g * 0.59 + color.b * 0.11, 0.0, 1.0);\n"
"}"
""
"float4 pixelMain(float4 Color : TEXCOORD0, float2 Texcoords : TEXCOORD1, float4 VColor : TEXCOORD2) : COLOR0"
"{"
" float4 diffuseTex = tex2D(ColorMapSampler, Texcoords);\n"
" diffuseTex *= VColor;\n"
""
" return float4(1.0, 1.0, 1.0, luminance(diffuseTex.rgb));\n"
"}"}