From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a03350.html | 5831 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 5831 insertions(+) create mode 100644 docs/doxygen/nel/a03350.html (limited to 'docs/doxygen/nel/a03350.html') diff --git a/docs/doxygen/nel/a03350.html b/docs/doxygen/nel/a03350.html new file mode 100644 index 00000000..d535048e --- /dev/null +++ b/docs/doxygen/nel/a03350.html @@ -0,0 +1,5831 @@ + + +NeL: NL3D::CSceneUser class Reference + + + +
+

NL3D::CSceneUser Class Reference

#include <scene_user.h> +

+

Inheritance diagram for NL3D::CSceneUser: +

+ +NL3D::UScene + +

Detailed Description

+
Author:
Lionel Berenguier

+Nevrax France

+
Date:
2001
+ +

+ +

+Definition at line 62 of file scene_user.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Types

LoadBalancing mgt.
enum  TPolygonBalancingMode { PolygonBalancingOff = 0, +PolygonBalancingOn, +PolygonBalancingClamp, +CountPolygonBalancing + }
Profiling and Render Filtering
enum  TRenderFilter {
+  FilterLandscape = 0x00000001, +FilterWater = 0x00000002, +FilterMeshNoVP = 0x00000004, +FilterMeshVP = 0x00000008, +
+  FilterMeshMRMNoVP = 0x00000010, +FilterMeshMRMVP = 0x00000020, +FilterMeshLodNoVP = 0x00000040, +FilterMeshLodVP = 0x00000080, +
+  FilterSkeleton = 0x00000100, +FilterSegRemanence = 0x00000200, +FilterPS = 0x00000400, +FilterFlare = 0x00000800, +
+  FilterCoarseMesh = 0x00001000, +FilterAllMeshNoVP = FilterMeshNoVP + FilterMeshMRMNoVP + FilterMeshLodNoVP, +FilterAllMeshVP = FilterMeshVP + FilterMeshMRMVP + FilterMeshLodVP, +FilterAllMesh = FilterAllMeshNoVP+FilterAllMeshVP, +
+  FilterFX = FilterSegRemanence + FilterPS + FilterFlare +
+ }

Public Member Functions

IWaterSurfaceAddedCallbackgetWaterCallback () const
void setWaterCallback (IWaterSurfaceAddedCallback *wcb)
Render
virtual void animate (TGlobalAnimationTime time)
virtual void render ()
virtual void updateWaitingInstances (double ellapsedTime)
Animation gestion.
virtual UAnimationSetcreateAnimationSet (const std::string &animationSetFile)
 Create a new AnimationSet, load it from a file. Use CPath to search the animation set. exception EPathNotFound if not found.

virtual UAnimationSetcreateAnimationSet ()
 Create an empty AnimationSet.

virtual UPlayListManagercreatePlayListManager ()
 Create a new PlayListManager.

virtual void deleteAnimationSet (UAnimationSet *animationSet)
 Delete a AnimationSet.

virtual void deletePlayListManager (UPlayListManager *playListManager)
 Delete a PlayListManager.

virtual void setAutomaticAnimationSet (UAnimationSet *as)
Component Mgt.
virtual UCameracreateCamera ()
 Create a camera. Usefull for this scene only.

virtual UCloudScapecreateCloudScape ()
 Create a landscape. There could be many Landscape per Scene (Driver? :). But never tested :).

virtual UInstancecreateInstance (const std::string &shapeName)
virtual void createInstanceAsync (const std::string &shapeName, UInstance **ppInstance, const NLMISC::CVector &position, uint selectedTexture)
virtual void createInstanceGroupAndAddToSceneAsync (const std::string &instanceGroup, UInstanceGroup **pIG, const NLMISC::CVector &pos, const NLMISC::CQuat &rot, uint selectedTexture, IAsyncLoadCallback *pCB=NULL)
virtual ULandscapecreateLandscape ()
 Create a landscape. There could be many Landscape per Scene (Driver? :). But never tested :).

virtual UPointLightcreatePointLight ()
 Create a dynamic PointLight. Usefull for this scene only.

virtual USkeletoncreateSkeleton (const std::string &shapeName)
virtual UTransformcreateTransform ()
virtual void deleteCamera (UCamera *cam)
 Delete a camera.

virtual void deleteCloudScape (UCloudScape *cs)
 delete a landscape.

virtual void deleteInstance (UInstance *inst)
virtual void deleteInstanceGroup (UInstanceGroup *pIG)
virtual void deleteLandscape (ULandscape *land)
 delete a landscape.

virtual void deletePointLight (UPointLight *light)
 Delete a dynamic PointLight.

virtual void deleteSkeleton (USkeleton *skel)
virtual void deleteTransform (UTransform *tr)
virtual void setToGlobalInstanceGroup (UInstanceGroup *pIG)
virtual void stopCreatingAndAddingIG (UInstanceGroup **pIG)
void updateWaitingIG ()
 should be called at each render

Visual Collision manager.
virtual UVisualCollisionManagercreateVisualCollisionManager ()
virtual void deleteVisualCollisionManager (UVisualCollisionManager *mgr)
Object
 CSceneUser (CDriverUser *drv, bool bSmallScene)
virtual ~CSceneUser ()
CLod / Character Lod mgt
virtual void deleteCLodShapeBank (uint32 bankId)
 delete a Shape Bank. No-op if bad id.

virtual sint32 getCLodAnimIdByName (uint32 shapeId, const std::string &name) const
virtual sint32 getCLodShapeIdByName (const std::string &name) const
virtual uint32 loadCLodShapeBank (const std::string &fileName)
virtual void resetCLodManager ()
 reset the manager.

Profiling and Render Filtering
virtual void enableElementRender (TRenderFilter elt, bool state)
virtual void getProfileResults (CBenchResults &results)
 get The result of the profiling.

virtual void profileNextRender ()
 Enable Profiling for the next render(). Reset All stats.

virtual void profileQuadGridClipManager ()
Global light setup.
virtual void enableLightingSystem (bool enable)
virtual NLMISC::CRGBA getAmbientGlobal () const
 get the global Ambient used for the scene. Default to (50, 50, 50).

virtual float getLightTransitionThreshold () const
 getLightTransitionThreshold()

virtual uint getMaxLightContribution () const
 setMaxLightContribution()

virtual NLMISC::CRGBA getSunAmbient () const
 get the Ambient of the Sun used for the scene.

virtual NLMISC::CRGBA getSunDiffuse () const
 get the Diffuse of the Sun used for the scene.

virtual NLMISC::CVector getSunDirection () const
 get the Direction of the Sun used for the scene.

virtual NLMISC::CRGBA getSunSpecular () const
 get the Specular of the Sun used for the scene.

virtual void setAmbientGlobal (NLMISC::CRGBA ambient)
 set the global Ambient used for the scene. Default to (50, 50, 50).

virtual void setLightGroupColor (uint lightmapGroup, NLMISC::CRGBA color)
 set the color of a light group.

virtual void setLightTransitionThreshold (float lightTransitionThreshold)
virtual void setMaxLightContribution (uint nlights)
virtual void setSunAmbient (NLMISC::CRGBA ambient)
 set the Ambient of the Sun used for the scene.

virtual void setSunDiffuse (NLMISC::CRGBA diffuse)
 set the Diffuse of the Sun used for the scene.

virtual void setSunDirection (const NLMISC::CVector &direction)
 set the Direction of the Sun used for the scene.

virtual void setSunSpecular (NLMISC::CRGBA specular)
 set the Specular of the Sun used for the scene.

ShadowMapping Options
virtual void enableShadowPolySmooth (bool enable)
 Enable Polygon Smoothing.

virtual bool getEnableShadowPolySmooth () const
 get Enable Polygon Smoothing flag

virtual uint getShadowMapBlurSize () const
 get the size of the blur (<=3 means number of fakeBlur).

virtual float getShadowMapDistFadeEnd () const
 Enable Polygon Smoothing.

virtual float getShadowMapDistFadeStart () const
 Enable Polygon Smoothing.

virtual uint getShadowMapMaxCasterAround () const
 Enable Polygon Smoothing.

virtual uint getShadowMapMaxCasterInScreen () const
 Enable Polygon Smoothing.

virtual float getShadowMapMaxDepth () const
 return the current ShadowMap Max Depth. This is the length in the lightDir direction where the shadow can touch receivers

virtual uint getShadowMapTextureSize () const
 return the current base ShadowMap TextureSize. Default is 64 texels.

virtual void setShadowMapBlurSize (uint bs)
 set the size of the blur (<=3 means number of fakeBlur).

virtual void setShadowMapDistFadeEnd (float dist)
 ShadowMap Distance Fade end (50 default).

virtual void setShadowMapDistFadeStart (float dist)
 ShadowMap Distance Fade Start (40 default).

virtual void setShadowMapMaxCasterAround (uint num)
 ShadowMap max Caster Around (optimize memory).

virtual void setShadowMapMaxCasterInScreen (uint num)
 ShadowMap max Caster In Screen (optimize CPU/GPU).

virtual void setShadowMapMaxDepth (float depth)
 set the ShadowMap Extent

virtual void setShadowMapTextureSize (uint size)
 must be a power of 2.

Camera/Viewport.
virtual void findCameraClusterSystemFromRay (UCamera *cam, UInstanceGroup *startClusterSystem, const NLMISC::CVector &startPos, const NLMISC::CVector &endPos)
virtual UCameragetCam ()
 Get the current camera.

virtual CViewport getViewport ()
 Get the current Viewport.

virtual void setCam (UCamera *cam)
 Set the current camera for this scene. nlError if NULL, or if the camera was not created by this UScene.

virtual void setViewport (const class CViewport &viewport)
 Set the current Viewport.

Coarse meshes mgt.
virtual uint8 getCoarseMeshLightingUpdate () const
 see setCoarseMeshLightingUpdate()

virtual void setCoarseMeshLightingUpdate (uint8 period)
virtual void setCoarseMeshManagerTexture (const char *sPath)
Flare contexts
virtual uint getFlareContext () const
virtual uint getNumFlareContexts () const
virtual void setFlareContext (uint context)
Weather mgt
virtual const NLMISC::CVectorgetGlobalWindDirection () const
 get the current windDirection

virtual float getGlobalWindPower () const
 get the current windPower

virtual void setGlobalWindDirection (const NLMISC::CVector &gwd)
 Set the current windDirection for all the scene. dir.z set to 0 and vector normalized.

virtual void setGlobalWindPower (float gwp)
 Set the current windPower for all the scene. 0-1.

LoadBalancing mgt.
virtual uint getGroupLoadMaxPolygon (const std::string &group)
virtual float getGroupNbFaceAsked (const std::string &group) const
virtual uint getMaxSkeletonsInNotCLodForm () const
 see setMaxSkeletonsInNotCLodForm()

virtual float getNbFaceAsked () const
virtual TPolygonBalancingMode getPolygonBalancingMode () const
 Get the PolygonBalancingMode.

virtual void setGroupLoadMaxPolygon (const std::string &group, uint nFaces)
virtual void setMaxSkeletonsInNotCLodForm (uint m)
virtual void setPolygonBalancingMode (TPolygonBalancingMode polBalMode)
 Set the PolygonBalancingMode.

transparent Layers mgt
virtual bool getLayersRenderingOrder () const
virtual void setLayersRenderingOrder (bool directOrder=true)
Accessor for CSceneUser.
CScenegetScene ()

Protected Types

typedef CPtrSet< CAnimationSetUserTAnimationSetSet
typedef CPtrSet< CCloudScapeUserTCloudScapeSet
typedef CPtrSet< CInstanceGroupUserTInstanceGroupSet
typedef CPtrSet< CLandscapeUserTLandscapeSet
typedef CPtrSet< CPlayListManagerUserTPlayListManagerSet
typedef CPtrSet< CTransformUserTTransformSet
typedef CPtrSet< CVisualCollisionManagerUserTVisualCollisionManagerSet
typedef std::list< CWaitingIGTWaitingIGList

Protected Attributes

TAnimationSetSet _AnimationSets
TCloudScapeSet _CloudScapes
CCameraUser_CurrentCamera
 The Current camera.

CDriverUser_DriverUser
 The driver which owns this scene.

TInstanceGroupSet _InstanceGroups
TLandscapeSet _Landscapes
TPlayListManagerSet _PlayListManagers
CScene _Scene
 The Scene.

