render_trav.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_RENDER_TRAV_H
#define NL_RENDER_TRAV_H

#include "nel/3d/trav_scene.h"
#include "nel/3d/ordering_table.h"
#include "nel/3d/layered_ordering_table.h"
#include "nel/misc/rgba.h"
#include "nel/3d/viewport.h"
#include "nel/3d/light_contribution.h"
#include "nel/3d/light.h"
#include "nel/3d/mesh_block_manager.h"
#include "nel/3d/shadow_map_manager.h"
#include "nel/3d/u_scene.h"
#include <vector>


namespace   NL3D
{

using NLMISC::CVector;
using NLMISC::CPlane;
using NLMISC::CMatrix;

class   IDriver;
class   CMaterial;

class   CTransform;
class   CLandscapeModel;

class   CVertexStreamManager;
class   CWaterModel;

// ***************************************************************************
/* Skin Manager setup
 * For the moment, the skin manager vertex buffer routes all its UV channel to UV0.
 * See void CVertexStreamManager::init(IDriver *driver, uint vertexFormat, uint maxVertices)
 *  use 8 VBswap for minimal(=> no) lock() time. 2 is not enough (saw 7 ms lost because of this)
 *  => size of the manager is 1280 Ko
 *  NB: 5000 vertices max for a model is a strong limitation, but it's OK for now...
 */
#define NL3D_MESH_SKIN_MANAGER_VERTEXFORMAT     (CVertexBuffer::PositionFlag | CVertexBuffer::NormalFlag | CVertexBuffer::TexCoord0Flag)
#define NL3D_MESH_SKIN_MANAGER_MAXVERTICES      5000
#define NL3D_MESH_SKIN_MANAGER_NUMVB            8

/* Same for Shadow Generation.
 * NB: need much less Vertices because: 1/ foolish to do more. 2/ Only position=> no UV/Normal discontinuities.
 *  => size of the manager is 1.3 Mo
 *  use 8 VBswap for minimal(=> no) lock() time. 2 is not enough (saw 7 ms lost because of this)
 *  => size of the manager is 280 Ko
 */
#define NL3D_SHADOW_MESH_SKIN_MANAGER_VERTEXFORMAT      (CVertexBuffer::PositionFlag)
#define NL3D_SHADOW_MESH_SKIN_MANAGER_MAXVERTICES       3000
#define NL3D_SHADOW_MESH_SKIN_MANAGER_NUMVB             8



// ***************************************************************************
class CRenderTrav : public CTravCameraScene
{
public:

    CRenderTrav();



    void                traverse(UScene::TRenderPart renderPart, bool newRender);



    void            clearRenderList();
    void            addRenderModel(CTransform *m)
    {
        // for possible removeRenderModel()
        m->_IndexLSBInRenderList= uint8(_CurrentNumVisibleModels&255);
        // add the model in the list
        RenderList[_CurrentNumVisibleModels]= m;
        _CurrentNumVisibleModels++;
    }
    // for createModel().
    void            reserveRenderList(uint numModels);

    /* This is for the rare case where objects are deleted during CScene::render(). called by deleteModel()
     *  This method don't need to be called by ~CTransform
     */
    void            removeRenderModel(CTransform *m);

    void            clearWaterModelList();



    // setup the Driver for render
    void            setDriver(IDriver *drv) {Driver= drv;}
    IDriver         *getDriver() {return Driver;}
    // Yoyo: temporary. May be used later if we decide to support a PBuffer to render texture for ShadowMap
    IDriver         *getAuxDriver() {return Driver;}
    void            setViewport (const CViewport& viewport)
    {
        _Viewport = viewport;
    }
    CViewport       getViewport () const
    {
        return _Viewport;
    }

    bool isCurrentPassOpaque() { return _CurrentPassOpaque; }

    void  setLayersRenderingOrder(bool directOrder = true) { _LayersRenderingOrder = directOrder; }
    bool  getLayersRenderingOrder() const { return _LayersRenderingOrder; }

    void setupTransparencySorting(uint8 maxPriority = 0, uint NbDistanceEntries = 1024);



    // @{

    // False by default. setuped by CScene
    bool                        LightingSystemEnabled;

    // Global ambient. Default is (50,50,50).
    NLMISC::CRGBA               AmbientGlobal;
    // The Sun Setup.
    NLMISC::CRGBA               SunAmbient, SunDiffuse, SunSpecular;
    // set the direction of the sun. dir is normalized.
    void                        setSunDirection(const CVector &dir);
    const CVector               getSunDirection() const {return _SunDirection;}

    // @}


    void                        setMeshSkinManager(CVertexStreamManager *msm);

    CVertexStreamManager        *getMeshSkinManager() const {return _MeshSkinManager;}

    CShadowMapManager           &getShadowMapManager() {return _ShadowMapManager;}
    const CShadowMapManager     &getShadowMapManager() const {return _ShadowMapManager;}

    void                        setShadowMeshSkinManager(CVertexStreamManager *msm);
    CVertexStreamManager        *getShadowMeshSkinManager() const {return _ShadowMeshSkinManager;}


