scene.h

Go to the documentation of this file.

/* Copyright, 2000 Nevrax Ltd.
 *
 * This file is part of NEVRAX NEL.
 * NEVRAX NEL is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.

 * NEVRAX NEL is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with NEVRAX NEL; see the file COPYING. If not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

#ifndef NL_SCENE_H
#define NL_SCENE_H


#include "nel/3d/camera.h"
#include "nel/3d/shape.h"
#include "nel/3d/animated_lightmap.h"
#include "nel/3d/play_list_manager.h"
#include "nel/3d/quad_grid_clip_manager.h"
#include "nel/3d/particle_system_manager.h"
#include "nel/3d/animation_set.h"
// The traversals
#include "nel/3d/hrc_trav.h"
#include "nel/3d/clip_trav.h"
#include "nel/3d/anim_detail_trav.h"
#include "nel/3d/load_balancing_trav.h"
#include "nel/3d/light_trav.h"
#include "nel/3d/render_trav.h"
#include "nel/3d/flare_model.h"

#include "nel/3d/viewport.h"
#include "nel/3d/u_scene.h"

#include "nel/misc/rgba.h"
#include "nel/misc/smart_ptr.h"

// Debug : Sept 01 2006
#include "nel/3d/skeleton_spawn_script.h"

#include <map>
#include <list>

namespace NL3D
{

using   NLMISC::CRefPtr;
using   NLMISC::CSmartPtr;

class   CTransform;
class   CTransformShape;
class   IDriver;
class   CShapeBank;
class   CCoarseMeshManager;
class   CInstanceGroup;
class   CLodCharacterManager;
class   CAsyncTextureManager;
class   CSkeletonModel;
class   CRootModel;
class   CVisualCollisionManager;
class   CTextureCube;
class   CWaterEnvMap;

// ***************************************************************************
class CScene
{
public:



    static void     registerBasics();

    static  void    registerModel(const NLMISC::CClassId &idModel, const NLMISC::CClassId &idModelBase, CTransform* (*creator)());





    CScene(bool bSmallScene);
    ~CScene();
    void            initDefaultRoots();
    void            initQuadGridClipManager ();
    void            setDriver(IDriver *drv);
    IDriver         *getDriver() const;


    void            release();




    void            render(bool doHrcPass=true);

    void            beginPartRender();
    void            renderPart(UScene::TRenderPart rp, bool doHrcPass=true);
    void            endPartRender();



    void            updateWaitingInstances(double systemTimeEllapsed);




    void            setCam(CCamera *cam) {CurrentCamera= cam;}
    CCamera         *getCam() {return CurrentCamera;}
    void            setViewport(const class CViewport& viewport)
    {
        _Viewport=viewport;
    }
    CViewport       getViewport()
    {
        return _Viewport;
    }

    CInstanceGroup *findCameraClusterSystemFromRay(CInstanceGroup *startClusterSystem,
        const NLMISC::CVector &startPos, NLMISC::CVector &endPos);




    CTransform      *createModel(const NLMISC::CClassId &idModel);

    void            deleteModel(CTransform *model);




    void            setShapeBank(CShapeBank*pShapeBank);

    CShapeBank   *getShapeBank(void) { return _ShapeBank ; }

    const CShapeBank   *getShapeBank(void) const { return _ShapeBank ; }

    CTransformShape *createInstance(const std::string &shapeName);

    void            createInstanceAsync(const std::string &shapeName, CTransformShape **pInstance, const NLMISC::CVector &position, uint selectedTexture);

    void            deleteInstance(CTransformShape*model);


    CInstanceGroup *getGlobalInstanceGroup() { return _GlobalInstanceGroup; }


    void    animate (TGlobalAnimationTime atTime);
    void    addInstanceGroupForLightAnimation(CInstanceGroup *ig);
    void    removeInstanceGroupForLightAnimation(CInstanceGroup *ig);
    // TODO:
    // TurnOff/TurnOn
    // Animate
    //CLight* addStaticLight(CLight*); // Generate Light Map
    //void addDynamicLight(CLight*); // ??? Vertex lighting



    TGlobalAnimationTime getCurrentTime(void) const { return _CurrentTime ; }

    TAnimationTime      getEllapsedTime(void) const { return _EllapsedTime ; }

    double              getCurrentSystemTime() const {return _GlobalSystemTime;}

    double              getEllapsedSystemTime() const { return _DeltaSystemTimeBetweenRender;}

    uint64              getNumRender() const { return _NumRender; }

    bool                isRendering() const {return _IsRendering;}



    float                   getNbFaceAsked () const;


    void                    setGroupLoadMaxPolygon(const std::string &group, uint nFaces);
    uint                    getGroupLoadMaxPolygon(const std::string &group);
    float                   getGroupNbFaceAsked (const std::string &group) const;


    enum            TPolygonBalancingMode {PolygonBalancingOff=0, PolygonBalancingOn, PolygonBalancingClamp, CountPolygonBalancing};

    void                    setPolygonBalancingMode(TPolygonBalancingMode polBalMode);
    TPolygonBalancingMode   getPolygonBalancingMode() const;


    void                    setMaxSkeletonsInNotCLodForm(uint m) {_MaxSkeletonsInNotCLodForm= m;}
    uint                    getMaxSkeletonsInNotCLodForm() const {return _MaxSkeletonsInNotCLodForm;}



    CCoarseMeshManager      *getCoarseMeshManager ()
    {
        return _CoarseMeshManager;
    }

    void                    setCoarseMeshLightingUpdate(uint8 period);

    uint8                   getCoarseMeshLightingUpdate() const {return _CoarseMeshLightingUpdate;}

    CLodCharacterManager    *getLodCharacterManager () const    {return _LodCharacterManager;}
    void                    setLodCharacterManager(CLodCharacterManager *m) {_LodCharacterManager= m;}





        void  setLayersRenderingOrder(bool directOrder = true);
        bool  getLayersRenderingOrder() const;




    void            enableLightingSystem(bool enable);

    bool            isLightingSystemEnabled() const {return _LightingSystemEnabled;}

    void            setAmbientGlobal(NLMISC::CRGBA ambient);
    void            setSunAmbient(NLMISC::CRGBA ambient);
    void            setSunDiffuse(NLMISC::CRGBA diffuse);
    void            setSunSpecular(NLMISC::CRGBA specular);
    void            setSunDirection(const NLMISC::CVector &direction);
    void            setLightGroupColor(uint lightmapGroup, NLMISC::CRGBA color);


    NLMISC::CRGBA   getAmbientGlobal() const;
    NLMISC::CRGBA   getSunAmbient() const;
    NLMISC::CRGBA   getSunDiffuse() const;
    NLMISC::CRGBA   getSunSpecular() const;
    NLMISC::CVector getSunDirection() const;
    uint            getNumLightGroup () const
    {
        return _LightGroupColor.size ();
    }
    NLMISC::CRGBA   getLightmapGroupColor(uint lightGroup) const
    {
        if (lightGroup<_LightGroupColor.size())
            return _LightGroupColor[lightGroup];
        else
            return CRGBA::White;
    }
    NLMISC::CRGBA   getAnimatedLightFactor (sint animatedLightmap, uint lightGroup) const
    {
        if (((uint)animatedLightmap)<_AnimatedLightPtr.size ())
        {
            return _AnimatedLightPtr[animatedLightmap]->getFactor (lightGroup);
        }
        else
        {
            return getLightmapGroupColor (lightGroup);
        }
    }
    sint            getAnimatedLightNameToIndex (const std::string &name) const;

    void        setMaxLightContribution(uint nlights);
    uint        getMaxLightContribution() const;

    void        setLightTransitionThreshold(float lightTransitionThreshold);
    float       getLightTransitionThreshold() const;






    void            setGlobalWindPower(float gwp);
    float           getGlobalWindPower() const {return _GlobalWindPower;}

    void            setGlobalWindDirection(const CVector &gwd);
    const CVector   &getGlobalWindDirection() const {return _GlobalWindDirection;}




    CHrcTrav            &getHrcTrav() {return HrcTrav;}
    CClipTrav           &getClipTrav() {return ClipTrav;}
    CLightTrav          &getLightTrav() {return LightTrav;}
    CAnimDetailTrav     &getAnimDetailTrav() {return AnimDetailTrav;}
    CLoadBalancingTrav  &getLoadBalancingTrav() {return LoadBalancingTrav;}
    CRenderTrav         &getRenderTrav() {return RenderTrav;}

    CTransform          *getRoot() const {return Root;}
    CCluster            *getRootCluster() const {return RootCluster;}



    CParticleSystemManager &getParticleSystemManager();


    void                setAutomaticAnimationSet(CAnimationSet *as);

    CAnimationSet       *getAutomaticAnimationSet() const { return _AutomaticAnimationSet; }


    CAsyncTextureManager        *getAsyncTextureManager() const {return _AsyncTextureManager;}
    void                        setAsyncTextureManager(CAsyncTextureManager *mgr) {_AsyncTextureManager= mgr;}

    // @{
    void                enableElementRender(UScene::TRenderFilter elt, bool state);
    uint32              getFilterRenderFlags() const {return _FilterRenderFlags;}
    // @}

    // @{
    typedef std::list<CSkeletonModel*>      TSkeletonModelList;
    typedef TSkeletonModelList::iterator    ItSkeletonModelList;
    ItSkeletonModelList         appendSkeletonModelToList(CSkeletonModel *skel);
    void                        eraseSkeletonModelToList(ItSkeletonModelList    it);
    ItSkeletonModelList         getSkeletonModelListBegin() {return _SkeletonModelList.begin();}
    ItSkeletonModelList         getSkeletonModelListEnd() {return _SkeletonModelList.end();}

    typedef std::list<CTransform*>              TShadowCasterList;
    typedef TShadowCasterList::iterator         ItShadowCasterList;
    void                        registerShadowCasterToList(CTransform *sc);
    void                        unregisterShadowCasterToList(CTransform *sc);
    ItShadowCasterList          getShadowCasterListBegin() {return _ShadowCasterList.begin();}
    ItShadowCasterList          getShadowCasterListEnd() {return _ShadowCasterList.end();}

    void                        addSSSModelRequest(const CSSSModelRequest &req);

    // @}


    // @{

    // Enable Profiling for the next render(). Reset All stats.
    void                        profileNextRender();
    bool                        isNextRenderProfile() const {return _NextRenderProfile;}

    // Result profiling
    UScene::CBenchResults       BenchRes;
    // increment with the current VBufferFormat
    void                            incrementProfileTriVBFormat(std::map<uint32, uint32> &formatToTri, uint32 vbFormat, uint32 numTris)
    {
        std::map<uint32, uint32>::iterator  it= formatToTri.find(vbFormat);
        if(it==formatToTri.end())
        {
            it= formatToTri.insert(std::make_pair(vbFormat,0)).first;
        }
        it->second+= numTris;
    }

    // @}

    // @{
        // The max number of contexts for flares
        enum { MaxNumFlareContexts = CFlareModel::MaxNumContext };
        // Set the current context for flares. context must be < to MaxNumFlareContexts
        void    setFlareContext(uint context) { nlassert(context < MaxNumFlareContexts); _FlareContext = context; }
        // Get the current context for flares
        uint    getFlareContext() const { return _FlareContext; }
    // @}


    // @{
    uint            getShadowMapTextureSize() const {return _ShadowMapTextureSize;}
    void            setShadowMapTextureSize(uint size);
    uint            getShadowMapBlurSize() const {return _ShadowMapBlurSize;}
    void            setShadowMapBlurSize(uint bs);
    void            enableShadowPolySmooth(bool enable);
    bool            getEnableShadowPolySmooth() const;

    void            setShadowMapDistFadeStart(float dist);
    float           getShadowMapDistFadeStart() const {return _ShadowMapDistFadeStart;}
    void            setShadowMapDistFadeEnd(float dist);
    float           getShadowMapDistFadeEnd() const {return _ShadowMapDistFadeEnd;}
    void            setShadowMapMaxCasterInScreen(uint num);
    uint            getShadowMapMaxCasterInScreen() const {return _ShadowMapMaxCasterInScreen;}
    void            setShadowMapMaxCasterAround(uint num);
    uint            getShadowMapMaxCasterAround() const {return _ShadowMapMaxCasterAround;}

    void                    setVisualCollisionManagerForShadow(CVisualCollisionManager *vcm) {_VisualCollisionManagerForShadow= vcm;}
    CVisualCollisionManager *getVisualCollisionManagerForShadow() const {return _VisualCollisionManagerForShadow;}
    // @}

    void            setWaterCallback(IWaterSurfaceAddedCallback *wcb) { _WaterCallback = wcb; }
    IWaterSurfaceAddedCallback *getWaterCallback() const { return _WaterCallback; }

    void            setLandscapePolyDrawingCallback(ILandscapePolyDrawingCallback *lpd)
    { _PolyDrawingCallback = lpd;}
    ILandscapePolyDrawingCallback *getLandscapePolyDrawingCallback() const { return _PolyDrawingCallback;}

    // Add a new occlusion query object that must be tested at the end of the rendering
    void            insertInOcclusionQueryList(CFlareModel *fm)
    {
        fm->Next = _FirstFlare;
        _FirstFlare = fm;
    }

    // debugging aid : draw all occlusion test mesh that are used by flares
    void            renderOcclusionTestMeshs();

    // Set a water envmap to be used with water surfaces in that scene. Water envmap may be shared accross several scenes.
    void          setWaterEnvMap(CWaterEnvMap *waterEnvMap) { _WaterEnvMap = waterEnvMap; }
    // Get currenlty used water envmap for that scene.
    CWaterEnvMap *getWaterEnvMap() const { return _WaterEnvMap; }
    void          updateWaterEnvMaps(TGlobalAnimationTime time);
    // Get vertex buffer used for water rendering
    CVertexBuffer &getWaterVB() { return _WaterVB; }
private:

    CRefPtr<CCamera>    CurrentCamera;
    CViewport       _Viewport;

    // the current time
    TGlobalAnimationTime  _CurrentTime ;

    // the real time
    TGlobalAnimationTime  _RealTime;
    TGlobalAnimationTime  _InitTime;

    // true when its the first call of animate
    bool _FirstAnimateCall ;

    // the ellapsed time
    TAnimationTime  _EllapsedTime ;

    // System time is a time that always run (independent from the animation time that run only on animate())
    double  _DeltaSystemTimeBetweenRender;
    double  _GlobalSystemTime;
    uint64  _NumRender; // the number of time render has been called



    CHrcTrav            HrcTrav;
    CClipTrav           ClipTrav;
    CLightTrav          LightTrav;
    CAnimDetailTrav     AnimDetailTrav;
    CLoadBalancingTrav  LoadBalancingTrav;
    CRenderTrav         RenderTrav;

    // The root models (will be deleted by CScene).
    CTransform          *Root;
    // The Root Cluster
    CCluster            *RootCluster;
    // This model is used to clip any model which has a Skeleton ancestor
    CRootModel          *SonsOfAncestorSkeletonModelGroup;


    // The Ligths automatic movements

    std::map<std::string, uint>                 _AnimatedLightNameToIndex;
    std::list<CAnimatedLightmap>                _AnimatedLight;
    std::vector<CAnimatedLightmap*>             _AnimatedLightPtr;
    CPlayListManager _LMAnimsAuto;

    /* Lightmap factor for each lightmap group.
     * size() must be == to CAnimatedLightmap::_GroupColor.size () */
    std::vector<NLMISC::CRGBA>      _LightGroupColor;

    // List of InstanceGroup to animate PointLightFactor.
    typedef std::set<CInstanceGroup*>   TAnimatedIgSet;
    typedef TAnimatedIgSet::iterator    ItAnimatedIgSet;
    TAnimatedIgSet  _AnimatedIgSet;


    CShapeBank      *_ShapeBank;

    typedef std::multimap<std::string,CTransformShape**> TWaitingInstancesMMap;
    TWaitingInstancesMMap _WaitingInstances;

    CInstanceGroup* _GlobalInstanceGroup;


    // The Coarse Mesh Manager. Owned by the scene
    CCoarseMeshManager          *_CoarseMeshManager;
    // CLodCharacterManager is not a model. setuped by user
    CLodCharacterManager        *_LodCharacterManager;


    CQuadGridClipManager        *_QuadGridClipManager;


    // Lighting.
    bool                        _LightingSystemEnabled;

    uint8                       _CoarseMeshLightingUpdate;


        CParticleSystemManager  _ParticleSystemManager;



    float                       _GlobalWindPower;
    CVector                     _GlobalWindDirection;


    // A set of automatic animation
    NLMISC::CSmartPtr<CAnimationSet>            _AutomaticAnimationSet;


    // The async texture manager, setuped by the user.
    CAsyncTextureManager        *_AsyncTextureManager;


    // List of skeletons in the scene
    TSkeletonModelList          _SkeletonModelList;
    // Max Skeleton displayed as std.
    uint                        _MaxSkeletonsInNotCLodForm;

    // Render filtering
    uint32                      _FilterRenderFlags;

    // profile
    bool                        _NextRenderProfile;

    IWaterSurfaceAddedCallback  *_WaterCallback;

    ILandscapePolyDrawingCallback * _PolyDrawingCallback;


    CFlareModel *_FirstFlare; // first flare to test for occlusion query

    // List of shadow casters in the scene
    TShadowCasterList           _ShadowCasterList;