TTransformSet _Transforms
TVisualCollisionManagerSet _VisualCollisionManagers
TWaitingIGList _WaitingIGs
std::map< UInstance **, CTransformShape * > _WaitingInstances

Private Member Functions

virtual void updateWaitingInstances ()
 update async loading during a call to render

+


Member Typedef Documentation

+

+ + + + +
+ + +
typedef CPtrSet<CAnimationSetUser> NL3D::CSceneUser::TAnimationSetSet [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 82 of file scene_user.h.

+

+ + + + +
+ + +
typedef CPtrSet<CCloudScapeUser> NL3D::CSceneUser::TCloudScapeSet [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 79 of file scene_user.h.

+

+ + + + +
+ + +
typedef CPtrSet<CInstanceGroupUser> NL3D::CSceneUser::TInstanceGroupSet [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 80 of file scene_user.h.

+

+ + + + +
+ + +
typedef CPtrSet<CLandscapeUser> NL3D::CSceneUser::TLandscapeSet [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 78 of file scene_user.h.

+

+ + + + +
+ + +
typedef CPtrSet<CPlayListManagerUser> NL3D::CSceneUser::TPlayListManagerSet [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 83 of file scene_user.h.

+

+ + + + +
+ + +
typedef CPtrSet<CTransformUser> NL3D::CSceneUser::TTransformSet [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 77 of file scene_user.h.

+

+ + + + +
+ + +
typedef CPtrSet<CVisualCollisionManagerUser> NL3D::CSceneUser::TVisualCollisionManagerSet [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 81 of file scene_user.h.

+

+ + + + +
+ + +
typedef std::list<CWaitingIG> NL3D::CSceneUser::TWaitingIGList [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 107 of file scene_user.h.

+


Member Enumeration Documentation

+

+ + + + +
+ + +
enum NL3D::UScene::TPolygonBalancingMode [inherited] +
+
+ + + + + +
+   + + +

+The mode of polygon balancing. NB: this apply to All LoadBalancingGroups, but the "Default" group which is always considered as PolygonBalancingOff PolygonBalancingOff => Models will be rendered with the number of faces they want to render. PolygonBalancingOn => Models will be rendered with the number of faces the LoadBalancing want. PolygonBalancingClamp => Same as PolygonBalancingOn, but factor <= 1, ie models won't be rendered with more face they want to render.

Enumeration values:
+ + + + + +
PolygonBalancingOff  +
PolygonBalancingOn  +
PolygonBalancingClamp  +
CountPolygonBalancing  +
+
+ +

+Definition at line 271 of file u_scene.h. +

+

+

+ + + + +
+ + +
enum NL3D::UScene::TRenderFilter [inherited] +
+
+ + + + + +
+   + + +

+

Enumeration values:
+ + + + + + + + + + + + + + + + + + +
FilterLandscape  +
FilterWater  +
FilterMeshNoVP  +
FilterMeshVP  +
FilterMeshMRMNoVP  +
FilterMeshMRMVP  +
FilterMeshLodNoVP  +
FilterMeshLodVP  +
FilterSkeleton  +
FilterSegRemanence  +
FilterPS  +
FilterFlare  +
FilterCoarseMesh  +
FilterAllMeshNoVP  +
FilterAllMeshVP  +
FilterAllMesh  +
FilterFX  +
+
+ +

+Definition at line 459 of file u_scene.h. +

+

00460         {
+00461                 FilterLandscape=        0x00000001,
+00462                 FilterWater=            0x00000002,
+00463                 FilterMeshNoVP=         0x00000004,
+00464                 FilterMeshVP=           0x00000008,
+00465                 FilterMeshMRMNoVP=      0x00000010,
+00466                 FilterMeshMRMVP=        0x00000020,
+00467                 FilterMeshLodNoVP=      0x00000040,
+00468                 FilterMeshLodVP=        0x00000080,
+00469                 FilterSkeleton=         0x00000100,                     // For skins, and also for sticked objects.
+00470                 FilterSegRemanence= 0x00000200,
+00471                 FilterPS=                       0x00000400,
+00472                 FilterFlare=            0x00000800,
+00473                 FilterCoarseMesh=       0x00001000,                     // Disable render of CoarseMesh (but not management through Meshs!)
+00474 
+00475                 // Combos:
+00476                 FilterAllMeshNoVP=      FilterMeshNoVP + FilterMeshMRMNoVP + FilterMeshLodNoVP,
+00477                 FilterAllMeshVP=        FilterMeshVP + FilterMeshMRMVP + FilterMeshLodVP,
+00478                 FilterAllMesh=          FilterAllMeshNoVP+FilterAllMeshVP,
+00479                 FilterFX=                       FilterSegRemanence + FilterPS + FilterFlare,
+00480         };
+
+


Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
NL3D::CSceneUser::CSceneUser CDriverUser drv,
bool  bSmallScene
+
+ + + + + +
+   + + +

+ +

+Definition at line 946 of file scene_user.cpp. +

+References _CurrentCamera, _DriverUser, createCamera(), NL3D::CDriverUser::getDriver(), NL3D::CScene::initDefaultRoots(), NL3D::CScene::initQuadGridClipManager(), NL3D_MEM_SCENE_INIT, nlassert, setCam(), NL3D::CScene::setDriver(), and NL3D::CScene::setViewport(). +

+

00946                                                          : _Scene(bSmallScene)
+00947 {
+00948         NL3D_MEM_SCENE_INIT
+00949         nlassert(drv);
+00950         _DriverUser= drv;
+00951         _CurrentCamera = NULL;
+00952 
+00953         // init default Roots.
+00954         _Scene.initDefaultRoots();
+00955 
+00956         // Set driver.
+00957         _Scene.setDriver(_DriverUser->getDriver());
+00958 
+00959         // Set viewport
+00960         _Scene.setViewport (CViewport());
+00961 
+00962         // init QuadGridClipManager
+00963         _Scene.initQuadGridClipManager ();
+00964 
+00965         // Create default camera, and active!!
+00966         setCam(createCamera());
+00967 }
+
+

+ + + + +
+ + + + + + + + + +
NL3D::CSceneUser::~CSceneUser  )  [virtual]
+
+ + + + + +
+   + + +

+ +

+Definition at line 969 of file scene_user.cpp. +

+References _CloudScapes, _CurrentCamera, _DriverUser, _Landscapes, _Transforms, _VisualCollisionManagers, NL3D::CPtrSet< T >::clear(), NL3D_MEM_SCENE, NL3D::CScene::release(), NL3D::CScene::setCam(), and NL3D::CScene::setDriver(). +

+

00970 {
+00971         NL3D_MEM_SCENE
+00972         _VisualCollisionManagers.clear();
+00973         _Transforms.clear();
+00974         _Landscapes.clear();
+00975         _CloudScapes.clear();
+00976         _Scene.release();
+00977         _Scene.setDriver(NULL);
+00978         _Scene.setCam(NULL);
+00979         _CurrentCamera= NULL;
+00980         _DriverUser= NULL;
+00981 }
+
+


Member Function Documentation

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::animate TGlobalAnimationTime  time  )  [virtual]
+
+ + + + + +
+   + + +

+Set the animation time for lightmap and Particle System animation. +

+Implements NL3D::UScene. +

+Definition at line 612 of file scene_user.cpp. +

+References NL3D::CScene::animate(), NL3D_HAUTO_RENDER_SCENE_ANIMATE, and NL3D::TGlobalAnimationTime. +

+

00613 {
+00614         NL_ALLOC_CONTEXT( 3dAnim )
+00615         NL3D_HAUTO_RENDER_SCENE_ANIMATE;
+00616 
+00617         _Scene.animate(time);
+00618 }
+
+

+ + + + +
+ + + + + + + + + + +
UAnimationSet * NL3D::CSceneUser::createAnimationSet const std::string &  animationSetFile  )  [virtual]
+
+ + + + + +
+   + + +

+Create a new AnimationSet, load it from a file. Use CPath to search the animation set. exception EPathNotFound if not found. +

+ +

+Implements NL3D::UScene. +

+Definition at line 85 of file scene_user.cpp. +

+References _AnimationSets, NL3D::CPtrSet< T >::insert(), NL3D_HAUTO_LOAD_ANIMSET, and NLMISC::CIFile::open(). +

+

00086 {
+00087         NL_ALLOC_CONTEXT( 3dAnmSt )
+00088         NL3D_HAUTO_LOAD_ANIMSET;
+00089 
+00090         NLMISC::CIFile  f;
+00091         // throw exception if not found.
+00092         std::string     path= CPath::lookup(animationSetFile);
+00093         f.open(path);
+00094         return _AnimationSets.insert(new CAnimationSetUser(f));
+00095 }
+
+

+ + + + +
+ + + + + + + + + +
virtual UAnimationSet* NL3D::CSceneUser::createAnimationSet  )  [virtual]
+
+ + + + + +
+   + + +

+Create an empty AnimationSet. +

+ +

+Implements NL3D::UScene.

+

+ + + + +
+ + + + + + + + + +
UCamera * NL3D::CSceneUser::createCamera  )  [virtual]
+
+ + + + + +
+   + + +

+Create a camera. Usefull for this scene only. +

+A Uscene is a factory of Instance/Landscape/Lights etc... +

+Implements NL3D::UScene. +

+Definition at line 678 of file scene_user.cpp. +

+References _Transforms, NL3D::CPtrSet< T >::insert(), NL3D_HAUTO_ELT_SCENE, and NL3D_MEM_SCENE. +

+Referenced by CSceneUser(). +

+

00679 {
+00680         NL3D_MEM_SCENE
+00681         NL3D_HAUTO_ELT_SCENE;
+00682 
+00683         // The component is auto added/deleted to _Scene in ctor/dtor.
+00684         return dynamic_cast<UCamera*>( _Transforms.insert(new CCameraUser(&_Scene)) );
+00685 }
+
+

+ + + + +
+ + + + + + + + + +
UCloudScape * NL3D::CSceneUser::createCloudScape  )  [virtual]
+
+ + + + + +
+   + + +

+Create a landscape. There could be many Landscape per Scene (Driver? :). But never tested :). +

+ +

+Implements NL3D::UScene. +

+Definition at line 873 of file scene_user.cpp. +

+References _CloudScapes, NL3D::CPtrSet< T >::insert(), NL3D_HAUTO_ELT_SCENE, and NL3D_MEM_CLOUDS. +

+

00874 {
+00875         NL3D_MEM_CLOUDS
+00876         NL3D_HAUTO_ELT_SCENE;
+00877 
+00878         // The component is auto added/deleted to _Scene in ctor/dtor.
+00879         return _CloudScapes.insert(new CCloudScapeUser(&_Scene));
+00880 }
+
+

+ + + + +
+ + + + + + + + + + +
UInstance * NL3D::CSceneUser::createInstance const std::string &  shapeName  )  [virtual]
+
+ + + + + +
+   + + +

+particle system

+mesh +

+Implements NL3D::UScene. +

+Definition at line 700 of file scene_user.cpp. +

+References _Transforms, NL3D::CScene::createInstance(), NL3D::CPtrSet< T >::insert(), NL3D_HAUTO_CREATE_INSTANCE, and NL3D_MEM_INSTANCE. +

+