    // add a landscape. Special for CLandscapeModel::traverseRender();
    void            addRenderLandscape(CLandscapeModel *model);



    // Test Memory of water model render list (because someone crash it...)
    // Yoyo: this crash seems to be fixed, but i leave the code, in case of.....
    void            debugWaterModelMemory(const char *tag, bool dumpList= false);

// ******************
public:

    // @{

    // Max VP Light setup Infos.
    enum    {MaxVPLight= 4};

    void        resetLightSetup();

    void        changeLightSetup(CLightContribution *lightContribution, bool useLocalAttenuation);


    void        beginVPLightSetup(uint ctStart, bool supportSpecular, const CMatrix &invObjectWM);

    void        changeVPLightSetupMaterial(const CMaterial &mat, bool excludeStrongest);


    static  std::string     getLightVPFragment(uint numActivePointLights, uint ctStart, bool supportSpecular, bool normalize);

    const CLight  &getDriverLight(sint index) const
    {
        nlassert(index >= 0 && index < NL3D_MAX_LIGHT_CONTRIBUTION+1);
        return _DriverLight[index];
    }

    sint        getStrongestLightIndex() const;

    void        getStrongestLightColors(NLMISC::CRGBA &diffuse, NLMISC::CRGBA &specular);

    uint        getNumVPLights() const {return _VPNumLights;}

    // @}


    // @{

    CMeshBlockManager       MeshBlockManager;

    // @}

    // ReSetup the Driver Frustum/Camera. Called internally and by ShadowMapManager only.
    void            setupDriverCamera();

private:

    // A grow only list of models to be rendered.
    std::vector<CTransform*>    RenderList;
    uint32                      _CurrentNumVisibleModels;

    // Ordering Table to sort transparent objects
    COrderingTable<CTransform>          OrderOpaqueList;
    std::vector<CLayeredOrderingTable<CTransform> > _OrderTransparentListByPriority;
    uint8                                           _MaxTransparencyPriority;

    IDriver         *Driver;
    CViewport       _Viewport;

    // Temporary for the render
    bool            _CurrentPassOpaque;
    bool            _LayersRenderingOrder;


    // @{
    // The last setup.
    CLightContribution          *_CacheLightContribution;
    bool                        _LastLocalAttenuation;
    // The number of light enabled
    uint                        _NumLightEnabled;

    // More precise setup
    uint                        _LastSunFactor;
    NLMISC::CRGBA               _LastFinalAmbient;
    CPointLight                 *_LastPointLight[NL3D_MAX_LIGHT_CONTRIBUTION];
    uint8                       _LastPointLightFactor[NL3D_MAX_LIGHT_CONTRIBUTION];
    bool                        _LastPointLightLocalAttenuation[NL3D_MAX_LIGHT_CONTRIBUTION];

    CVector                     _SunDirection;

    // driver Lights setuped in changeLightSetup()
    CLight                      _DriverLight[NL3D_MAX_LIGHT_CONTRIBUTION+1];

    // index of the strongest light (when used)
    mutable uint                _StrongestLightIndex;
    mutable bool                _StrongestLightTouched;

    // Current ctStart setuped with beginVPLightSetup()
    uint                        _VPCurrentCtStart;
    // Current num of VP lights enabled.
    uint                        _VPNumLights;
    // Current support of specular
    bool                        _VPSupportSpecular;
    // Sum of all ambiant of all lights + ambiantGlobal.
    NLMISC::CRGBAF              _VPFinalAmbient;
    // Diffuse/Spec comp of all light / 255.
    NLMISC::CRGBAF              _VPLightDiffuse[MaxVPLight];
    NLMISC::CRGBAF              _VPLightSpecular[MaxVPLight];

    NLMISC::CRGBA               _StrongestLightDiffuse;
    NLMISC::CRGBA               _StrongestLightSpecular;

    // Cache for changeVPLightSetupMaterial()
    bool                        _VPMaterialCacheDirty;
    uint32                      _VPMaterialCacheEmissive;
    uint32                      _VPMaterialCacheAmbient;
    uint32                      _VPMaterialCacheDiffuse;
    uint32                      _VPMaterialCacheSpecular;
    float                       _VPMaterialCacheShininess;

    // @}


    CVertexStreamManager        *_MeshSkinManager;


    CShadowMapManager           _ShadowMapManager;
    CVertexStreamManager        *_ShadowMeshSkinManager;


    // clear the list
    void            clearRenderLandscapeList();
    // render the landscapes
    void            renderLandscapes();

    // A grow only list of landscapes to be rendered.
    std::vector<CLandscapeModel*>   _LandscapeRenderList;

    // @}


    struct CWaterModelDump
    {
        void        *Address;
        void        *ClippedPolyBegin;
        void        *ClippedPolyEnd;
    };
    std::vector<CWaterModelDump>    _DebugWaterModelList;

public:
    CWaterModel *_FirstWaterModel;
};


}


#endif // NL_RENDER_TRAV_H

/* End of render_trav.h */