transform.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_TRANSFORM_H
#define NL_TRANSFORM_H

#include "nel/3d/hrc_trav.h"
#include "nel/3d/track.h"
#include "nel/3d/transformable.h"
#include "nel/3d/animated_value.h"
#include "nel/3d/channel_mixer.h"
#include "nel/misc/matrix.h"
#include "nel/misc/matrix.h"
#include "nel/misc/aabbox.h"
#include "nel/3d/light_contribution.h"
#include "nel/3d/lighting_manager.h"
#include "nel/misc/class_id.h"
#include "nel/3d/fast_ptr_list.h"


namespace   NLMISC
{
    class   CAABBox;
};


namespace   NL3D
{

using NLMISC::CRGBA;


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


class   CSkeletonModel;
class   CInstanceGroup;
class   ILogicInfo;
class   CLoadBalancingGroup;
class   CSkinSpecularRdrPass;
class   CShadowMap;
class   CMaterial;
class   IDriver;
class CInstanceUser;

// ***************************************************************************
// ClassIds.
const NLMISC::CClassId      TransformId=NLMISC::CClassId(0x174750cb, 0xf952024);


// ***************************************************************************
class CTransform : public ITransformable
{
public:
    static  void    registerBasic();

    CScene          *getOwnerScene() const {return _OwnerScene;}

public:

    // @{

    virtual void    update();

    virtual void    initModel();

    virtual void    traverseHrc();
    virtual void    traverseClip();
    virtual void    traverseAnimDetail();
    virtual void    traverseLoadBalancing();
    virtual void    traverseLight();
    virtual void    traverseRender();

    virtual bool    clip()
    {
        return true;
    }

    virtual void    profileRender();


    // @}

    // build matching user interface object (a class derived from CInstanceUser)
    virtual class UTransform *buildMatchingUserInterfaceObject ();

public:

    void            setTransparency(bool v);
    void            setOpacity(bool v);
    // no op for non multi-lod object, else, force the opacity /
    void            setBypassLODOpacityFlag(bool bypass);
    bool            getBypassLODOpacityFlag() const{ return getStateFlag(BypassLODOpacity) != 0;  }
    // return a non-zero value if true
    uint32          isOpaque() { return getStateFlag(IsOpaque); }
    uint32          isTransparent() { return getStateFlag(IsTransparent); }


    void            setOrderingLayer(uint layer) { _OrderingLayer = uint8(layer); }

    uint            getOrderingLayer() const { return _OrderingLayer; }

    //  an object with distance 10 and priority 1 will be displayed before any object with distance 1 and priority 0.
    // IMPORTANT : priority is clamped by the number of priorities defined in the scene. By default there's only one priority of 0
    // that is possible, so priority ordering doesn't actually occurs.
    void            setTransparencyPriority(uint8 priority) { _TransparencyPriority = priority; }
    uint8           getTransparencyPriority() const { return _TransparencyPriority; }

    void            hide();
    void            show();
    /*
     *  Enable / disable user clipping. If enable, the transform is not clipped into the engine.
     *  The user has to use show / hide to clip or not the transform.
     */
    void            setUserClipping(bool enable);
    bool            getUserClipping() const;
    void            heritVisibility();
    CHrcTrav::TVisibility   getVisibility() {return Visibility;}
    CSkeletonModel*         getSkeletonModel () const {return _FatherSkeletonModel;}
    // Get the ancestor skeleton, (father skeleton that has the least depth in the model tree), or NULL if none
    CSkeletonModel          *getAncestorSkeletonModel() const { return _AncestorSkeletonModel; }

    // @{
    void            hrcLinkSon(CTransform *son);
    void            hrcUnlink();
    // get the Hrc parent if any (else NULL)
    CTransform      *hrcGetParent() const {return _HrcParent;}
    // get Sons links. NB: indices are no more valid after an hrcUnlink()
    uint            hrcGetNumChildren() const {return _HrcSons.size();}
    CTransform      *hrcGetChild(uint index) const;
    // @}


    // @{
    // Add a link from me to son for Clip Graph (no-op if son==this)
    void            clipAddChild(CTransform *son);
    // Remove a link from me to son for Clip Graph (no-op if not found)
    void            clipDelChild(CTransform *son);
    // unlink from all parent clip
    void            clipUnlinkFromAll();
    // get Parents links. NB: indices are no more valid after a clipDelChild()
    uint            clipGetNumParents() const {return _ClipParents.size();}
    CTransform      *clipGetParent(uint index) const;
    // get Sons links. NB: indices are no more valid after a clipDelChild()
    uint            clipGetNumChildren() const {return _ClipSons.size();}
    CTransform      *clipGetChild(uint index) const;
    // @}