00701 {
+00702         NL3D_MEM_INSTANCE
+00703         NL3D_HAUTO_CREATE_INSTANCE;
+00704 
+00705         CTransform      *model= _Scene.createInstance(shapeName);
+00706         // If not found, return NULL.
+00707         if(model==NULL)
+00708                 return NULL;
+00709 
+00710         // The component is auto added/deleted to _Scene in ctor/dtor.
+00711         if (dynamic_cast<CParticleSystemModel *>(model))
+00712         {
+00714                 return dynamic_cast<UInstance*>( _Transforms.insert(new CParticleSystemInstanceUser(&_Scene, model)) );
+00715         }
+00716         else
+00717         {
+00719                 return dynamic_cast<UInstance*>( _Transforms.insert(new CInstanceUser(&_Scene, model, true)) );
+00720         }
+00721 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::CSceneUser::createInstanceAsync const std::string &  shapeName,
UInstance **  ppInstance,
const NLMISC::CVector position,
uint  selectedTexture
[virtual]
+
+ + + + + +
+   + + +

+Same as createInstance but the instance is loaded asynchronously. You must poll to know if the instance if created by calling render() +

+Implements NL3D::UScene. +

+Definition at line 724 of file scene_user.cpp. +

+References NL3D::CScene::createInstanceAsync(), NL3D_HAUTO_CREATE_INSTANCE, NL3D_MEM_INSTANCE, and uint. +

+

00725 {
+00726         NL3D_MEM_INSTANCE
+00727         NL3D_HAUTO_CREATE_INSTANCE;
+00728 
+00729         _WaitingInstances[ppInstance] = NULL;
+00730         _Scene.createInstanceAsync(shapeName,&_WaitingInstances[ppInstance], position, selectedTexture);
+00731 //              CTransform      *model= _Scene.createInstance(shapeName);
+00732         // If not found, return NULL.
+00733 //              if(model==NULL)
+00734 //                      return NULL;
+00735 
+00736 //              if( dynamic_cast<CMeshInstance*>(model)==NULL )
+00737 //                      nlerror("UScene::createInstance(): shape is not a mesh");
+00738 
+00739         // The component is auto added/deleted to _Scene in ctor/dtor.
+00740 //              return dynamic_cast<UInstance*>( _Transforms.insert(new CInstanceUser(&_Scene, model)) );
+00741 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::CSceneUser::createInstanceGroupAndAddToSceneAsync const std::string &  instanceGroup,
UInstanceGroup **  pIG,
const NLMISC::CVector pos,
const NLMISC::CQuat rot,
uint  selectedTexture,
IAsyncLoadCallback pCB = NULL
[virtual]
+
+ + + + + +
+   + + +

+create an instance group asynchronously, and add it to a scene asynchronously once it has been loaded. The instance groups that must be added to the scene are checked at each render. The pIG pointer is filled once the instance group has been loaded and add to the scene +

+Implements NL3D::UScene. +

+Definition at line 753 of file scene_user.cpp. +

+References _WaitingIGs, NL3D_HAUTO_ASYNC_IG, NL3D_MEM_IG, and uint. +

+

00755 {
+00756         NL3D_MEM_IG
+00757         NL3D_HAUTO_ASYNC_IG;
+00758 
+00759         _WaitingIGs.push_front(CWaitingIG(pIG, pos, rot, selectedTexture, pCB));
+00760         UInstanceGroup::createInstanceGroupAsync(instanceGroup, &(_WaitingIGs.begin()->IGToLoad));
+00761         // this list updat will be performed at each render, see updateWaitingIG
+00762 }
+
+

+ + + + +
+ + + + + + + + + +
ULandscape * NL3D::CSceneUser::createLandscape  )  [virtual]
+
+ + + + + +
+   + + +

+Create a landscape. There could be many Landscape per Scene (Driver? :). But never tested :). +

+ +

+Implements NL3D::UScene. +

+Definition at line 856 of file scene_user.cpp. +

+References _Landscapes, NL3D::CPtrSet< T >::insert(), NL3D_HAUTO_ELT_SCENE, and NL3D_MEM_LANDSCAPE. +

+

00857 {
+00858         NL3D_MEM_LANDSCAPE
+00859         NL3D_HAUTO_ELT_SCENE;
+00860 
+00861         // The component is auto added/deleted to _Scene in ctor/dtor.
+00862         return _Landscapes.insert(new CLandscapeUser(&_Scene));
+00863 }
+
+

+ + + + +
+ + + + + + + + + +
UPlayListManager * NL3D::CSceneUser::createPlayListManager  )  [virtual]
+
+ + + + + +
+   + + +

+Create a new PlayListManager. +

+ +

+Implements NL3D::UScene. +

+Definition at line 118 of file scene_user.cpp. +

+References _PlayListManagers, NL3D::CPtrSet< T >::insert(), and NL3D_HAUTO_ELT_SCENE. +

+

00119 {
+00120         NL_ALLOC_CONTEXT( 3dAnim )
+00121         NL3D_HAUTO_ELT_SCENE;
+00122 
+00123         return _PlayListManagers.insert(new CPlayListManagerUser());
+00124 }
+
+

+ + + + +
+ + + + + + + + + +
UPointLight * NL3D::CSceneUser::createPointLight  )  [virtual]
+
+ + + + + +
+   + + +

+Create a dynamic PointLight. Usefull for this scene only. +

+ +

+Implements NL3D::UScene. +

+Definition at line 353 of file scene_user.cpp. +

+References _Transforms, NL3D::CScene::createModel(), NL3D::CPtrSet< T >::insert(), NL3D_HAUTO_ELT_SCENE, NL3D_MEM_LIGHT, and NL3D::PointLightModelId. +

+

00354 {
+00355         NL3D_MEM_LIGHT
+00356         NL3D_HAUTO_ELT_SCENE;
+00357 
+00358         CTransform      *model= _Scene.createModel(PointLightModelId);
+00359         // If not found, return NULL.
+00360         if(model==NULL)
+00361                 return NULL;
+00362 
+00363         // The component is auto added/deleted to _Scene in ctor/dtor.
+00364         return dynamic_cast<UPointLight*>( _Transforms.insert(new CPointLightUser(&_Scene, model)) );
+00365 }
+
+

+ + + + +
+ + + + + + + + + + +
USkeleton * NL3D::CSceneUser::createSkeleton const std::string &  shapeName  )  [virtual]
+
+ + + + + +
+   + + +

+Create a skeleton instance of the skeleton shape "shapename". If not present, try to load "shapename" via CPath. If fails (file not found), return NULL. nlerror if the file is not a skeleton shape file. +

+Implements NL3D::UScene. +

+Definition at line 830 of file scene_user.cpp. +

+References _Transforms, NL3D::CScene::createInstance(), NL3D::CPtrSet< T >::insert(), NL3D_HAUTO_CREATE_SKELETON, NL3D_MEM_SKELETON, and nlerror. +

+

00831 {
+00832         NL3D_MEM_SKELETON
+00833         NL3D_HAUTO_CREATE_SKELETON;
+00834 
+00835         CTransform      *model= _Scene.createInstance(shapeName);
+00836         // If not found, return NULL.
+00837         if(model==NULL)
+00838                 return NULL;
+00839 
+00840         if( dynamic_cast<CSkeletonModel*>(model)==NULL )
+00841                 nlerror("UScene::createSkeleton(): shape is not a skeletonShape");
+00842 
+00843         // The component is auto added/deleted to _Scene in ctor/dtor.
+00844         return dynamic_cast<USkeleton*>( _Transforms.insert(new CSkeletonUser(&_Scene, model)) );
+00845 }
+
+

+ + + + +
+ + + + + + + + + +
UTransform * NL3D::CSceneUser::createTransform  )  [virtual]
+
+ + + + + +
+   + + +

+Create a dummy object +

+Implements NL3D::UScene. +

+Definition at line 806 of file scene_user.cpp. +

+References _Transforms, NL3D::CScene::createModel(), NL3D::CPtrSet< T >::insert(), NL3D_HAUTO_ELT_SCENE, NL3D_MEM_SCENE, and NL3D::TransformId. +

+

00807 {
+00808         NL3D_MEM_SCENE
+00809         NL3D_HAUTO_ELT_SCENE;
+00810 
+00811         CTransform      *model= _Scene.createModel(TransformId);
+00812         // If not found, return NULL.
+00813         if(model==NULL)
+00814                 return NULL;
+00815 
+00816         // The component is auto added/deleted to _Scene in ctor/dtor.
+00817         return dynamic_cast<UTransform*>( _Transforms.insert(new CTransformUser(&_Scene, model, true)) );
+00818 }
+
+

+ + + + +
+ + + + + + + + + +
UVisualCollisionManager * NL3D::CSceneUser::createVisualCollisionManager  )  [virtual]
+
+ + + + + +
+   + + +

+ +

+Implements NL3D::UScene. +

+Definition at line 929 of file scene_user.cpp. +

+References _VisualCollisionManagers, NL3D::CPtrSet< T >::insert(), NL3D_HAUTO_ELT_SCENE, and NL3D_MEM_VISUAL_COLLISION. +

+

00930 {
+00931         NL3D_MEM_VISUAL_COLLISION
+00932         NL3D_HAUTO_ELT_SCENE;
+00933 
+00934         return _VisualCollisionManagers.insert(new CVisualCollisionManagerUser);
+00935 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::deleteAnimationSet UAnimationSet animationSet  )  [virtual]
+
+ + + + + +
+   + + +

+Delete a AnimationSet. +

+ +

+Implements NL3D::UScene. +

+Definition at line 97 of file scene_user.cpp. +

+References _AnimationSets, NL3D::CPtrSet< T >::erase(), and NL3D_HAUTO_ELT_SCENE. +

+

00098 {
+00099         NL_ALLOC_CONTEXT( 3dAnmSt )
+00100         NL3D_HAUTO_ELT_SCENE;
+00101 
+00102         _AnimationSets.erase((CAnimationSetUser*)animationSet, "deleteAnimationSet(): Bad AnimationSet ptr");
+00103 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::deleteCamera UCamera cam  )  [virtual]
+
+ + + + + +
+   + + +

+Delete a camera. +

+ +

+Implements NL3D::UScene. +

+Definition at line 686 of file scene_user.cpp. +

+References _CurrentCamera, _Transforms, NL3D::CPtrSet< T >::erase(), NL3D_HAUTO_ELT_SCENE, and NL3D_MEM_SCENE. +

+

00687 {
+00688         NL3D_MEM_SCENE
+00689         NL3D_HAUTO_ELT_SCENE;
+00690 
+00691         CCameraUser             *oldCam= dynamic_cast<CCameraUser*>(cam);
+00692         // Is this the current camera??
+00693         if(oldCam==_CurrentCamera)
+00694                 _CurrentCamera=NULL;
+00695 
+00696         // The component is auto added/deleted to _Scene in ctor/dtor.
+00697         _Transforms.erase(oldCam);
+00698 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::deleteCLodShapeBank uint32  bankId  )  [virtual]
+
+ + + + + +
+   + + +

+delete a Shape Bank. No-op if bad id. +

+ +

+Implements NL3D::UScene. +

+Definition at line 503 of file scene_user.cpp. +

+References NL3D::CLodCharacterManager::compile(), NL3D::CLodCharacterManager::deleteShapeBank(), NL3D::CScene::getLodCharacterManager(), NL3D_HAUTO_LOAD_LOD, NL3D_MEM_LOD, nlassert, and uint32. +

+

00504 {
+00505         NL3D_MEM_LOD
+00506         NL3D_HAUTO_LOAD_LOD;
+00507 
+00508         // DriverUser always setup the lod manager
+00509         nlassert(_Scene.getLodCharacterManager());
+00510 
+00511         // delete the bank
+00512         _Scene.getLodCharacterManager()->deleteShapeBank(bankId);
+00513 
+00514         // recompile the shape Map.
+00515         _Scene.getLodCharacterManager()->compile();
+00516 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::deleteCloudScape UCloudScape cs  )  [virtual]
+
+ + + + + +
+   + + +

+delete a landscape. +

+ +

+Implements NL3D::UScene. +

+Definition at line 881 of file scene_user.cpp. +

+References _CloudScapes, NL3D::CPtrSet< T >::erase(), and NL3D_MEM_CLOUDS. +

+

00882 {
+00883         NL3D_MEM_CLOUDS
+00884 
+00885         // The component is auto added/deleted to _Scene in ctor/dtor.
+00886         _CloudScapes.erase((CCloudScapeUser*) cs);
+00887 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::deleteInstance UInstance inst  )  [virtual]
+
+ + + + + +
+   + + +

+Delete an instance via his pointer. +

+Implements NL3D::UScene. +

+Definition at line 743 of file scene_user.cpp. +

+References _Transforms, NL3D::CPtrSet< T >::erase(), NL3D_HAUTO_ELT_SCENE, and NL3D_MEM_INSTANCE. +

+

00744 {
+00745         NL3D_MEM_INSTANCE
+00746         NL3D_HAUTO_ELT_SCENE;
+00747 
+00748         // The component is auto added/deleted to _Scene in ctor/dtor.
+00749         _Transforms.erase(dynamic_cast<CTransformUser*>(inst));
+00750 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::deleteInstanceGroup UInstanceGroup pIG  )  [virtual]
+
+ + + + + +
+   + + +

+Delete an instance group +

+Implements NL3D::UScene. +

+Definition at line 801 of file scene_user.cpp. +

+

