scene_group.h

Go to the documentation of this file.

/* Copyright, 2001 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_GROUP_H
#define NL_SCENE_GROUP_H

#include "nel/misc/types_nl.h"
#include "nel/misc/vector.h"
#include "nel/misc/quat.h"
#include "nel/misc/smart_ptr.h"
#include "nel/3d/portal.h"
#include "nel/3d/cluster.h"
#include "nel/3d/transform.h"
#include "nel/3d/point_light_named.h"
#include "nel/3d/point_light_named_array.h"
#include "nel/3d/ig_surface_light.h"
#include "nel/3d/clip_trav.h"

#include <vector>

namespace NLMISC
{
class CRGBA;
class IStream;
struct EStream;
class CMatrix;
}

namespace NL3D {

class CScene;
class CTransformShape;
class IDriver;
class ITransformName;
struct IAddRemoveInstance;
struct IIGAddBegin;

class CInstanceGroup : public NLMISC::CRefCount
{
    /* ***********************************************
     *  WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
     *  It can be loaded/called through CAsyncFileManager for instance
     * ***********************************************/

public:

    enum    {NumStaticLightPerInstance= 2};
    enum TState { StateNotAdded = 0, StateAdding, StateAdded, StateError };

public:


    class CInstance
    {
    public:
        std::string Name;

        sint32 nParent;

        std::vector<uint32> Clusters;

        NLMISC::CQuat Rot;
        NLMISC::CVector Pos;
        NLMISC::CVector Scale;

        // Name of the instance
        std::string InstanceName;

        bool    DontAddToScene;

        bool    Visible;

        // If true (false by default), then the instance don't cast shadow (used by ig_lighter.exe).
        bool    DontCastShadow;
        // If true (false by default), then the instance's lighting will not be precomputed.
        bool    AvoidStaticLightPreCompute;
        // This part is precomputed.
        bool    StaticLightEnabled;     // If false, then the instance 's lighting is not pre-computed.
        uint8   SunContribution;        // Contribution of the Sun.
        // Ids of the lights. FF == disabled. if Lights[i]==FF, then all lights >=i are considered disabled.
        uint8   Light[NumStaticLightPerInstance];
        uint8   LocalAmbientId;
        bool    DontCastShadowForInterior;
        bool    DontCastShadowForExterior;


        CInstance ();

        void serial (NLMISC::IStream& f);
    };

    typedef std::vector<CInstance> TInstanceArray;


    uint                    getNumInstance () const;

    const std::string&      getShapeName (uint instanceNb) const;

    const std::string&      getInstanceName (uint instanceNb) const;

    const NLMISC::CVector&  getInstancePos (uint instanceNb) const;

    const NLMISC::CQuat&    getInstanceRot (uint instanceNb) const;

    // Get an instance scale
    const NLMISC::CVector&  getInstanceScale (uint instanceNb) const;

    // Get instance matrix (no pivot added)
    void                    getInstanceMatrix(uint instanceNb, NLMISC::CMatrix &dest) const;

    // Get the instance father (-1 if this is a root)
    sint32                  getInstanceParent (uint instanceNb) const;

    // Get a const ref on the instance
    const CInstance         &getInstance(uint instanceNb) const;

    // Get a mutable ref on the instance
    CInstance               &getInstance(uint instanceNb);

    // Get the ig global pos
    const NLMISC::CVector &getGlobalPos() const { return _GlobalPos; }

    CTransformShape         *getTransformShape(uint instanceNb) const;

    CInstanceGroup();
    ~CInstanceGroup();

    void build (const CVector &vGlobalPos, const TInstanceArray& array,
                const std::vector<CCluster>& Clusters,
                const std::vector<CPortal>& Portals);

    void build (const CVector &vGlobalPos, const TInstanceArray& array,
                const std::vector<CCluster>& Clusters,
                const std::vector<CPortal>& Portals,
                const std::vector<CPointLightNamed> &pointLightList,
                const CIGSurfaceLight::TRetrieverGridMap *retrieverGridMap= NULL,
                float igSurfaceLightCellSize= 0);

    void retrieve (CVector &vGlobalPos, TInstanceArray& array,
                std::vector<CCluster>& Clusters,
                std::vector<CPortal>& Portals,
                std::vector<CPointLightNamed> &pointLightList) const;

    void serial (NLMISC::IStream& f);

    void createRoot (CScene& scene);

    void setTransformNameCallback (ITransformName *pTN);

    void setAddRemoveInstanceCallback(IAddRemoveInstance *callback);

    void setIGAddBeginCallback(IIGAddBegin *callback);



    bool addToScene (CScene& scene, IDriver *driver=NULL, uint selectedTexture=0);
    bool addToSceneAsync (CScene& scene, IDriver *driver=NULL, uint selectedTexture=0);
    void stopAddToSceneAsync ();
    TState getAddToSceneState ();

    void getShapeName (uint instanceIndex, std::string &shapeName) const;

    void                    setUserInterface(class UInstanceGroup *uig) {_UserIg= uig;}
    class UInstanceGroup    *getUserInterface() const {return _UserIg;}

    void                    displayDebugClusters(IDriver *drv, class CTextContext *txtCtx);