    // @{
    virtual ITrack* getDefaultTrack (uint valueId);
    virtual void    registerToChannelMixer(CChannelMixer *chanMixer, const std::string &prefix);
    // @}

    void            setChannelMixerOwnerShip(bool enable = true)    { setStateFlag(IsDeleteChannelMixer, enable); }
    bool            getChannelMixerOwnerShip() const { return getStateFlag(IsDeleteChannelMixer)!=0; }


    void            freeze();
    void            setDontUnfreezeChildren(bool val);


    void            freezeHRC();


    void            unfreezeHRC();


    uint32          isQuadGridClipEnabled() const {return getStateFlag(QuadGridClipEnabled);}

    const CMatrix&  getWorldMatrix() const {return _WorldMatrix;}

    // force the world matrix (could be modified next frame after hrc traversal
    void            setWorldMatrix(const CMatrix &mat) { _WorldMatrix = mat;}

    bool    isHrcVisible() const
    {
        return _WorldVis;
    }

    bool    isClipVisible() const
    {
        return _Visible;
    }


    // A RefPtr is kept on the clusterSystem, so getClusterSystem() will return NULL if the instance group has been deleted
    void                setClusterSystem (CInstanceGroup *pCS);
    CInstanceGroup*     getClusterSystem ();


    // @{
    void                resetLighting();

    uint32              isLightable() const {return getStateFlag(IsFinalLightable);}

    void                setUserLightable(bool enable);

    bool                getUserLightable() const {return getStateFlag(IsUserLightable)!=0;}

    void                freezeStaticLightSetup(CPointLight *pointLight[NL3D_MAX_LIGHT_CONTRIBUTION],
        uint numPointLights, uint8 sunContribution, CPointLight *frozenAmbientlight);

    void                unfreezeStaticLightSetup();

    uint32              isBigLightable() const {return getStateFlag(IsBigLightable);}

    bool                useMergedPointLight() const {return _LightContribution.UseMergedPointLight;}

    const CLightContribution &getLightContribution() const { return _LightContribution; }


    virtual void        getLightHotSpotInWorld(CVector &modelPos, float &modelRadius) const {modelPos= CVector::Null; modelRadius=0;}

    // @}


    void                setLogicInfo(ILogicInfo *logicInfo) {_LogicInfo= logicInfo;}


    virtual void        getAABBox(NLMISC::CAABBox &bbox) const;


    // @{

    void                setLoadBalancingGroup(const std::string &group);

    const std::string   &getLoadBalancingGroup() const;

    // @}


    // @{
    uint32              isSkeleton() const {return getStateFlag(IsSkeleton);}
    uint32              isSkinned() const {return getStateFlag(IsSkinned);}
    virtual bool        getSkinBoneBBox(NLMISC::CAABBox &/* bbox */, uint /* boneId */) {return false;}
    // @}


    // @{

    void                setMeanColor(CRGBA color);

    CRGBA               getMeanColor() const {return _MeanColor;}

    uint32              isAnimDetailable() const {return getStateFlag(IsAnimDetailable);}
    uint32              isLoadBalancable() const {return getStateFlag(IsLoadBalancable);}
    uint32              isRenderable() const {return getStateFlag(IsRenderable);}

    uint32              isMeshBaseInstance() const {return getStateFlag(IsMeshBaseInstance);}
    uint32              isTransformShape() const {return getStateFlag(IsTransformShape);}
    uint32              isCluster() const {return getStateFlag(IsCluster);}

    bool                supportFastIntersect() const {return _SupportFastIntersect;}
    virtual bool        fastIntersect(const NLMISC::CVector &/* p0 */, const NLMISC::CVector &/* dir */, float &/* dist2D */, float &/* distZ */, bool /* computeDist2D */) {return false;}

    void                enableFastIntersectSupport(bool enable) {_SupportFastIntersect= enable;}

    // @}


    // @{
    void                enableCastShadowMap(bool state);
    bool                canCastShadowMap() const {return getStateFlag(IsFinalShadowMapCaster)!=0;}