00802 {
+00803         delete pIG;
+00804 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::deleteLandscape ULandscape land  )  [virtual]
+
+ + + + + +
+   + + +

+delete a landscape. +

+ +

+Implements NL3D::UScene. +

+Definition at line 864 of file scene_user.cpp. +

+References _Landscapes, NL3D::CPtrSet< T >::erase(), NL3D_HAUTO_ELT_SCENE, and NL3D_MEM_LANDSCAPE. +

+

00865 {
+00866         NL3D_MEM_LANDSCAPE
+00867         NL3D_HAUTO_ELT_SCENE;
+00868 
+00869         // The component is auto added/deleted to _Scene in ctor/dtor.
+00870         _Landscapes.erase((CLandscapeUser*) land);
+00871 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::deletePlayListManager UPlayListManager playListManager  )  [virtual]
+
+ + + + + +
+   + + +

+Delete a PlayListManager. +

+ +

+Implements NL3D::UScene. +

+Definition at line 126 of file scene_user.cpp. +

+References _PlayListManagers, NL3D::CPtrSet< T >::erase(), and NL3D_HAUTO_ELT_SCENE. +

+

00127 {
+00128         NL_ALLOC_CONTEXT( 3dAnim )
+00129         NL3D_HAUTO_ELT_SCENE;
+00130 
+00131         _PlayListManagers.erase((CPlayListManagerUser*)playListManager, "deletePlayListManager(): Bad PlayListManager ptr");
+00132 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::deletePointLight UPointLight light  )  [virtual]
+
+ + + + + +
+   + + +

+Delete a dynamic PointLight. +

+ +

+Implements NL3D::UScene. +

+Definition at line 367 of file scene_user.cpp. +

+References _Transforms, NL3D::CPtrSet< T >::erase(), NL3D_HAUTO_ELT_SCENE, and NL3D_MEM_LIGHT. +

+

00368 {
+00369         NL3D_MEM_LIGHT
+00370         NL3D_HAUTO_ELT_SCENE;
+00371 
+00372         // The component is auto added/deleted to _Scene in ctor/dtor.
+00373         _Transforms.erase(dynamic_cast<CTransformUser*>(light));
+00374 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::deleteSkeleton USkeleton skel  )  [virtual]
+
+ + + + + +
+   + + +

+Delete a skeleton instance via his pointer. +

+Implements NL3D::UScene. +

+Definition at line 846 of file scene_user.cpp. +

+References _Transforms, NL3D::CPtrSet< T >::erase(), NL3D_HAUTO_ELT_SCENE, and NL3D_MEM_SKELETON. +

+

00847 {
+00848         NL3D_MEM_SKELETON
+00849         NL3D_HAUTO_ELT_SCENE;
+00850 
+00851         // The component is auto added/deleted to _Scene in ctor/dtor.
+00852         _Transforms.erase(dynamic_cast<CTransformUser*>(skel));
+00853 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::deleteTransform UTransform tr  )  [virtual]
+
+ + + + + +
+   + + +

+Delete a dummy object +

+Implements NL3D::UScene. +

+Definition at line 820 of file scene_user.cpp. +

+References _Transforms, NL3D::CPtrSet< T >::erase(), NL3D_HAUTO_ELT_SCENE, and NL3D_MEM_SCENE. +

+

00821 {
+00822         NL3D_MEM_SCENE
+00823         NL3D_HAUTO_ELT_SCENE;
+00824 
+00825         // The component is auto added/deleted to _Scene in ctor/dtor.
+00826         _Transforms.erase(dynamic_cast<CTransformUser*>(tr));
+00827 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::deleteVisualCollisionManager UVisualCollisionManager mgr  )  [virtual]
+
+ + + + + +
+   + + +

+ +

+Implements NL3D::UScene. +

+Definition at line 936 of file scene_user.cpp. +

+References _VisualCollisionManagers, NL3D::CPtrSet< T >::erase(), NL3D_HAUTO_ELT_SCENE, and NL3D_MEM_VISUAL_COLLISION. +

+

00937 {
+00938         NL3D_MEM_VISUAL_COLLISION
+00939         NL3D_HAUTO_ELT_SCENE;
+00940 
+00941         _VisualCollisionManagers.erase(dynamic_cast<CVisualCollisionManagerUser*>(mgr));
+00942 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CSceneUser::enableElementRender TRenderFilter  elt,
bool  state
[virtual]
+
+ + + + + +
+   + + +

+Enable or disable some Models to be rendered (for profile). Default is ALL enabled NB: filtering is made at clip pass. Hence, much of the render processing is skipped (animDetail, light, lod, render) +

+Implements NL3D::UScene. +

+Definition at line 997 of file scene_user.cpp. +

+References NL3D::CScene::enableElementRender(). +

+

00998 {
+00999         _Scene.enableElementRender(elt, state);
+01000 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::enableLightingSystem bool  enable  )  [virtual]
+
+ + + + + +
+   + + +

+Enable Scene Lighting system. For backward compatibility, false by default. If false, all objects will take last driver 's light setup +

+Implements NL3D::UScene. +

+Definition at line 229 of file scene_user.cpp. +

+References NL3D::CScene::enableLightingSystem(), NL3D_HAUTO_UI_SCENE, and NL3D_MEM_LIGHT. +

+

00230 {
+00231         NL3D_MEM_LIGHT
+00232         NL3D_HAUTO_UI_SCENE;
+00233 
+00234         _Scene.enableLightingSystem(enable);
+00235 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::enableShadowPolySmooth bool  enable  )  [virtual]
+
+ + + + + +
+   + + +

+Enable Polygon Smoothing. +

+ +

+Implements NL3D::UScene. +

+Definition at line 1082 of file scene_user.cpp. +

+References NL3D::CScene::enableShadowPolySmooth(). +

+

01083 {
+01084         _Scene.enableShadowPolySmooth(enable);
+01085 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::CSceneUser::findCameraClusterSystemFromRay UCamera cam,
UInstanceGroup startClusterSystem,
const NLMISC::CVector startPos,
const NLMISC::CVector endPos
[virtual]
+
+ + + + + +
+   + + +

+Special For Camera Third person. Traverse the ClusterSystem with a Ray (clip through portals, cluster system hierarchy...), to find where could lies the camera at End point. As result, a camera->setClusterSystem() is done with the found cluster system +

+Implements NL3D::UScene. +

+Definition at line 658 of file scene_user.cpp. +

+References NL3D::CInstanceGroupUser::_InstanceGroup, NL3D::CScene::findCameraClusterSystemFromRay(), NL3D::CCameraUser::getCamera(), NL3D_HAUTO_UI_SCENE, and NL3D_MEM_SCENE. +

+

00660 {
+00661         NL3D_MEM_SCENE
+00662         NL3D_HAUTO_UI_SCENE;
+00663         
+00664         if(!cam)
+00665                 return;
+00666 
+00667         CCameraUser                     *ucam= dynamic_cast<CCameraUser*>(cam);
+00668         CInstanceGroupUser      *uig= dynamic_cast<CInstanceGroupUser*>(startClusterSystem);
+00669         CCamera                         *pCam= ucam->getCamera();
+00670         CInstanceGroup          *pIg= NULL;
+00671         if(uig)
+00672                 pIg= &uig->_InstanceGroup;
+00673 
+00674         _Scene.findCameraClusterSystemFromRay(pCam, pIg, startPos, endPos);
+00675 }
+
+

+ + + + +
+ + + + + + + + + +
NLMISC::CRGBA NL3D::CSceneUser::getAmbientGlobal  )  const [virtual]
+
+ + + + + +
+   + + +

+get the global Ambient used for the scene. Default to (50, 50, 50). +

+ +

+Implements NL3D::UScene. +

+Definition at line 283 of file scene_user.cpp. +

+References NL3D::CScene::getAmbientGlobal(), NL3D_HAUTO_UI_SCENE, and NL3D_MEM_LIGHT. +

+

00284 {
+00285         NL3D_MEM_LIGHT
+00286         NL3D_HAUTO_UI_SCENE;
+00287 
+00288         return _Scene.getAmbientGlobal();
+00289 }
+
+

+ + + + +
+ + + + + + + + + +
UCamera * NL3D::CSceneUser::getCam  )  [virtual]
+
+ + + + + +
+   + + +

+Get the current camera. +

+ +

+Implements NL3D::UScene. +

+Definition at line 636 of file scene_user.cpp. +

+References _CurrentCamera, NL3D_HAUTO_UI_SCENE, and NL3D_MEM_SCENE. +

+

00637 {
+00638         NL3D_MEM_SCENE
+00639         NL3D_HAUTO_UI_SCENE;
+00640 
+00641         return dynamic_cast<UCamera*>(_CurrentCamera);
+00642 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
sint32 NL3D::CSceneUser::getCLodAnimIdByName uint32  shapeId,
const std::string &  name
const [virtual]
+
+ + + + + +
+   + + +

+Get a AnimId of a shape by its name. -1 if not found. +

+Implements NL3D::UScene. +

+Definition at line 531 of file scene_user.cpp. +

+References NL3D::CLodCharacterShape::getAnimIdByName(), NL3D::CScene::getLodCharacterManager(), NL3D::CLodCharacterManager::getShape(), NL3D_HAUTO_UI_SCENE, NL3D_MEM_LOD, nlassert, sint32, and uint32. +

+

00532 {
+00533         NL3D_MEM_LOD
+00534         NL3D_HAUTO_UI_SCENE;
+00535 
+00536         // DriverUser always setup the lod manager
+00537         nlassert(_Scene.getLodCharacterManager());
+00538 
+00539         const CLodCharacterShape        *shape= _Scene.getLodCharacterManager()->getShape(shapeId);
+00540         if(shape)
+00541                 return shape->getAnimIdByName(name);
+00542         else
+00543                 return -1;
+00544 }
+
+

+ + + + +
+ + + + + + + + + + +
sint32 NL3D::CSceneUser::getCLodShapeIdByName const std::string &  name  )  const [virtual]
+
+ + + + + +
+   + + +

+Get a shapeId by its name. -1 if not found. +

+Implements NL3D::UScene. +

+Definition at line 519 of file scene_user.cpp. +

+References NL3D::CScene::getLodCharacterManager(), NL3D::CLodCharacterManager::getShapeIdByName(), NL3D_HAUTO_UI_SCENE, NL3D_MEM_LOD, nlassert, and sint32. +

+

00520 {
+00521         NL3D_MEM_LOD
+00522         NL3D_HAUTO_UI_SCENE;
+00523 
+00524         // DriverUser always setup the lod manager
+00525         nlassert(_Scene.getLodCharacterManager());
+00526 
+00527         return _Scene.getLodCharacterManager()->getShapeIdByName(name);
+00528 }
+
+

+ + + + +
+ + + + + + + + + +
uint8 NL3D::CSceneUser::getCoarseMeshLightingUpdate  )  const [virtual]
+
+ + + + + +
+   + + +

+see setCoarseMeshLightingUpdate() +

+ +

+Implements NL3D::UScene. +

+Definition at line 220 of file scene_user.cpp. +

+References NL3D::CScene::getCoarseMeshLightingUpdate(), NL3D_HAUTO_UI_SCENE, NL3D_MEM_LIGHT, and uint8. +

+

00221 {
+00222         NL3D_MEM_LIGHT
+00223         NL3D_HAUTO_UI_SCENE;
+00224 
+00225         return _Scene.getCoarseMeshLightingUpdate();
+00226 }
+
+

+ + + + +
+ + + + + + + + + +
bool NL3D::CSceneUser::getEnableShadowPolySmooth  )  const [virtual]
+
+ + + + + +
+   + + +

+get Enable Polygon Smoothing flag +

+ +

+Implements NL3D::UScene. +

+Definition at line 1088 of file scene_user.cpp. +

+References NL3D::CScene::getEnableShadowPolySmooth(). +

+

01089 {
+01090         return _Scene.getEnableShadowPolySmooth();
+01091 }
+
+

+ + + + +
+ + + + + + + + + +
uint NL3D::CSceneUser::getFlareContext  )  const [virtual]
+
+ + + + + +
+   + + +

+ +

+Implements NL3D::UScene. +

+Definition at line 1039 of file scene_user.cpp. +

+References NL3D::CScene::getFlareContext(), and uint. +

+

01040 {
+01041         return _Scene.getFlareContext(); 
+01042 }
+
+