private:
    bool addToSceneWhenAllShapesLoaded (CScene& scene, IDriver *driver, uint selectedTexture);

public:
    bool removeFromScene (CScene& scene);



    void getLights (std::set<std::string> &LightNames);




    void getBlendShapes (std::set<std::string> &BlendShapeNames);

    void setBlendShapeFactor (const std::string &BlendShapeName, float rFactor);



    void addCluster (CCluster *pCluster);

    void setClusterSystemForInstances (CInstanceGroup *pIG);

    void getDynamicPortals (std::vector<std::string> &names);

    void setDynamicPortal (std::string& name, bool opened);

    bool getDynamicPortal (std::string& name);



    void linkRoot (CScene &scene, CTransform *father);

    void setPos (const CVector &pos);

    void setRotQuat (const CQuat &quat);

    CVector getPos ();

    CQuat getRotQuat ();

    void        freezeHRC();

    void        unfreezeHRC();


public:

    // @{

    const std::vector<CPointLightNamed> &getPointLightList() const {return _PointLightArray.getPointLights();}

    uint                                 getNumPointLights() const { return _PointLightArray.getPointLights().size(); }

    CPointLightNamed                    &getPointLightNamed(uint index)
    {
        return _PointLightArray.getPointLights()[index];
    }

    void            setPointLightFactor(const CScene &scene);

    bool            getStaticLightSetup(NLMISC::CRGBA sunAmbient, uint retrieverIdentifier, sint surfaceId, const CVector &localPos,
        std::vector<CPointLightInfluence> &pointLightList, uint8 &sunContribution, NLMISC::CRGBA &localAmbient)
    {
        return _IGSurfaceLight.getStaticLightSetup(sunAmbient, retrieverIdentifier, surfaceId, localPos,
            pointLightList, sunContribution, localAmbient);
    }

    const CIGSurfaceLight   &getIGSurfaceLight() const {return _IGSurfaceLight;}

    void            enableRealTimeSunContribution(bool enable);
    bool            getRealTimeSunContribution() const {return _RealTimeSunContribution;}


    // @}

    bool linkToParent (CInstanceGroup*pFather);

    CInstanceGroup  *getParentClusterSystem() const {return _ParentClusterSystem;}

public:

    TInstanceArray                  _InstancesInfos;
    std::vector<CTransformShape*>   _Instances;

    std::vector<CPortal>    _Portals;
    std::vector<CCluster>   _ClusterInfos;
    std::vector<CCluster*>  _ClusterInstances;

    CTransform      *_Root;

    CClipTrav       *_ClipTrav;
    // The cluster system used to link unclustered instances (setClusterSystemForInstances)
    CInstanceGroup  *_ClusterSystemForInstances;
    // The cluster system parent of us (linkToParent() call)
    CInstanceGroup  *_ParentClusterSystem;

    NLMISC::CVector _GlobalPos;


private:
    // @{

    bool                            _RealTimeSunContribution;

    CPointLightNamedArray           _PointLightArray;

    void            buildPointLightList(const std::vector<CPointLightNamed> &pointLightList,
                                        std::vector<uint>   &plRemap);

    CIGSurfaceLight                 _IGSurfaceLight;

    // @}

    // @{
    bool        _AddToSceneSignal;
    TState      _AddToSceneState;
    CScene      *_AddToSceneTempScene;
    IDriver     *_AddToSceneTempDriver;
    uint        _AddToSceneTempSelectTexture;
    // @}

    ITransformName       *_TransformName;
    IAddRemoveInstance   *_AddRemoveInstance;
    IIGAddBegin          *_IGAddBeginCallback;

    // Yes this is ugly, but impossible otherwise with the actual user interface system...
    UInstanceGroup       *_UserIg;
};


} // NL3D


#endif // NL_SCENE_GROUP_H

/* End of scene_group.h */