    void                enableReceiveShadowMap(bool state) {if(modelCanReceiveShadowMap()) setStateFlag(IsFinalShadowMapReceiver, state);}
    bool                canReceiveShadowMap() const {return getStateFlag(IsFinalShadowMapReceiver)!=0;}

    uint32              modelCanCastShadowMap() const {return getStateFlag(IsShadowMapCaster);}
    uint32              modelCanReceiveShadowMap() const {return getStateFlag(IsShadowMapReceiver);}

    virtual void        generateShadowMap(const CVector &/* lightDir */) { }
    virtual CShadowMap  *getShadowMap() {return NULL;}

    virtual void        getReceiverBBox(CAABBox &bbox);

    virtual void        receiveShadowMap(CShadowMap * /* shadowMap */, const CVector &/* casterPos */, const CMaterial &/* shadowMat */) { }

    virtual const CMatrix   &getReceiverRenderWorldMatrix() const {return getWorldMatrix();}

    void                setGeneratingShadowMap(bool state) {if(canCastShadowMap()) setStateFlag(IsGeneratingShadowMap, state);}
    bool                isGeneratingShadowMap() const {return getStateFlag(IsGeneratingShadowMap)!=0;}

    virtual bool        computeWorldBBoxForShadow(NLMISC::CAABBox &/* worldBB */) {return false;}
    virtual void        renderIntoSkeletonShadowMap(CSkeletonModel * /* rootSkeleton */, CMaterial  &/* castMat */) { }

    void                setShadowMapDirectionZThreshold(float zthre);
    float               getShadowMapDirectionZThreshold() const {return _ShadowMapDirectionZThreshold;}

    void                setShadowMapMaxDepth(float depth);
    float               getShadowMapMaxDepth() const {return _ShadowMapMaxDepth;}

    // @}

    void                setForceClipRoot(bool forceClipRoot);
    bool                getForceClipRoot() const { return getStateFlag(ForceClipRoot) != 0; }


    // test if the model is a flare
    virtual bool isFlare() const { return false; }


    void        setSSSWO(bool state) {setStateFlag(SSSWO, state);}
    bool        getSSSWO() const {return getStateFlag(SSSWO)!=0;}


// ********
private:
    CHrcTrav::TVisibility   Visibility;

    static  CTrackDefaultVector     DefaultPos;
    static  CTrackDefaultVector     DefaultPivot;
    static  CTrackDefaultVector     DefaultRotEuler;
    static  CTrackDefaultQuat       DefaultRotQuat;
    static  CTrackDefaultVector     DefaultScale;

protected:
    CTransform();
    virtual ~CTransform();

    virtual void    unlinkFromQuadCluster() {}

    // @{

    virtual bool            isSkinnable() const {return false;}
    virtual void            setApplySkin(bool state);
    virtual const std::vector<sint32>           *getSkinBoneUsage() const {return NULL;}
    virtual const std::vector<NLMISC::CBSphere> *getSkinBoneSphere() const {return NULL;}
    virtual void            renderSkin(float /* alphaMRM */) { }


    virtual bool            supportSkinGrouping() const {return false;}
    virtual sint            renderSkinGroupGeom(float /* alphaMRM */, uint /* remainingVertices */, uint8 * /* dest */) {return 0;}
    virtual void            renderSkinGroupPrimitives(uint /* baseVertex */, std::vector<CSkinSpecularRdrPass> &/* specularRdrPasses */, uint /* skinIndex */) { }
    virtual void            renderSkinGroupSpecularRdrPass(uint /* rdrPass */) { }

    virtual bool            supportShadowSkinGrouping() const {return false;}
    virtual sint            renderShadowSkinGeom(uint /* remainingVertices */, uint8 * /* vbDest */) {return 0;}
    virtual void            renderShadowSkinPrimitives(CMaterial &/* castMat */, IDriver * /* drv */, uint /* baseVertex */) { }

    virtual bool            supportIntersectSkin() const {return false;}
    virtual bool            intersectSkin(const CMatrix &/* toRaySpace */, float &/* dist2D */, float &/* distZ */, bool /* computeDist2D */) {return false;}

    // The SkeletonModel, root of us (skinning or sticked object). NULL , if normal mode.
    CSkeletonModel  *_FatherSkeletonModel;
    // If sticked object, id of the bone in the _FatherSkeletonModel.
    uint            _FatherBoneId;

    // @}

    // @{