+ + + + +
+ + + + + + + + + +
const CVector & NL3D::CSceneUser::getGlobalWindDirection  )  const [virtual]
+
+ + + + + +
+   + + +

+get the current windDirection +

+ +

+Implements NL3D::UScene. +

+Definition at line 399 of file scene_user.cpp. +

+References NL3D::CScene::getGlobalWindDirection(), NL3D_HAUTO_UI_SCENE, and NL3D_MEM_SCENE. +

+

00400 {
+00401         NL3D_MEM_SCENE
+00402         NL3D_HAUTO_UI_SCENE;
+00403 
+00404         return _Scene.getGlobalWindDirection();
+00405 }
+
+

+ + + + +
+ + + + + + + + + +
float NL3D::CSceneUser::getGlobalWindPower  )  const [virtual]
+
+ + + + + +
+   + + +

+get the current windPower +

+ +

+Implements NL3D::UScene. +

+Definition at line 386 of file scene_user.cpp. +

+References NL3D::CScene::getGlobalWindPower(), NL3D_HAUTO_UI_SCENE, and NL3D_MEM_SCENE. +

+

00387 {
+00388         NL3D_MEM_SCENE
+00389         NL3D_HAUTO_UI_SCENE;
+00390 
+00391         return _Scene.getGlobalWindPower();
+00392 }
+
+

+ + + + +
+ + + + + + + + + + +
uint NL3D::CSceneUser::getGroupLoadMaxPolygon const std::string &  group  )  [virtual]
+
+ + + + + +
+   + + +

+Get the number of faces wanted for a LoadBlancingGroup. The Group is created if did not exist. +

+Implements NL3D::UScene. +

+Definition at line 175 of file scene_user.cpp. +

+References NL3D::CScene::getGroupLoadMaxPolygon(), NL3D_HAUTO_UI_SCENE, NL3D_MEM_SCENE, and uint. +

+

00176 {
+00177         NL3D_MEM_SCENE
+00178         NL3D_HAUTO_UI_SCENE;
+00179 
+00180         return _Scene.getGroupLoadMaxPolygon(group);
+00181 }
+
+

+ + + + +
+ + + + + + + + + + +
float NL3D::CSceneUser::getGroupNbFaceAsked const std::string &  group  )  const [virtual]
+
+ + + + + +
+   + + +

+Get the last face count asked from the instances before reduction. only for the given group return 0 if the Group does not exist. +

+Implements NL3D::UScene. +

+Definition at line 183 of file scene_user.cpp. +

+References NL3D::CScene::getGroupNbFaceAsked(), NL3D_HAUTO_UI_SCENE, and NL3D_MEM_SCENE. +

+

00184 {
+00185         NL3D_MEM_SCENE
+00186         NL3D_HAUTO_UI_SCENE;
+00187 
+00188         return _Scene.getGroupNbFaceAsked (group);
+00189 }
+
+

+ + + + +
+ + + + + + + + + +
virtual bool NL3D::CSceneUser::getLayersRenderingOrder  )  const [inline, virtual]
+
+ + + + + +
+   + + +

+ +

+Implements NL3D::UScene. +

+Definition at line 237 of file scene_user.h. +

+References NL3D::CScene::getLayersRenderingOrder(). +

+

00237 { return _Scene.getLayersRenderingOrder(); }
+
+

+ + + + +
+ + + + + + + + + +
float NL3D::CSceneUser::getLightTransitionThreshold  )  const [virtual]
+
+ + + + + +
+   + + +

+getLightTransitionThreshold() +

+ +

+Implements NL3D::UScene. +

+Definition at line 343 of file scene_user.cpp. +

+References NL3D::CScene::getLightTransitionThreshold(), NL3D_HAUTO_UI_SCENE, and NL3D_MEM_LIGHT. +

+

00344 {
+00345         NL3D_MEM_LIGHT
+00346         NL3D_HAUTO_UI_SCENE;
+00347 
+00348         return _Scene.getLightTransitionThreshold();
+00349 }
+
+

+ + + + +
+ + + + + + + + + +
uint NL3D::CSceneUser::getMaxLightContribution  )  const [virtual]
+
+ + + + + +
+   + + +

+setMaxLightContribution() +

+ +

+Implements NL3D::UScene. +

+Definition at line 328 of file scene_user.cpp. +

+References NL3D::CScene::getMaxLightContribution(), NL3D_HAUTO_UI_SCENE, NL3D_MEM_LIGHT, and uint. +

+

00329 {
+00330         NL3D_MEM_LIGHT
+00331         NL3D_HAUTO_UI_SCENE;
+00332 
+00333         return _Scene.getMaxLightContribution();
+00334 }
+
+

+ + + + +
+ + + + + + + + + +
uint NL3D::CSceneUser::getMaxSkeletonsInNotCLodForm  )  const [virtual]
+
+ + + + + +
+   + + +

+see setMaxSkeletonsInNotCLodForm() +

+ +

+Implements NL3D::UScene. +

+Definition at line 990 of file scene_user.cpp. +

+References NL3D::CScene::getMaxSkeletonsInNotCLodForm(), and uint. +

+

00991 {
+00992         return _Scene.getMaxSkeletonsInNotCLodForm();
+00993 }
+
+

+ + + + +
+ + + + + + + + + +
float NL3D::CSceneUser::getNbFaceAsked  )  const [virtual]
+
+ + + + + +
+   + + +

+Get the last face count asked from the instances before reduction. It gets the sum of All groups. +

+Implements NL3D::UScene. +

+Definition at line 158 of file scene_user.cpp. +

+References NL3D::CScene::getNbFaceAsked(), NL3D_HAUTO_UI_SCENE, and NL3D_MEM_SCENE. +

+

00159 {
+00160         NL3D_MEM_SCENE
+00161         NL3D_HAUTO_UI_SCENE;
+00162 
+00163         return _Scene.getNbFaceAsked ();
+00164 }
+
+

+ + + + +
+ + + + + + + + + +
uint NL3D::CSceneUser::getNumFlareContexts  )  const [virtual]
+
+ + + + + +
+   + + +

+ +

+Implements NL3D::UScene. +

+Definition at line 1022 of file scene_user.cpp. +

+References uint. +

+

01023 {
+01024         return CScene::MaxNumFlareContexts;
+01025 }
+
+

+ + + + +
+ + + + + + + + + +
CSceneUser::TPolygonBalancingMode NL3D::CSceneUser::getPolygonBalancingMode  )  const [virtual]
+
+ + + + + +
+   + + +

+Get the PolygonBalancingMode. +

+ +

+Implements NL3D::UScene. +

+Definition at line 147 of file scene_user.cpp. +

+References NL3D::CScene::getPolygonBalancingMode(), NL3D_HAUTO_UI_SCENE, NL3D_MEM_SCENE, nlassert, and uint. +

+

00148 {
+00149         NL3D_MEM_SCENE
+00150         NL3D_HAUTO_UI_SCENE;
+00151 
+00152         nlassert( (uint)CScene::CountPolygonBalancing == (uint)CSceneUser::CountPolygonBalancing );
+00153         return (CSceneUser::TPolygonBalancingMode)(uint)_Scene.getPolygonBalancingMode();
+00154 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::getProfileResults CBenchResults &  results  )  [virtual]
+
+ + + + + +
+   + + +

+get The result of the profiling. +

+ +

+Implements NL3D::UScene. +

+Definition at line 1009 of file scene_user.cpp. +

+References NL3D::CScene::BenchRes. +

+

01010 {
+01011         // Fill profile results
+01012         results= _Scene.BenchRes;
+01013 }
+
+

+ + + + +
+ + + + + + + + + + +
CScene& NL3D::CSceneUser::getScene void   )  [inline]
+
+ + + + + +
+   + + +

+ +

+Definition at line 328 of file scene_user.h. +

+References NL3D_MEM_SCENE. +

+

00329         {
+00330                 NL3D_MEM_SCENE
+00331                 return _Scene;
+00332         }
+
+

+ + + + +
+ + + + + + + + + +
uint NL3D::CSceneUser::getShadowMapBlurSize  )  const [virtual]
+
+ + + + + +
+   + + +

+get the size of the blur (<=3 means number of fakeBlur). +

+ +

+Implements NL3D::UScene. +

+Definition at line 1070 of file scene_user.cpp. +

+References NL3D::CScene::getShadowMapBlurSize(), and uint. +

+

01071 {
+01072         return _Scene.getShadowMapBlurSize();
+01073 }
+
+

+ + + + +
+ + + + + + + + + +
float NL3D::CSceneUser::getShadowMapDistFadeEnd  )  const [virtual]
+
+ + + + + +
+   + + +

+Enable Polygon Smoothing. +

+ +

+Implements NL3D::UScene. +

+Definition at line 1109 of file scene_user.cpp. +

+References NL3D::CScene::getShadowMapDistFadeEnd(). +

+

01110 {
+01111         return _Scene.getShadowMapDistFadeEnd();
+01112 }
+
+

+ + + + +
+ + + + + + + + + +
float NL3D::CSceneUser::getShadowMapDistFadeStart  )  const [virtual]
+
+ + + + + +
+   + + +

+Enable Polygon Smoothing. +

+ +

+Implements NL3D::UScene. +

+Definition at line 1099 of file scene_user.cpp. +

+References NL3D::CScene::getShadowMapDistFadeStart(). +

+

01100 {
+01101         return _Scene.getShadowMapDistFadeStart();
+01102 }
+
+

+ + + + +
+ + + + + + + + + +
uint NL3D::CSceneUser::getShadowMapMaxCasterAround  )  const [virtual]
+
+ + + + + +
+   + + +

+Enable Polygon Smoothing. +

+ +

+Implements NL3D::UScene. +

+Definition at line 1129 of file scene_user.cpp. +

+References NL3D::CScene::getShadowMapMaxCasterAround(), and uint. +

+

01130 {
+01131         return _Scene.getShadowMapMaxCasterAround();
+01132 }
+
+

+ + + + +
+ + + + + + + + + +
uint NL3D::CSceneUser::getShadowMapMaxCasterInScreen  )  const [virtual]
+
+ + + + + +
+   + + +

+Enable Polygon Smoothing. +

+ +

+Implements NL3D::UScene. +

+Definition at line 1119 of file scene_user.cpp. +

+References NL3D::CScene::getShadowMapMaxCasterInScreen(), and uint. +

+

01120 {
+01121         return _Scene.getShadowMapMaxCasterInScreen();
+01122 }
+
+

+ + + + +
+ + + + + + + + + +
float NL3D::CSceneUser::getShadowMapMaxDepth  )  const [virtual]
+
+ + + + + +
+   + + +

+return the current ShadowMap Max Depth. This is the length in the lightDir direction where the shadow can touch receivers +

+ +

+Implements NL3D::UScene. +

+Definition at line 1058 of file scene_user.cpp. +

+References NL3D::CScene::getShadowMapMaxDepth(). +

+

01059 {
+01060         return _Scene.getShadowMapMaxDepth();
+01061 }
+
+

+ + + + +
+ + + + + + + + + +
uint NL3D::CSceneUser::getShadowMapTextureSize  )  const [virtual]
+
+ + + + + +
+   + + +

+return the current base ShadowMap TextureSize. Default is 64 texels. +

+ +

+Implements NL3D::UScene. +

+Definition at line 1046 of file scene_user.cpp. +

+References NL3D::CScene::getShadowMapTextureSize(), and uint. +

+

01047 {
+01048         return _Scene.getShadowMapTextureSize();
+01049 }
+
+

+ + + + +
+ + + + + + + + + +
NLMISC::CRGBA NL3D::CSceneUser::getSunAmbient  )  const [virtual]
+
+ + + + + +
+   + + +

+get the Ambient of the Sun used for the scene. +

+ +

+Implements NL3D::UScene. +

+Definition at line 290 of file scene_user.cpp. +

+References NL3D::CScene::getSunAmbient(), NL3D_HAUTO_UI_SCENE, and NL3D_MEM_LIGHT. +

+

00291 {
+00292         NL3D_MEM_LIGHT
+00293         NL3D_HAUTO_UI_SCENE;
+00294 
+00295         return _Scene.getSunAmbient();
+00296 }
+
+

+ + + + +
+ + + + + + + + + +
NLMISC::CRGBA NL3D::CSceneUser::getSunDiffuse  )  const [virtual]
+
+ + + + + +
+   + + +