// ******************
private:
    struct  CModelEntry
    {
        NLMISC::CClassId    ModelId, BaseModelId;
        CTransform* (*Creator)();
        bool    operator<(const CModelEntry& o) const {return ModelId<o.ModelId;}
        bool    operator==(const CModelEntry& o) const {return ModelId==o.ModelId;}
        bool    operator!=(const CModelEntry& o) const {return !(*this==o);}
    };


private:
    // must do this for _UpdateModelList access.
    friend  class CTransform;
    friend  class CClipTrav;

    std::set<CTransform*>               _Models;
    CTransform                          *_UpdateModelList;

    static std::set<CModelEntry>    _RegModels;

    void            updateModels();

    // current context for rendering of flares
    uint            _FlareContext;

    // ShadowMap Options
    uint            _ShadowMapTextureSize;
    uint            _ShadowMapBlurSize;
    float           _ShadowMapDistFadeStart;
    float           _ShadowMapDistFadeEnd;
    uint            _ShadowMapMaxCasterInScreen;
    uint            _ShadowMapMaxCasterAround;
    CVisualCollisionManager     *_VisualCollisionManagerForShadow;

    // Delayed model delete
    bool            _IsRendering;
    std::vector<CTransform*>    _ToDelete;

    UScene::TRenderPart _RenderedPart;
    void    renderOcclusionTestMeshsWithCurrMaterial();
    CWaterEnvMap    *_WaterEnvMap;
    std::vector<CSSSModelRequest>       _SSSModelRequests;
    void                                    flushSSSModelRequests();
    // common vb for water display
    CVertexBuffer    _WaterVB;


};



}


#endif // NL_SCENE_H

/* End of scene.h */