    CLightContribution      _LightContribution;

    uint32                  isNeedUpdateLighting() const {return getStateFlag(IsNeedUpdateLighting);}
    uint32                  isNeedUpdateFrozenStaticLightSetup() const {return getStateFlag(IsNeedUpdateFrozenStaticLightSetup);}

    CLightingManager::CQGItLightedModel     _LightedModelIt;

    // @}


    CChannelMixer           *getChannelMixer() const {return _ChannelMixer;}


    // @{

    void                setIsLightable(bool val);
    void                setIsRenderable(bool val);
    void                setIsBigLightable(bool val);
    void                setIsSkeleton(bool val);
    void                setIsForceAnimDetail(bool val);
    void                setIsLoadbalancable(bool val);

    void                setIsMeshBaseInstance(bool val) {setStateFlag(IsMeshBaseInstance, val);}
    void                setIsTransformShape(bool val) {setStateFlag(IsTransformShape, val);}
    void                setIsCluster(bool val) {setStateFlag(IsCluster, val);}

    void                setIsShadowMapCaster(bool val) {setStateFlag(IsShadowMapCaster, val);}
    void                setIsShadowMapReceiver(bool val) {setStateFlag(IsShadowMapReceiver, val);}

    // @}

    bool                getShowWhenLODSticked() const { return _ForceCLodSticked; }

    // force to compute that transform matrix (useful if matrix needed but clipped because sticked to a clipped skeleton for example)
    void                forceCompute();

private:
    static CTransform   *creator() {return new CTransform;}
    friend class    CSkeletonModel;
    friend class    CScene;
    friend class    CClipTrav;
    friend class    CAnimDetailTrav;
    friend class    CRenderTrav;

    // The Scene which owns us
    CScene          *_OwnerScene;

    // @{
    // Hrc hierarchy. One parent and possible multiple sons
    CFastPtrListNode            _HrcNode;
    CFastPtrList<CTransform>    _HrcSons;
    CTransform                  *_HrcParent;
    NLMISC::CRefPtr<CTransform> _HrcParentUnfreeze;

    /* Clip Graph. DAG (Direct Acyclic Graph)
     *  NB: implementation optmized for Low number of parent. clipAddChild() and clipDelChild() is in O(numParents).
     */
    struct  CClipNode
    {
        CFastPtrListNode            ClipNode;
        CTransform                  *Parent;
    };
    CFastPtrList<CTransform>    _ClipSons;
    std::vector<CClipNode*>     _ClipParents;
    bool            clipHasParent(CTransform *parent);
    void            clipDelFromParent(CTransform *parent);

    // @}

    // @{
    // linked list of models to update.
    CTransform      *_PrecModelToUpdate;
    CTransform      *_NextModelToUpdate;

    // for CScene::createModel() and for CTransform::freezeHRC() only.
    void            linkToUpdateList();
    void            unlinkFromUpdateList();

    // @}


    // For anim detail.
    NLMISC::CRefPtr<CChannelMixer>      _ChannelMixer;

    // Last date of ITransformable matrix.
    uint64          _LastTransformableMatrixDate;

    NLMISC::CRefPtr<CInstanceGroup>     _ClusterSystem;


    enum    TFreezeHRCState { FreezeHRCStateDisabled=0, FreezeHRCStateRequest, FreezeHRCStateReady, FreezeHRCStateEnabled};
    TFreezeHRCState         _FreezeHRCState;

    uint8               _OrderingLayer;
    uint8               _TransparencyPriority;

    // For stickObjectEx(). with forceCLod==true
    bool                _ForceCLodSticked : 1;

    bool                _TransformDirty   : 1;

    // see supportFastIntersect. Filled by CSkeletonModel
    bool                _SupportFastIntersect : 1;

    ILogicInfo          *_LogicInfo;


    CRGBA               _MeanColor;

    std::list<CTransform*>::iterator        _ItShadowCasterInScene;

    float                       _ShadowMapDirectionZThreshold;
    float                       _ShadowMapMaxDepth;

    // @{