+get the Diffuse of the Sun used for the scene. +

+ +

+Implements NL3D::UScene. +

+Definition at line 297 of file scene_user.cpp. +

+References NL3D::CScene::getSunDiffuse(), NL3D_HAUTO_UI_SCENE, and NL3D_MEM_LIGHT. +

+

00298 {
+00299         NL3D_MEM_LIGHT
+00300         NL3D_HAUTO_UI_SCENE;
+00301 
+00302         return _Scene.getSunDiffuse();
+00303 }
+
+

+ + + + +
+ + + + + + + + + +
NLMISC::CVector NL3D::CSceneUser::getSunDirection  )  const [virtual]
+
+ + + + + +
+   + + +

+get the Direction of the Sun used for the scene. +

+ +

+Implements NL3D::UScene. +

+Definition at line 311 of file scene_user.cpp. +

+References NL3D::CScene::getSunDirection(), NL3D_HAUTO_UI_SCENE, and NL3D_MEM_LIGHT. +

+

00312 {
+00313         NL3D_MEM_LIGHT
+00314         NL3D_HAUTO_UI_SCENE;
+00315 
+00316         return _Scene.getSunDirection();
+00317 }
+
+

+ + + + +
+ + + + + + + + + +
NLMISC::CRGBA NL3D::CSceneUser::getSunSpecular  )  const [virtual]
+
+ + + + + +
+   + + +

+get the Specular of the Sun used for the scene. +

+ +

+Implements NL3D::UScene. +

+Definition at line 304 of file scene_user.cpp. +

+References NL3D::CScene::getSunSpecular(), NL3D_HAUTO_UI_SCENE, and NL3D_MEM_LIGHT. +

+

00305 {
+00306         NL3D_MEM_LIGHT
+00307         NL3D_HAUTO_UI_SCENE;
+00308 
+00309         return _Scene.getSunSpecular();
+00310 }
+
+

+ + + + +
+ + + + + + + + + +
CViewport NL3D::CSceneUser::getViewport  )  [virtual]
+
+ + + + + +
+   + + +

+Get the current Viewport. +

+ +

+Implements NL3D::UScene. +

+Definition at line 650 of file scene_user.cpp. +

+References NL3D::CScene::getViewport(), NL3D_HAUTO_UI_SCENE, and NL3D_MEM_SCENE. +

+

00651 {
+00652         NL3D_MEM_SCENE
+00653         NL3D_HAUTO_UI_SCENE;
+00654 
+00655         return _Scene.getViewport();
+00656 }
+
+

+ + + + +
+ + + + + + + + + +
IWaterSurfaceAddedCallback * NL3D::CSceneUser::getWaterCallback  )  const [virtual]
+
+ + + + + +
+   + + +

+ +

+Implements NL3D::UScene. +

+Definition at line 1139 of file scene_user.cpp. +

+References NL3D::CScene::getWaterCallback(). +

+

01140 {
+01141         return _Scene.getWaterCallback();
+01142 }
+
+

+ + + + +
+ + + + + + + + + + +
uint32 NL3D::CSceneUser::loadCLodShapeBank const std::string &  fileName  )  [virtual]
+
+ + + + + +
+   + + +

+Load a Shape Bank. The ShapeMap is rebuilded. Hence slow call. NB: a vector of ShapeBank is maintained internally, hence, not so many shapeBank should be created at same Time. trhow exception if failed to load the file

Parameters:
+ + +
fileName is a .clodbank file, to be loaded. CPath::lookup is used.
+
+
Returns:
id of the shape Bank.
+ +

+Implements NL3D::UScene. +

+Definition at line 475 of file scene_user.cpp. +

+References NL3D::CLodCharacterManager::compile(), NL3D::CLodCharacterManager::createShapeBank(), file, NL3D::CScene::getLodCharacterManager(), NL3D::CLodCharacterManager::getShapeBank(), NL3D_HAUTO_LOAD_LOD, NL3D_MEM_LOD, nlassert, and uint32. +

+

00476 {
+00477         NL3D_MEM_LOD
+00478         NL3D_HAUTO_LOAD_LOD;
+00479 
+00480         // DriverUser always setup the lod manager
+00481         nlassert(_Scene.getLodCharacterManager());
+00482 
+00483         // Open the file
+00484         CIFile  file(CPath::lookup(fileName));
+00485 
+00486         // create the shape bank
+00487         uint32  bankId= _Scene.getLodCharacterManager()->createShapeBank();
+00488 
+00489         // get the bank
+00490         CLodCharacterShapeBank  *bank= _Scene.getLodCharacterManager()->getShapeBank(bankId);
+00491         nlassert(bank);
+00492 
+00493         // read the bank.
+00494         file.serial(*bank);
+00495 
+00496         // recompile the shape Map.
+00497         _Scene.getLodCharacterManager()->compile();
+00498 
+00499         return bankId;
+00500 }
+
+

+ + + + +
+ + + + + + + + + +
void NL3D::CSceneUser::profileNextRender  )  [virtual]
+
+ + + + + +
+   + + +

+Enable Profiling for the next render(). Reset All stats. +

+ +

+Implements NL3D::UScene. +

+Definition at line 1004 of file scene_user.cpp. +

+References NL3D::CScene::profileNextRender(). +

+

01005 {
+01006         _Scene.profileNextRender();
+01007 }
+
+

+ + + + +
+ + + + + + + + + +
void NL3D::CSceneUser::profileQuadGridClipManager  )  [virtual]
+
+ + + + + +
+   + + +

+output (nlinfo) Stats for Usage of the QuadClip +

+Implements NL3D::UScene. +

+Definition at line 1016 of file scene_user.cpp. +

+References NL3D::CScene::getClipTrav(), NL3D::CClipTrav::getQuadGridClipManager(), and NL3D::CQuadGridClipManager::profile(). +

+

01017 {
+01018         _Scene.getClipTrav().getQuadGridClipManager()->profile();
+01019 }
+
+

+ + + + +
+ + + + + + + + + +
void NL3D::CSceneUser::render  )  [virtual]
+
+ + + + + +
+   + + +

+Render the scene from the CurrentCamera view (setCam()), and the current Viewport. nlError if no current camera. NB: no Driver clear buffers (color or ZBuffer) are done....
+ NB: The UDriver Matrix/Viewport context for 2D/3D interface is restored after this render. NB: nlerror if the current camera has been deleted. NB: the UDriver Light setup (see UDriver::setLight() / UDriver::setAmbientColor()) is modified. At the exit of render(), all UDriver lights are disabled. +

+Implements NL3D::UScene. +

+Definition at line 548 of file scene_user.cpp. +

+References _CurrentCamera, _DriverUser, NL3D_HAUTO_RENDER_SCENE, NL3D_MEM_SCENE_RENDER, nlerror, NL3D::CScene::render(), NL3D::CDriverUser::restoreMatrixContext(), and updateWaitingInstances(). +

+

00549 {       
+00550         NL3D_MEM_SCENE_RENDER
+00551 
+00552         // render the scene.
+00553         {
+00554                 NL3D_HAUTO_RENDER_SCENE
+00555 
+00556                 if(_CurrentCamera==NULL)
+00557                         nlerror("render(): try to render with no camera linked (may have been deleted)");
+00558                 _Scene.render();
+00559         }
+00560 
+00561         updateWaitingInstances();
+00562 
+00563         // Must restore the matrix context, so 2D/3D interface not disturbed.
+00564         _DriverUser->restoreMatrixContext();
+00565 }
+
+

+ + + + +
+ + + + + + + + + +
void NL3D::CSceneUser::resetCLodManager  )  [virtual]
+
+ + + + + +
+   + + +

+reset the manager. +

+NB: for an historic reason, CLod interface is in UScene, BUT THERE IS ONLY ONE LOD MANAGER PER UDriver! +

+Implements NL3D::UScene. +

+Definition at line 463 of file scene_user.cpp. +

+References NL3D::CScene::getLodCharacterManager(), NL3D_HAUTO_UI_SCENE, NL3D_MEM_LOD, nlassert, and NL3D::CLodCharacterManager::reset(). +

+

00464 {
+00465         NL3D_MEM_LOD
+00466         NL3D_HAUTO_UI_SCENE;
+00467 
+00468         // DriverUser always setup the lod manager
+00469         nlassert(_Scene.getLodCharacterManager());
+00470 
+00471         _Scene.getLodCharacterManager()->reset();
+00472 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setAmbientGlobal NLMISC::CRGBA  ambient  )  [virtual]
+
+ + + + + +
+   + + +

+set the global Ambient used for the scene. Default to (50, 50, 50). +

+ +

+Implements NL3D::UScene. +

+Definition at line 238 of file scene_user.cpp. +

+References NL3D_HAUTO_UI_SCENE, NL3D_MEM_LIGHT, and NL3D::CScene::setAmbientGlobal(). +

+

00239 {
+00240         NL3D_MEM_LIGHT
+00241         NL3D_HAUTO_UI_SCENE;
+00242 
+00243         _Scene.setAmbientGlobal(ambient);
+00244 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setAutomaticAnimationSet UAnimationSet as  )  [virtual]
+
+ + + + + +
+   + + +

+Set the automatic animation set used by the scene. +

+Implements NL3D::UScene. +

+Definition at line 106 of file scene_user.cpp. +

+References NL3D::CAnimationSetUser::_AnimationSet, NL3D::UAnimationSet::build(), NL3D_HAUTO_UI_SCENE, nlassert, and NL3D::CScene::setAutomaticAnimationSet(). +

+

00107 {
+00108         NL_ALLOC_CONTEXT( 3dAnmSt )
+00109         NL3D_HAUTO_UI_SCENE;
+00110 
+00111         nlassert(as);
+00112         as->build();
+00113         CAnimationSetUser *asu = NLMISC::safe_cast<CAnimationSetUser *>(as);
+00114         _Scene.setAutomaticAnimationSet(asu->_AnimationSet);
+00115 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setCam UCamera cam  )  [virtual]
+
+ + + + + +
+   + + +

+Set the current camera for this scene. nlError if NULL, or if the camera was not created by this UScene. +

+ +

+Implements NL3D::UScene. +

+Definition at line 622 of file scene_user.cpp. +

+References _CurrentCamera, NL3D::CTransformUser::getScene(), NL3D_HAUTO_UI_SCENE, NL3D_MEM_SCENE, nlerror, and NL3D::CScene::setCam(). +

+Referenced by CSceneUser(). +

+

00623 {
+00624         NL3D_MEM_SCENE
+00625         NL3D_HAUTO_UI_SCENE;
+00626 
+00627         if(!cam)
+00628                 nlerror("setCam(): cannot set a NULL camera");
+00629         CCameraUser             *newCam= dynamic_cast<CCameraUser*>(cam);
+00630         if( newCam->getScene() != &_Scene)
+00631                 nlerror("setCam(): try to set a current camera not created from this scene");
+00632 
+00633         _CurrentCamera= newCam;
+00634         _Scene.setCam(newCam->getCamera());
+00635 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setCoarseMeshLightingUpdate uint8  period  )  [virtual]
+
+ + + + + +
+   + + +

+Each coarseMesh lighting will be updated every "period" frame. clamped to 1,255 +

+Implements NL3D::UScene. +

+Definition at line 211 of file scene_user.cpp. +

+References NL3D_HAUTO_UI_SCENE, NL3D_MEM_LIGHT, NL3D::CScene::setCoarseMeshLightingUpdate(), and uint8. +

+

00212 {
+00213         NL3D_MEM_LIGHT
+00214         NL3D_HAUTO_UI_SCENE;
+00215 
+00216         _Scene.setCoarseMeshLightingUpdate(period);
+00217 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setCoarseMeshManagerTexture const char *  sPath  )  [virtual]
+
+ + + + + +
+   + + +

+Set the coarse meshes's common texture. +

+Implements NL3D::UScene. +

+Definition at line 194 of file scene_user.cpp. +

+References NL3D::CScene::getCoarseMeshManager(), NL3D_HAUTO_LOAD_LOD, NL3D_MEM_LOD, and NL3D::CCoarseMeshManager::setTextureFile(). +

+

