u_scene.h

Go to the documentation of this file.
00001 
00005 /* Copyright, 2001 Nevrax Ltd.
00006  *
00007  * This file is part of NEVRAX NEL.
00008  * NEVRAX NEL is free software; you can redistribute it and/or modify
00009  * it under the terms of the GNU General Public License as published by
00010  * the Free Software Foundation; either version 2, or (at your option)
00011  * any later version.
00012 
00013  * NEVRAX NEL is distributed in the hope that it will be useful, but
00014  * WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00016  * General Public License for more details.
00017 
00018  * You should have received a copy of the GNU General Public License
00019  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00020  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00021  * MA 02111-1307, USA.
00022  */
00023 
00024 #ifndef NL_U_SCENE_H
00025 #define NL_U_SCENE_H
00026 
00027 #include "nel/misc/types_nl.h"
00028 #include "nel/misc/quat.h"
00029 #include "animation_time.h"
00030 #include <map>
00031 
00032 
00033 namespace NLMISC
00034 {
00035 class CRGBA;
00036 class CVector;
00037 class CPolygon2D;
00038 class CMatrix;
00039 };
00040 
00041 namespace NL3D
00042 {
00043 
00044 
00045 class UCamera;
00046 class UInstance;
00047 class ULandscape;
00048 class UCloudScape;
00049 class UInstanceGroup;
00050 class USkeleton;
00051 class UTransform;
00052 class UVisualCollisionManager;
00053 class UAnimationSet;
00054 class UPlayListManager;
00055 class UPointLight;
00056 class UWaterEnvMap;
00057 
00058 
00059 //****************************************************************************
00060 // useful callback for createInstanceGroupAndAddToSceneAsync
00061 class IAsyncLoadCallback
00062 {
00063 public:
00064     virtual ~IAsyncLoadCallback() {}
00067     virtual void InstanceGroupCreated(UInstanceGroup *newVal) = 0;
00068 };
00069 
00070 // callback to know when a water surface is added
00071 class IWaterSurfaceAddedCallback
00072 {
00073 public:
00074     virtual ~IWaterSurfaceAddedCallback() {}
00075     // A water surface with the given height has been added.
00076     virtual void waterSurfaceAdded(const NLMISC::CPolygon2D &shape, const NLMISC::CMatrix &worldMatrix, bool splashEnabled, bool usesSceneWaterenvmap) = 0;
00077     virtual void waterSurfaceRemoved(bool usesSceneWaterenvmap) = 0;
00078 };
00079 
00080 // callback to setup stencil buffer before and after landscape render
00081 class ILandscapePolyDrawingCallback
00082 {
00083 public:
00084     virtual ~ILandscapePolyDrawingCallback() {}
00085     virtual void beginPolyDrawing() = 0;
00086     virtual void endPolyDrawing() = 0;
00087 };
00088 
00089 
00090 //****************************************************************************
00102 class UScene
00103 {
00104 protected:
00105 
00107     // @{
00108     UScene() {}
00109     virtual ~UScene() {}
00110     // @}
00111 
00112 public:
00113     enum TRenderPart
00114     {
00115         RenderNothing     = 0,
00116         RenderOpaque      = 0x01,
00117         RenderTransparent = 0x02,
00118         RenderFlare       = 0x04,
00119         RenderAll = RenderOpaque | RenderTransparent | RenderFlare
00120     };
00121 
00122 
00124 
00125 
00132     virtual void            render(bool updateWaitingInstances = true, bool restoreMatrixContextAfterRender = true)=0;
00133 
00139     virtual void            beginPartRender() =0;
00140 
00147     virtual void            renderPart(UScene::TRenderPart rp) =0;
00148 
00151     virtual void            endPartRender(bool updateWaitingInstances = true, bool restoreMatrixContextAfterRender = true) =0;
00152 
00153 
00158     virtual void            updateWaitingInstances(double systemTimeEllapsed) = 0;
00159 
00160 
00164     virtual void            animate (TGlobalAnimationTime time) =0;
00165 
00167 
00168 
00170 
00171 
00172     virtual void            setCam(UCamera cam)=0;
00174     virtual UCamera         getCam()=0;
00176     virtual void            setViewport(const class CViewport& viewport)=0;
00178     virtual CViewport       getViewport()=0;
00179 
00186     virtual UInstanceGroup  *findCameraClusterSystemFromRay(UInstanceGroup *startClusterSystem,
00187         const NLMISC::CVector &startPos, NLMISC::CVector &endPos) =0;
00189 
00190 
00192 
00196 
00198     virtual UCamera         createCamera()=0;
00200     virtual void            deleteCamera(UCamera &cam)=0;
00201 
00206     virtual UInstance       createInstance(const std::string &shapeName)=0;
00210     virtual void            createInstanceAsync(const std::string &shapeName,UInstance *ppInstance, const NLMISC::CVector &position, uint selectedTexture)=0;
00213     virtual void            deleteInstance(UInstance &inst)=0;
00214 
00219     virtual void createInstanceGroupAndAddToSceneAsync (const std::string &instanceGroup,
00220                                                         UInstanceGroup **pIG,
00221                                                         const NLMISC::CVector &pos,
00222                                                         const NLMISC::CQuat &rot,
00223                                                         uint selectedTexture,
00224                                                         IAsyncLoadCallback *pCB = NULL
00225                                                        ) = 0;
00226 
00230     virtual void stopCreatingAndAddingIG(UInstanceGroup **pIG) = 0;
00231 
00234     virtual void deleteInstanceGroup(UInstanceGroup *pIG) = 0;
00235 
00238     virtual UTransform      createTransform()=0;
00241     virtual void            deleteTransform(UTransform &tr)=0;
00242 
00247     virtual USkeleton       createSkeleton(const std::string &shapeName)=0;
00250     virtual void            deleteSkeleton(USkeleton &skel)=0;
00251 
00253     virtual ULandscape      *createLandscape()=0;
00255     virtual void            deleteLandscape(ULandscape *land)=0;
00256 
00258     virtual UCloudScape     *createCloudScape()=0;
00260     virtual void            deleteCloudScape(UCloudScape *cs)=0;
00261 
00265     virtual void setToGlobalInstanceGroup(UInstanceGroup *pIGU) = 0;
00266     //virtual   UInstanceGroup  *createInstanceGroup(const std::string &instanceGroup) =0;
00268     //virtual   void            deleteInstanceGroup(UInstanceGroup  *group) =0;
00269 
00270 
00272     virtual UPointLight     createPointLight()=0;
00274     virtual void            deletePointLight(UPointLight &light)=0;
00275 
00276 
00278 
00280     // @{
00282     virtual UPlayListManager    *createPlayListManager() =0;
00284     virtual void                deletePlayListManager(UPlayListManager *playListManager) =0;
00287     virtual void                setAutomaticAnimationSet(UAnimationSet *as) = 0;
00288     // @}
00289 
00291 
00292     virtual UVisualCollisionManager     *createVisualCollisionManager() =0;
00293     virtual void                        deleteVisualCollisionManager(UVisualCollisionManager *mgr) =0;
00295 
00296 
00298 
00299 
00307     enum            TPolygonBalancingMode {PolygonBalancingOff=0, PolygonBalancingOn, PolygonBalancingClamp, CountPolygonBalancing };
00308 
00310     virtual void                setPolygonBalancingMode(TPolygonBalancingMode polBalMode) =0;
00312     virtual TPolygonBalancingMode   getPolygonBalancingMode() const =0;
00313 
00314 
00318     virtual float               getNbFaceAsked () const =0;
00319 
00320 
00324     virtual void                setGroupLoadMaxPolygon(const std::string &group, uint nFaces) =0;
00328     virtual uint                getGroupLoadMaxPolygon(const std::string &group) =0;
00332     virtual float               getGroupNbFaceAsked (const std::string &group) const =0;
00333 
00337     virtual void                setMaxSkeletonsInNotCLodForm(uint m) =0;
00339     virtual uint                getMaxSkeletonsInNotCLodForm() const =0;
00340 
00342 
00344 
00345 
00348     virtual void                setCoarseMeshManagerTexture (const char *sPath) =0;
00349 
00353     virtual void                setCoarseMeshLightingUpdate(uint8 period) =0;
00354 
00356     virtual uint8               getCoarseMeshLightingUpdate() const  =0;
00357 
00359 
00360 
00362 
00363 
00367     virtual void                enableLightingSystem(bool enable) =0;
00368 
00369 
00371     virtual void                setAmbientGlobal(NLMISC::CRGBA ambient) =0;
00373     virtual void                setSunAmbient(NLMISC::CRGBA ambient) =0;
00375     virtual void                setSunDiffuse(NLMISC::CRGBA diffuse) =0;
00377     virtual void                setSunSpecular(NLMISC::CRGBA specular) =0;
00379     virtual void                setSunDirection(const NLMISC::CVector &direction) =0;
00381     virtual void                setLightGroupColor(uint lightmapGroup, NLMISC::CRGBA color) =0;
00382 
00383 
00385     virtual NLMISC::CRGBA       getAmbientGlobal() const =0;
00387     virtual NLMISC::CRGBA       getSunAmbient() const =0;
00389     virtual NLMISC::CRGBA       getSunDiffuse() const =0;
00391     virtual NLMISC::CRGBA       getSunSpecular() const =0;
00393     virtual NLMISC::CVector     getSunDirection() const =0;
00394 
00399     virtual void                setMaxLightContribution(uint nlights) =0;
00402     virtual uint                getMaxLightContribution() const =0;
00403 
00412     virtual void                setLightTransitionThreshold(float lightTransitionThreshold) =0;
00415     virtual float               getLightTransitionThreshold() const =0;
00416 
00417 
00419 
00420 
00422 
00423 
00429         virtual void  setLayersRenderingOrder(bool directOrder = true) = 0;
00430         virtual bool  getLayersRenderingOrder() const = 0;
00432 
00433 
00435 
00436 
00438     virtual void                setGlobalWindPower(float gwp) =0;
00440     virtual float               getGlobalWindPower() const =0;
00441 
00443     virtual void                setGlobalWindDirection(const NLMISC::CVector &gwd) =0;
00445     virtual const NLMISC::CVector       &getGlobalWindDirection() const =0;
00446 
00448 
00449 
00451 
00454 
00456     virtual void                resetCLodManager() =0;
00457 
00465     virtual uint32              loadCLodShapeBank(const std::string &fileName) =0;
00466 
00468     virtual void                deleteCLodShapeBank(uint32 bankId) =0;
00469 
00472     virtual sint32              getCLodShapeIdByName(const std::string &name) const =0;
00473 
00476     virtual sint32              getCLodAnimIdByName(uint32 shapeId, const std::string &name) const =0;
00477 
00479 
00480 
00486     // @{
00487         // Get the max number of contexts
00488         virtual uint getNumFlareContexts() const = 0;
00489         // Set the current context for flares. context must be < to MaxNumFlareContexts
00490         virtual void    setFlareContext(uint context) = 0;
00491         // Get the current context for flares
00492         virtual uint    getFlareContext() const = 0;
00493     // @}
00494 
00496     // @{
00497     enum    TRenderFilter
00498     {
00499         FilterLandscape=    0x00000001,
00500         FilterWater=        0x00000002,
00501         FilterMeshNoVP=     0x00000004,
00502         FilterMeshVP=       0x00000008,
00503         FilterMeshMRMNoVP=  0x00000010,
00504         FilterMeshMRMVP=    0x00000020,
00505         FilterMeshLodNoVP=  0x00000040,
00506         FilterMeshLodVP=    0x00000080,
00507         FilterSkeleton=     0x00000100,         // For skins, and also for sticked objects.
00508         FilterSegRemanence= 0x00000200,
00509         FilterPS=           0x00000400,
00510         FilterFlare=        0x00000800,
00511         FilterCoarseMesh=   0x00001000,         // Disable render of CoarseMesh (but not management through Meshs!)
00512 
00513         // Combos:
00514         FilterAllMeshNoVP=  FilterMeshNoVP + FilterMeshMRMNoVP + FilterMeshLodNoVP,
00515         FilterAllMeshVP=    FilterMeshVP + FilterMeshMRMVP + FilterMeshLodVP,
00516         FilterAllMesh=      FilterAllMeshNoVP+FilterAllMeshVP,
00517         FilterFX=           FilterSegRemanence + FilterPS + FilterFlare,
00518     };
00519 
00523     virtual void                enableElementRender(TRenderFilter elt, bool state) =0;
00524 
00526     struct  CBenchResults
00527     {
00528         std::map<uint32, uint32>                            MeshMRMProfileTriVBFormat;
00529         std::map<uint32, uint32>                            MeshProfileTriVBFormat;
00530         uint32                                              NumMeshRdrNormal;
00531         uint32                                              NumMeshRdrBlock;
00532         uint32                                              NumMeshRdrBlockWithVBHeap;
00533         uint32                                              NumMeshTriRdrNormal;
00534         uint32                                              NumMeshTriRdrBlock;
00535         uint32                                              NumMeshTriRdrBlockWithVBHeap;
00536         uint32                                              NumMeshMRMRdrNormal;
00537         uint32                                              NumMeshMRMRdrBlock;
00538         uint32                                              NumMeshMRMRdrBlockWithVBHeap;
00539         uint32                                              NumMeshMRMTriRdrNormal;
00540         uint32                                              NumMeshMRMTriRdrBlock;
00541         uint32                                              NumMeshMRMTriRdrBlockWithVBHeap;
00542         uint32                                              NumMeshVBufferStd;
00543         uint32                                              NumMeshVBufferHard;
00544         uint32                                              NumMeshMRMVBufferStd;
00545         uint32                                              NumMeshMRMVBufferHard;
00546 
00547         void    reset()
00548         {
00549             MeshMRMProfileTriVBFormat.clear();
00550             MeshProfileTriVBFormat.clear();
00551             NumMeshRdrNormal= 0;
00552             NumMeshRdrBlock= 0;
00553             NumMeshRdrBlockWithVBHeap= 0;
00554             NumMeshTriRdrNormal= 0;
00555             NumMeshTriRdrBlock= 0;
00556             NumMeshTriRdrBlockWithVBHeap= 0;
00557             NumMeshMRMRdrNormal= 0;
00558             NumMeshMRMRdrBlock= 0;
00559             NumMeshMRMRdrBlockWithVBHeap= 0;
00560             NumMeshMRMTriRdrNormal= 0;
00561             NumMeshMRMTriRdrBlock= 0;
00562             NumMeshMRMTriRdrBlockWithVBHeap= 0;
00563             NumMeshVBufferStd= 0;
00564             NumMeshVBufferHard= 0;
00565             NumMeshMRMVBufferStd= 0;
00566             NumMeshMRMVBufferHard= 0;
00567         }
00568     };
00569 
00571     virtual void                profileNextRender() =0;
00572 
00574     virtual void                getProfileResults(CBenchResults &results) =0;
00575 
00578     virtual void                profileQuadGridClipManager() =0;
00579 
00580     // @}
00581 
00582 
00584     // @{
00586     virtual uint            getShadowMapTextureSize() const =0;
00588     virtual void            setShadowMapTextureSize(uint size) =0;
00590     virtual uint            getShadowMapBlurSize() const =0;
00592     virtual void            setShadowMapBlurSize(uint bs) =0;
00594     virtual void            enableShadowPolySmooth(bool enable) =0;
00596     virtual bool            getEnableShadowPolySmooth() const =0;
00597 
00599     virtual void            setShadowMapDistFadeStart(float dist) =0;
00600     virtual float           getShadowMapDistFadeStart() const =0;
00602     virtual void            setShadowMapDistFadeEnd(float dist) =0;
00603     virtual float           getShadowMapDistFadeEnd() const =0;
00605     virtual void            setShadowMapMaxCasterInScreen(uint num) =0;
00606     virtual uint            getShadowMapMaxCasterInScreen() const =0;
00608     virtual void            setShadowMapMaxCasterAround(uint num) =0;
00609     virtual uint            getShadowMapMaxCasterAround() const =0;
00610 
00612     virtual void            setVisualCollisionManagerForShadow(UVisualCollisionManager *vcm) =0;
00613     // @}
00614 
00615     // set a callback to know when a water surface is instantiated
00616     virtual void            setWaterCallback(IWaterSurfaceAddedCallback *wcb) = 0;
00617     virtual IWaterSurfaceAddedCallback *getWaterCallback() const = 0;
00618 
00619 
00620     virtual void            setLandscapePolyDrawingCallback(ILandscapePolyDrawingCallback *lpd) = 0;
00621     virtual ILandscapePolyDrawingCallback *getLandscapePolyDrawingCallback() const = 0;
00622 
00631     virtual void setupTransparencySorting(uint8 maxPriority = 0, uint NbDistanceEntries = 1024) = 0;
00632 
00634     // @{
00638     virtual void          setWaterEnvMap(UWaterEnvMap *waterEnvMap) = 0;
00639     // Get currently used water envmap for that scene.
00640     virtual UWaterEnvMap *getWaterEnvMap() const = 0;
00644     virtual void          updateWaterEnvMaps(TGlobalAnimationTime time) = 0;
00645     // @}
00646 };
00647 
00648 } // NL3D
00649 
00650 #endif // NL_U_SCENE_H
00651 
00652 /* End of u_scene.h */

Generated on Thu Jan 7 08:26:21 2010 for NeL by  doxygen 1.6.1