    enum    TState  {
        // Post-clipping Traversal flags. If set, then the object is inserted into traversal list.
        IsAnimDetailable=       0x0001,
        IsLoadBalancable=       0x0002,
        IsLightable=            0x0004,
        IsRenderable=           0x0008,
        // Transparency Flags.
        IsTransparent=          0x0010,
        IsOpaque=               0x0020,
        // For fast clip.
        QuadGridClipEnabled=    0x0040,
        // Lighting.
        IsUserLightable=        0x0080,
        IsFinalLightable=       0x0100,     // IsLightable && IsUserLightable
        IsBigLightable=         0x0200,
        IsNeedUpdateLighting=   0x0400,
        IsNeedUpdateFrozenStaticLightSetup=
                                0x0800,
        // Skinning
        IsSkeleton=             0x1000,     // set if the model is a skeleton (faster than dynamic_cast)
        IsSkinned=              0x2000,     // true if the model is isSkinnable() and if currently skinned
        // Misc
        IsDeleteChannelMixer=   0x4000,
        IsForceAnimDetail=      0x8000,
        IsMeshBaseInstance=     0x10000,
        IsTransformShape=       0x20000,    // set if the model is a transform_shape (faster than dynamic_cast)
        IsCluster=              0x40000,    // set if the model is a cluster (faster than dynamic_cast)
        UserClipping=           0x80000,    // set if the user provide a clip method, don't call clip() in ClipTrav

        // ShadowMap
        IsShadowMapCaster=      0x100000,   // set if the model can cast ShadowMap
        IsFinalShadowMapCaster= 0x200000,   // set if the model can cast ShadowMap AND the user want it
        IsShadowMapReceiver=    0x400000,   // set if the model can receive ShadowMap
        IsFinalShadowMapReceiver= 0x800000, // set if the model can receive ShadowMap AND the user want it
        IsGeneratingShadowMap=  0x1000000,  // temp set if the model is asked to render its shadowMap this frame.

        ForceClipRoot           = 0x2000000,// Force the object to always be attached to the root
                                            // As a consequence, it can't be inserted into a cluster system (even the root cluster)
                                            // and is thus always visible when in the frustum
        ClusterSystemAuto       = 0x4000000,

        SSSWO                   = 0x8000000,    // Special for SkeletonSpawnScript. if set, the WorldMatrix is special

        BypassLODOpacity        = 0x10000000    // for mesh multi lod : do not use the LOD opacity / transparency, but the parent one (overwritten at traversal, else ...)

        // NB: may continue on >=0x20000000
    };

    uint32              _StateFlags;

    void                setStateFlag(uint32 mask, bool val)
    {
        // reset the state.
        _StateFlags&= ~mask;
        // set the state
        _StateFlags|= ( 0- ((uint32)val) ) & mask;
    }

    uint32              getStateFlag(uint32 mask) const
    {
        return _StateFlags&mask;
    }

    // @}

protected:

    uint32                      _RenderFilterType;


protected:

    // @{

    CMatrix     _LocalMatrix;
    CHrcTrav::TVisibility   _LocalVis;  // The visibility state of the node.
    sint64      _LocalDate;             // The update date of the LocalMatrix.
    CMatrix     _WorldMatrix;
    sint64      _WorldDate;         // The update date of the WorldMatrix.
    bool        _WorldVis;          // Is the node visible? (enabled?)
    // Transform Specicic Hrc
    bool        _Frozen;
    bool        _DontUnfreezeChildren; // Useful when cluster system move to not test instance again
    bool        _ClipLinkedInSonsOfAncestorSkeletonModelGroup;
    // !NULL if any skeleton is an ancestor in hierarchy. Updated at each Hrc traversal!!
    CSkeletonModel  *_AncestorSkeletonModel;

    void        updateWorld();
    // according to _AncestorSkeletonModel, link clipTrav.
    void        updateClipTravForAncestorSkeleton();

    // @}


    // @{

    sint64      _ClipDate;
    // The index of the Observer in the _VisibleList; -1 (default) means not in
    sint        _IndexInVisibleList;
    bool        _Visible;

    // @}

    // @{
    // Used by CRenderTrav. see CRenderTrav::removeRenderModel() implementation
    uint8       _IndexLSBInRenderList;
    // @}

    // @{

    void            updateWorldMatrixFromFather();

    void            traverseAnimDetailWithoutUpdateWorldMatrix();

    // @}

    // @{
    // Which group owns this model
    CLoadBalancingGroup     *_LoadBalancingGroup;
    // @}

    // @{
    virtual void            createShadowMap() {}
    virtual void            deleteShadowMap() {}
    // @}

};


} // namespace NL3D


#endif // NL_TRANSFORM_H

/* End of transform.h */