00195 {
+00196         NL3D_MEM_LOD
+00197         NL3D_HAUTO_LOAD_LOD;
+00198 
+00199         // Get the manager
+00200         CCoarseMeshManager *manager=_Scene.getCoarseMeshManager ();
+00201 
+00202         // Does it exist ?
+00203         if (manager)
+00204         {
+00205                 // Set the texture
+00206                 manager->setTextureFile (sPath);
+00207         }
+00208 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setFlareContext uint  context  )  [virtual]
+
+ + + + + +
+   + + +

+ +

+Implements NL3D::UScene. +

+Definition at line 1028 of file scene_user.cpp. +

+References nlwarning, NL3D::CScene::setFlareContext(), and uint. +

+

01029 {
+01030         if (context > CScene::MaxNumFlareContexts)
+01031         {
+01032                 nlwarning("Invalid flare context");
+01033                 return;
+01034         }
+01035         _Scene.setFlareContext(context);
+01036 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setGlobalWindDirection const NLMISC::CVector gwd  )  [virtual]
+
+ + + + + +
+   + + +

+Set the current windDirection for all the scene. dir.z set to 0 and vector normalized. +

+ +

+Implements NL3D::UScene. +

+Definition at line 394 of file scene_user.cpp. +

+References NL3D::CScene::setGlobalWindDirection(). +

+

00395 {
+00396         _Scene.setGlobalWindDirection(gwd);
+00397 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setGlobalWindPower float  gwp  )  [virtual]
+
+ + + + + +
+   + + +

+Set the current windPower for all the scene. 0-1. +

+ +

+Implements NL3D::UScene. +

+Definition at line 378 of file scene_user.cpp. +

+References NL3D_HAUTO_UI_SCENE, NL3D_MEM_SCENE, and NL3D::CScene::setGlobalWindPower(). +

+

00379 {
+00380         NL3D_MEM_SCENE
+00381         NL3D_HAUTO_UI_SCENE;
+00382 
+00383         _Scene.setGlobalWindPower(gwp);
+00384 }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CSceneUser::setGroupLoadMaxPolygon const std::string &  group,
uint  nFaces
[virtual]
+
+ + + + + +
+   + + +

+Set the number of faces wanted for a LoadBlancingGroup. The Group is created if did not exist. +

+Implements NL3D::UScene. +

+Definition at line 167 of file scene_user.cpp. +

+References NL3D_HAUTO_UI_SCENE, NL3D_MEM_SCENE, NL3D::CScene::setGroupLoadMaxPolygon(), and uint. +

+

00168 {
+00169         NL3D_MEM_SCENE
+00170         NL3D_HAUTO_UI_SCENE;
+00171 
+00172         _Scene.setGroupLoadMaxPolygon(group, nFaces);
+00173 }
+
+

+ + + + +
+ + + + + + + + + + +
virtual void NL3D::CSceneUser::setLayersRenderingOrder bool  directOrder = true  )  [inline, virtual]
+
+ + + + + +
+   + + +

+Set the order or rendering of layers containing transparent objects. In real case, with direct order, we have:

    +
  • Underwater is rendered.
  • Water is rendered.
  • Objects above water are rendered.
+ +

+Implements NL3D::UScene. +

+Definition at line 236 of file scene_user.h. +

+References NL3D::CScene::setLayersRenderingOrder(). +

+

00236 { _Scene.setLayersRenderingOrder(directOrder); }
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void NL3D::CSceneUser::setLightGroupColor uint  lightmapGroup,
NLMISC::CRGBA  color
[virtual]
+
+ + + + + +
+   + + +

+set the color of a light group. +

+ +

+Implements NL3D::UScene. +

+Definition at line 273 of file scene_user.cpp. +

+References NL3D_HAUTO_UI_SCENE, NL3D_MEM_LIGHT, NL3D::CScene::setLightGroupColor(), and uint. +

+

00274 {
+00275         NL3D_MEM_LIGHT
+00276         NL3D_HAUTO_UI_SCENE;
+00277 
+00278         _Scene.setLightGroupColor(lightmapGroup, color);
+00279 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setLightTransitionThreshold float  lightTransitionThreshold  )  [virtual]
+
+ + + + + +
+   + + +

+Advanced. When a model is influenced by more light than allowed, or when it reach the limits of the light (attenuationEnd), the light can be darkened according to some threshold. The resultLightColor begin to fade when distModelToLight== attEnd- threshold*(attEnd-attBegin). when distModelToLight== 0, resultLightColor==Black. By default, this value is 0.1f. Setting higher values will smooth transition but will generally darken the global effects of lights. NB: clamp(value, 0, 1); +

+Implements NL3D::UScene. +

+Definition at line 336 of file scene_user.cpp. +

+References NL3D_HAUTO_UI_SCENE, NL3D_MEM_LIGHT, and NL3D::CScene::setLightTransitionThreshold(). +

+

00337 {
+00338         NL3D_MEM_LIGHT
+00339         NL3D_HAUTO_UI_SCENE;
+00340 
+00341         _Scene.setLightTransitionThreshold(lightTransitionThreshold);
+00342 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setMaxLightContribution uint  nlights  )  [virtual]
+
+ + + + + +
+   + + +

+setup the max number of point light that can influence a model. NB: clamped by NL3D_MAX_LIGHT_CONTRIBUTION Default is 3. NB: the sun contribution is not taken into account +

+Implements NL3D::UScene. +

+Definition at line 321 of file scene_user.cpp. +

+References NL3D_HAUTO_UI_SCENE, NL3D_MEM_LIGHT, NL3D::CScene::setMaxLightContribution(), and uint. +

+

00322 {
+00323         NL3D_MEM_LIGHT
+00324         NL3D_HAUTO_UI_SCENE;
+00325 
+00326         _Scene.setMaxLightContribution(nlights);
+00327 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setMaxSkeletonsInNotCLodForm uint  m  )  [virtual]
+
+ + + + + +
+   + + +

+LoadBalancing for CLod and Skeletons. Setup the max number of skeletons displayed in std way (ie not CLod). Default is 20. +

+Implements NL3D::UScene. +

+Definition at line 984 of file scene_user.cpp. +

+References NL3D::CScene::setMaxSkeletonsInNotCLodForm(), and uint. +

+

00985 {
+00986         _Scene.setMaxSkeletonsInNotCLodForm(m);
+00987 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setPolygonBalancingMode TPolygonBalancingMode  polBalMode  )  [virtual]
+
+ + + + + +
+   + + +

+Set the PolygonBalancingMode. +

+ +

+Implements NL3D::UScene. +

+Definition at line 136 of file scene_user.cpp. +

+References NL3D_HAUTO_UI_SCENE, NL3D_MEM_SCENE, nlassert, NL3D::CScene::setPolygonBalancingMode(), and uint. +

+

00137 {
+00138         NL3D_MEM_SCENE
+00139         NL3D_HAUTO_UI_SCENE;
+00140 
+00141         nlassert( (uint)CScene::CountPolygonBalancing == (uint)CSceneUser::CountPolygonBalancing );
+00142         _Scene.setPolygonBalancingMode((CScene::TPolygonBalancingMode)(uint)(polBalMode));
+00143 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setShadowMapBlurSize uint  bs  )  [virtual]
+
+ + + + + +
+   + + +

+set the size of the blur (<=3 means number of fakeBlur). +

+ +

+Implements NL3D::UScene. +

+Definition at line 1076 of file scene_user.cpp. +

+References NL3D::CScene::setShadowMapBlurSize(), and uint. +

+

01077 {
+01078         _Scene.setShadowMapBlurSize(bs);
+01079 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setShadowMapDistFadeEnd float  dist  )  [virtual]
+
+ + + + + +
+   + + +

+ShadowMap Distance Fade end (50 default). +

+ +

+Implements NL3D::UScene. +

+Definition at line 1104 of file scene_user.cpp. +

+References NL3D::CScene::setShadowMapDistFadeEnd(). +

+

01105 {
+01106         _Scene.setShadowMapDistFadeEnd(dist);
+01107 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setShadowMapDistFadeStart float  dist  )  [virtual]
+
+ + + + + +
+   + + +

+ShadowMap Distance Fade Start (40 default). +

+ +

+Implements NL3D::UScene. +

+Definition at line 1094 of file scene_user.cpp. +

+References NL3D::CScene::setShadowMapDistFadeStart(). +

+

01095 {
+01096         _Scene.setShadowMapDistFadeStart(dist);
+01097 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setShadowMapMaxCasterAround uint  num  )  [virtual]
+
+ + + + + +
+   + + +

+ShadowMap max Caster Around (optimize memory). +

+ +

+Implements NL3D::UScene. +

+Definition at line 1124 of file scene_user.cpp. +

+References num, NL3D::CScene::setShadowMapMaxCasterAround(), and uint. +

+

01125 {
+01126         _Scene.setShadowMapMaxCasterAround(num);
+01127 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setShadowMapMaxCasterInScreen uint  num  )  [virtual]
+
+ + + + + +
+   + + +

+ShadowMap max Caster In Screen (optimize CPU/GPU). +

+ +

+Implements NL3D::UScene. +

+Definition at line 1114 of file scene_user.cpp. +

+References num, NL3D::CScene::setShadowMapMaxCasterInScreen(), and uint. +

+

01115 {
+01116         _Scene.setShadowMapMaxCasterInScreen(num);
+01117 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setShadowMapMaxDepth float  depth  )  [virtual]
+
+ + + + + +
+   + + +

+set the ShadowMap Extent +

+ +

+Implements NL3D::UScene. +

+Definition at line 1064 of file scene_user.cpp. +

+References depth, and NL3D::CScene::setShadowMapMaxDepth(). +

+

01065 {
+01066         _Scene.setShadowMapMaxDepth(depth);
+01067 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setShadowMapTextureSize uint  size  )  [virtual]
+
+ + + + + +
+   + + +

+must be a power of 2. +

+ +

+Implements NL3D::UScene. +

+Definition at line 1052 of file scene_user.cpp. +

+References NL3D::CScene::setShadowMapTextureSize(), size, and uint. +

+

01053 {
+01054         _Scene.setShadowMapTextureSize(size);
+01055 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setSunAmbient NLMISC::CRGBA  ambient  )  [virtual]
+
+ + + + + +
+   + + +

+set the Ambient of the Sun used for the scene. +

+ +

+Implements NL3D::UScene. +

+Definition at line 245 of file scene_user.cpp. +

+References NL3D_HAUTO_UI_SCENE, NL3D_MEM_LIGHT, and NL3D::CScene::setSunAmbient(). +

+

00246 {
+00247         NL3D_MEM_LIGHT
+00248         NL3D_HAUTO_UI_SCENE;
+00249 
+00250         _Scene.setSunAmbient(ambient);
+00251 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setSunDiffuse NLMISC::CRGBA  diffuse  )  [virtual]
+
+ + + + + +
+   + + +

+set the Diffuse of the Sun used for the scene. +

+ +

+Implements NL3D::UScene. +

+Definition at line 252 of file scene_user.cpp. +

+References NL3D_HAUTO_UI_SCENE, NL3D_MEM_LIGHT, and NL3D::CScene::setSunDiffuse(). +

+

00253 {
+00254         NL3D_MEM_LIGHT
+00255         NL3D_HAUTO_UI_SCENE;
+00256 
+00257         _Scene.setSunDiffuse(diffuse);
+00258 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setSunDirection const NLMISC::CVector direction  )  [virtual]
+
+ + + + + +
+   + + +

+set the Direction of the Sun used for the scene. +

+ +

+Implements NL3D::UScene. +

+Definition at line 266 of file scene_user.cpp. +

+References NL3D_HAUTO_UI_SCENE, NL3D_MEM_LIGHT, and NL3D::CScene::setSunDirection(). +

+

00267 {
+00268         NL3D_MEM_LIGHT
+00269         NL3D_HAUTO_UI_SCENE;
+00270 
+00271         _Scene.setSunDirection(direction);
+00272 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setSunSpecular NLMISC::CRGBA  specular  )  [virtual]
+
+ + + + + +
+   + + +

+set the Specular of the Sun used for the scene. +

+ +

+Implements NL3D::UScene. +

+Definition at line 259 of file scene_user.cpp. +

+References NL3D_HAUTO_UI_SCENE, NL3D_MEM_LIGHT, and NL3D::CScene::setSunSpecular(). +

+

00260 {
+00261         NL3D_MEM_LIGHT
+00262         NL3D_HAUTO_UI_SCENE;
+00263 
+00264         _Scene.setSunSpecular(specular);
+00265 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setToGlobalInstanceGroup UInstanceGroup pIG  )  [virtual]
+
+ + + + + +
+   + + +

+Assign the Instance Group to the root cluster +

+Implements NL3D::UScene. +

+Definition at line 919 of file scene_user.cpp. +

+References NL3D::CInstanceGroupUser::_InstanceGroup, NL3D::CScene::getGlobalInstanceGroup(), NL3D_HAUTO_UI_SCENE, NL3D_MEM_IG, and NL3D::CInstanceGroup::setClusterSystemForInstances(). +

+Referenced by updateWaitingIG(). +

+

00920 {
+00921         NL3D_MEM_IG
+00922         NL3D_HAUTO_UI_SCENE;
+00923 
+00924         CInstanceGroupUser *pIGU = (CInstanceGroupUser*)pIG;
+00925         pIGU->_InstanceGroup.setClusterSystemForInstances(_Scene.getGlobalInstanceGroup());
+00926 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setViewport const class CViewport viewport  )  [virtual]
+
+ + + + + +
+   + + +

+Set the current Viewport. +

+ +

+Implements NL3D::UScene. +

+Definition at line 643 of file scene_user.cpp. +

+References NL3D_HAUTO_UI_SCENE, NL3D_MEM_SCENE, and NL3D::CScene::setViewport(). +

+

00644 {
+00645         NL3D_MEM_SCENE
+00646         NL3D_HAUTO_UI_SCENE;
+00647 
+00648         _Scene.setViewport(viewport);
+00649 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::setWaterCallback IWaterSurfaceAddedCallback wcb  )  [virtual]
+
+ + + + + +
+   + + +

+ +

+Implements NL3D::UScene. +

+Definition at line 1134 of file scene_user.cpp. +

+References NL3D::CScene::setWaterCallback(). +

+

01135 {
+01136         _Scene.setWaterCallback(wcb);
+01137 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::stopCreatingAndAddingIG UInstanceGroup **  pIG  )  [virtual]
+
+ + + + + +
+   + + +

+If we are adding the ig : stop loading and adding it to the scene if the ig is already added to the scene : remove it from scene +

+Implements NL3D::UScene. +

+Definition at line 764 of file scene_user.cpp. +

+References _WaitingIGs, NL3D::CSceneUser::CWaitingIG::CallerPtr, NL3D::UInstanceGroup::getAddToSceneState(), NL3D::CSceneUser::CWaitingIG::IGToLoad, NL3D_HAUTO_ASYNC_IG, NL3D_MEM_IG, NL3D::UInstanceGroup::removeFromScene(), and NL3D::UInstanceGroup::stopAddToSceneAsync(). +

+

00765 {
+00766         NL3D_MEM_IG
+00767         NL3D_HAUTO_ASYNC_IG;
+00768 
+00769         for(TWaitingIGList::iterator it = _WaitingIGs.begin(); it != _WaitingIGs.end(); ++it)
+00770         {
+00771                 CWaitingIG &rWIG = *it;
+00772                 if (rWIG.CallerPtr == pIG)
+00773                 {
+00774                         if (rWIG.IGToLoad == NULL)
+00775                         {
+00776                                 UInstanceGroup::stopCreateInstanceGroupAsync(pIG);
+00777                         }
+00778                         // Ig must be initialized
+00779                         else if (rWIG.IGToLoad != (UInstanceGroup*)-1)
+00780                         {
+00781                                 switch(rWIG.IGToLoad->getAddToSceneState())
+00782                                 {
+00783                                         case UInstanceGroup::StateAdding:
+00784                                                 rWIG.IGToLoad->stopAddToSceneAsync();
+00785                                         break;
+00786                                         case UInstanceGroup::StateAdded:
+00787                                                 rWIG.IGToLoad->removeFromScene(*this);
+00788                                                 delete rWIG.IGToLoad;
+00789                                         break;
+00790                                         case UInstanceGroup::StateNotAdded:
+00791                                                 delete rWIG.IGToLoad;
+00792                                         break;
+00793                                 }
+00794                         }
+00795                         _WaitingIGs.erase(it);
+00796                         return;
+00797                 }
+00798         }               
+00799 }
+
+

+ + + + +
+ + + + + + + + + +
void NL3D::CSceneUser::updateWaitingIG  ) 
+
+ + + + + +
+   + + +

+should be called at each render +

+ +

+Definition at line 408 of file scene_user.cpp. +

+References _DriverUser, _WaitingIGs, NL3D_MEM_IG, and setToGlobalInstanceGroup(). +

+Referenced by updateWaitingInstances(). +

+

00409 {
+00410         NL3D_MEM_IG
+00411         for(TWaitingIGList::iterator it = _WaitingIGs.begin(); it != _WaitingIGs.end();)
+00412         {
+00413                 bool    erased= false;
+00414                 if (it->IGToLoad != NULL) // ig loaded ?
+00415                 {
+00416                         if (it->IGToLoad != (UInstanceGroup *) -1)
+00417                         {
+00418                                 switch (it->IGToLoad->getAddToSceneState())
+00419                                 {
+00420                                         case UInstanceGroup::StateNotAdded:
+00421                                                 // start loading
+00422                                                 if (it->Callback != NULL)
+00423                                                         it->Callback->InstanceGroupCreated(it->IGToLoad);
+00424                                                 it->IGToLoad->addToSceneAsync(*this, _DriverUser, it->SelectedTexture);
+00425                                         break;
+00426                                         case UInstanceGroup::StateAdded:
+00427                                                 it->IGToLoad->setPos(it->Pos);
+00428                                                 it->IGToLoad->setRotQuat(it->Rot);
+00429                                                 this->setToGlobalInstanceGroup(it->IGToLoad);
+00430                                                 *it->CallerPtr = it->IGToLoad;
+00431                                                 // remove from list
+00432                                                 it = _WaitingIGs.erase(it);
+00433                                                 erased= true;
+00434                                         break;
+00435                                         case UInstanceGroup::StateError:
+00436                                                 delete it->IGToLoad;
+00437                                                 it->IGToLoad = (UInstanceGroup *) -1;
+00438                                                 *it->CallerPtr = it->IGToLoad;
+00439                                                 // remove from list
+00440                                                 it = _WaitingIGs.erase(it);
+00441                                                 erased= true;
+00442                                         break;
+00443                                         default:
+00444                                         break;
+00445                                 }
+00446                         }
+00447                         else
+00448                         {
+00449                                 // loading failed
+00450                                 *it->CallerPtr = it->IGToLoad;
+00451                                 it = _WaitingIGs.erase(it);
+00452                                 erased= true;
+00453                         }
+00454                 }
+00455                 // next IG.
+00456                 if(!erased)
+00457                         it++;
+00458         }
+00459 }
+
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CSceneUser::updateWaitingInstances double  ellapsedTime  )  [virtual]
+
+ + + + + +
+   + + +

+Update waiting instances and igs that are loaded asynchronously NB: this is called by render()

Parameters:
+ + +
systemTimeEllapsed : the time between 2 calls to updateWaitingInstances, in seconds
+
+ +

+Implements NL3D::UScene. +

+Definition at line 569 of file scene_user.cpp. +

+References NL3D_MEM_INSTANCE, updateWaitingInstances(), and NL3D::CScene::updateWaitingInstances(). +

+

00570 {
+00571         NL3D_MEM_INSTANCE
+00572         _Scene.updateWaitingInstances(ellapsedTime);
+00573         updateWaitingInstances();
+00574 }
+
+

+ + + + +
+ + + + + + + + + +
void NL3D::CSceneUser::updateWaitingInstances  )  [private, virtual]
+
+ + + + + +
+   + + +

+update async loading during a call to render +

+ +

+Definition at line 578 of file scene_user.cpp. +

+References _Transforms, NL3D::CPtrSet< T >::insert(), NL3D_HAUTO_ASYNC_IG, NL3D_MEM_INSTANCE, and updateWaitingIG(). +

+Referenced by render(), and updateWaitingInstances(). +

+

00579 {
+00580         NL3D_MEM_INSTANCE
+00581         // Update waiting instances
+00582         {
+00583                 NL3D_HAUTO_ASYNC_IG
+00584 
+00585                 // Done after the _Scene.render because in this method the instance are checked for creation
+00586                 std::map<UInstance**,CTransformShape*>::iterator it = _WaitingInstances.begin();
+00587                 while( it != _WaitingInstances.end() )
+00588                 {
+00589                         if( it->second != NULL )
+00590                         {
+00591                                 *(it->first) = dynamic_cast<UInstance*>( _Transforms.insert(new CInstanceUser(&_Scene, it->second, true)) );
+00592                                 std::map<UInstance**,CTransformShape*>::iterator delIt = it;
+00593                                 ++it;
+00594                                 _WaitingInstances.erase(delIt);
+00595                         }
+00596                         else
+00597                         {
+00598                                 ++it;
+00599                         }
+00600                 }
+00601         }
+00602 
+00603         // update waiting instances groups;
+00604         {
+00605                 NL3D_HAUTO_ASYNC_IG
+00606 
+00607                 updateWaitingIG();
+00608         }       
+00609 }
+
+


Field Documentation

+

+ + + + +
+ + +
TAnimationSetSet NL3D::CSceneUser::_AnimationSets [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 89 of file scene_user.h. +

+Referenced by createAnimationSet(), and deleteAnimationSet().

+

+ + + + +
+ + +
TCloudScapeSet NL3D::CSceneUser::_CloudScapes [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 86 of file scene_user.h. +

+Referenced by createCloudScape(), deleteCloudScape(), and ~CSceneUser().

+

+ + + + +
+ + +
CCameraUser* NL3D::CSceneUser::_CurrentCamera [protected] +
+
+ + + + + +
+   + + +

+The Current camera. +

+ +

+Definition at line 73 of file scene_user.h. +

+Referenced by CSceneUser(), deleteCamera(), getCam(), render(), setCam(), and ~CSceneUser().

+

+ + + + +
+ + +
CDriverUser* NL3D::CSceneUser::_DriverUser [protected] +
+
+ + + + + +
+   + + +

+The driver which owns this scene. +

+ +

+Definition at line 69 of file scene_user.h. +

+Referenced by CSceneUser(), render(), updateWaitingIG(), and ~CSceneUser().

+

+ + + + +
+ + +
TInstanceGroupSet NL3D::CSceneUser::_InstanceGroups [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 87 of file scene_user.h.

+

+ + + + +
+ + +
TLandscapeSet NL3D::CSceneUser::_Landscapes [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 85 of file scene_user.h. +

+Referenced by createLandscape(), deleteLandscape(), and ~CSceneUser().

+

+ + + + +
+ + +
TPlayListManagerSet NL3D::CSceneUser::_PlayListManagers [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 90 of file scene_user.h. +

+Referenced by createPlayListManager(), and deletePlayListManager().

+

+ + + + +
+ + +
CScene NL3D::CSceneUser::_Scene [protected] +
+
+ + + + + +
+   + + +

+The Scene. +

+ +

+Definition at line 71 of file scene_user.h.

+

+ + + + +
+ + +
TTransformSet NL3D::CSceneUser::_Transforms [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 84 of file scene_user.h. +

+Referenced by createCamera(), createInstance(), createPointLight(), createSkeleton(), createTransform(), deleteCamera(), deleteInstance(), deletePointLight(), deleteSkeleton(), deleteTransform(), updateWaitingInstances(), and ~CSceneUser().

+

+ + + + +
+ + +
TVisualCollisionManagerSet NL3D::CSceneUser::_VisualCollisionManagers [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 88 of file scene_user.h. +

+Referenced by createVisualCollisionManager(), deleteVisualCollisionManager(), and ~CSceneUser().

+

+ + + + +
+ + +
TWaitingIGList NL3D::CSceneUser::_WaitingIGs [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 108 of file scene_user.h. +

+Referenced by createInstanceGroupAndAddToSceneAsync(), stopCreatingAndAddingIG(), and updateWaitingIG().

+

+ + + + +
+ + +
std::map<UInstance**,CTransformShape*> NL3D::CSceneUser::_WaitingInstances [protected] +
+
+ + + + + +
+   + + +

+ +

+Definition at line 92 of file scene_user.h.

+


The documentation for this class was generated from the following files: +
Generated on Tue Mar 16 07:40:53 2004 for NeL by + +doxygen +1.3.6
+ + -- cgit v1.2.1