gzShadowVolume.h

Go to the documentation of this file.

//*****************************************************************************
// File         : gzShadowVolume.h
// Module       : 
// Description  : Class definition of the gzShadowVolume class
// Author       : Anders Modén      
// Product      : Gizmo3D 2.1.1
//      
// Copyright © 2003- Saab Training Systems AB, Sweden   
//          
// NOTE:    Gizmo3D is a high performance 3D Scene Graph and effect visualisation 
//          C++ toolkit for Linux, Mac OS X, Windows (Win32) and IRIX® for  
//          usage in Game or VisSim development.
//
//
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000115  Created file    
//
//******************************************************************************
#ifndef __GZ_SHADOW_VOLUME_H__
#define __GZ_SHADOW_VOLUME_H__

#include "gzRecursive.h"
#include "gzGeometry.h"
#include "gzNodeAction.h"
#include "gzLight.h"
#include "gzShadowGeometry.h"

//******************************************************************************
// Class    : gzShadowVolume
//                                  
// Purpose  : Base class for all volumetric shadows
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  010101  Created 
//                                  
//******************************************************************************
class gzShadowVolume : public gzBaseGeometry
{
public:

    GZ_GRAPH_EXPORT gzShadowVolume(gzLight *shadowlight=NULL,gzULong softPasses=0,gzFloat softScale=1.0f,const gzString & name=GZ_EMPTY_STRING);

    GZ_GRAPH_EXPORT virtual ~gzShadowVolume(){};

    GZ_DECLARE_TYPE_INTERFACE_EXPORT(GZ_GRAPH_EXPORT);  // typed interface

    // ---------- Clone interface ---------------------------------------
    
    GZ_GRAPH_EXPORT virtual gzReference* clone() const=0;

    // ---------- Shadow Volume settings --------------------------------

    GZ_GRAPH_EXPORT gzLight *getShadowLight();

    GZ_GRAPH_EXPORT gzVoid setShadowLight(gzLight *shadowLight);

    // --------- Transform of shadow volume -----------------------------

    GZ_GRAPH_EXPORT gzVoid setTransformIndex(gzULong index);    // Default 0;

    GZ_GRAPH_EXPORT gzULong getTransformIndex();

    // --------- Pass activation IDs ------------------------------------

    GZ_GRAPH_EXPORT gzVoid  useRenderID(gzBool on);
    GZ_GRAPH_EXPORT gzBool  useRenderID();

    GZ_GRAPH_EXPORT gzVoid  setRenderID(gzULong id);
    GZ_GRAPH_EXPORT gzULong getRenderID();

    // ---------- Soft shadow control -----------------------------------

    GZ_GRAPH_EXPORT gzVoid  setPrimaryDirection(const gzVec3 &direction,const gzVec3 &base);
    GZ_GRAPH_EXPORT gzVec3  getPrimaryDirection();
    GZ_GRAPH_EXPORT gzVec3  getPrimaryBase();

    GZ_GRAPH_EXPORT gzVoid  setNumberOfSoftPasses(gzULong passes);
    GZ_GRAPH_EXPORT gzULong getNumberOfSoftPasses();

    GZ_GRAPH_EXPORT gzVoid  setSoftScale(gzFloat scale);
    GZ_GRAPH_EXPORT gzFloat getSoftScale();

    GZ_GRAPH_EXPORT gzVoid updateSoftScaleMatrix();

    GZ_GRAPH_EXPORT const gzMatrix4 &getSoftScaleMatrix();

private:

    

    gzLight *   m_shadowLight;

    gzULong     m_transformIndex;

    gzBool      m_useRenderID;

    gzULong     m_renderID;

    gzVec3      m_primaryDirection;

    gzVec3      m_primaryBase;

    gzFloat     m_scaleFactor;

    gzULong     m_softPasses;   

    gzMatrix4   m_scaleMatrix;
};

//******************************************************************************
// Class    : gzShadowVolumeGeometry
//                                  
// Purpose  : Special volume shadow using a base geometry as volume
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  010101  Created 
//                                  
//******************************************************************************
class gzShadowVolumeGeometry : public gzShadowVolume
{
public:

    GZ_GRAPH_EXPORT gzShadowVolumeGeometry( gzLight *shadowlight=NULL,gzBaseGeometry *geom=NULL,gzULong softPasses=0,gzFloat softScale=1.0f,const gzString & name=GZ_EMPTY_STRING);

    GZ_GRAPH_EXPORT virtual ~gzShadowVolumeGeometry(){};

    GZ_DECLARE_TYPE_INTERFACE_EXPORT(GZ_GRAPH_EXPORT);  // typed interface

    // ---------- Clone interface ---------------------------------------
    
    GZ_GRAPH_EXPORT virtual gzReference* clone() const;

    // ---------- Action interface --------------------------------------

    GZ_GRAPH_EXPORT virtual gzVoid preTraverseAction( gzTraverseAction *actionclass , gzContext *context);

    // ---------- Common graph functions --------------------------------

    GZ_GRAPH_EXPORT virtual gzVoid updateNode();


    // ---------- ShadowVolumeGeom interface ----------------------------

    GZ_GRAPH_EXPORT gzVoid setGeometry(gzBaseGeometry *geometry);

    GZ_GRAPH_EXPORT gzBaseGeometry *getGeometry();

private:

    gzRefPointer<gzBaseGeometry>    m_geometry;                     

};

//******************************************************************************
// Class    : gzIndexBaseGeometry
//                                  
// Purpose  : -
//                                  
// Notes    : Private usage 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  010101  Created 
//                                  
//******************************************************************************
class gzIndexBaseGeometry : public gzReference
{
private:

    gzIndexBaseGeometry(){};

    friend class gzShadowRender;

    gzRefPointer<gzBaseGeometry>    geometry;

    gzULong                         index;

    gzBool                          equalIndex;
};


//******************************************************************************
// Class    : gzShadowRender
//                                  
// Purpose  : The actual shadow render class. Add child nodes to render in shadow
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  010101  Created 
//                                  
//******************************************************************************
class gzShadowRender : public gzRecursive
{
public:
    GZ_GRAPH_EXPORT gzShadowRender(const gzString & name=GZ_EMPTY_STRING);
    GZ_GRAPH_EXPORT virtual ~gzShadowRender(){};

    GZ_DECLARE_TYPE_INTERFACE_EXPORT(GZ_GRAPH_EXPORT);  // typed interface


    // ---------- Clone interface ---------------------------------------
    GZ_GRAPH_EXPORT virtual gzReference* clone() const;

    // ---------- Action Interface --------------------------------------

    GZ_GRAPH_EXPORT virtual gzVoid preTraverseAction( gzTraverseAction *actionclass , gzContext *context);
    GZ_GRAPH_EXPORT virtual gzVoid postTraverseAction( gzTraverseAction *actionclass , gzContext *context);
    GZ_GRAPH_EXPORT virtual gzActionStage useActionStage( gzTraverseAction *actionclass , gzContext *context);

    // ---------- Render Volume API --------------------------------------

    GZ_GRAPH_EXPORT gzVoid addShadowVolume (gzShadowVolume *mask, gzBool addToRender=FALSE);

    GZ_GRAPH_EXPORT gzVoid removeShadowVolume (gzShadowVolume *mask);

    GZ_GRAPH_EXPORT gzVoid addGeometryMask (gzBaseGeometry *render, gzULong index=0,gzBool equalIndex=FALSE);

    GZ_GRAPH_EXPORT gzVoid showVolumes (gzBool show);

    GZ_GRAPH_EXPORT gzVoid useClearing(gzBool on);

    GZ_GRAPH_EXPORT gzVoid setPassOffset(gzULong offset);


protected:

    GZ_GRAPH_EXPORT virtual gzVoid calculateTransform(gzContext *context);  // Override to calculate other transform

    gzRefList<gzShadowVolume>   m_volumes;

    gzRefList<gzIndexBaseGeometry>  m_geometryMasks;

    gzULong                     m_passOffset;

    gzBool                      m_showVolumes:1;

    gzBool                      m_useClearing:1;
};

enum gzShadowGeneratorType
{
    GZ_SHADOW_GEOMETRY,
    GZ_SHADOW_DEPTHMAP
};


//******************************************************************************
// Class    : gzShadowGenerator
//                                  
// Purpose  : Generates and detects shadow changes from each rendering pass.
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  010101  Created 
//                                  
//******************************************************************************
class gzShadowGenerator : public gzNode
{
public:
    GZ_DECLARE_TYPE_INTERFACE_EXPORT(GZ_GRAPH_EXPORT);  // typed interface

    GZ_GRAPH_EXPORT gzShadowGenerator(gzNode *node , gzShadowVolumeGeometry *shadowVolume , const gzDouble &lengthFactor , gzShadowGeneratorType type, const gzString & name=GZ_EMPTY_STRING);

    GZ_GRAPH_EXPORT virtual ~gzShadowGenerator(){};

    // ---------- clone interface ---------------------------------------

    GZ_GRAPH_EXPORT virtual gzReference* clone() const;

    // ---------- Action interface --------------------------------------

    GZ_GRAPH_EXPORT virtual gzVoid preTraverseAction( gzTraverseAction *actionclass , gzContext *context);


    GZ_GRAPH_EXPORT static gzVoid addShadowGenerators(  gzNode *scene,
                                                        gzShadowRender *render,
                                                        gzLight *light , 
                                                        gzBool useShadowTag=FALSE,
                                                        const gzDouble &lengthFactor=5.0,
                                                        const gzULong &softPasses=0, 
                                                        const gzFloat &softScale=1.0f,
                                                        gzRefList<gzShadowGenerator> *addedGenerators=NULL,
                                                        gzShadowGeneratorType type=GZ_SHADOW_GEOMETRY, 
                                                        gzULong maxTraverseDepth=0xffffffffUL,
                                                        gzBool inShadowTag=FALSE);


    GZ_GRAPH_EXPORT static gzBool removeShadowGenerators(   gzNode *scene , gzShadowRender *render , gzNode *item=NULL);

    GZ_GRAPH_EXPORT gzShadowVolumeGeometry *getShadowVolumeGeometry();

    GZ_GRAPH_EXPORT gzNode *getNode();

private:

    gzDouble                                m_lengthFactor;

    gzRefPointer<gzNode>                    m_node;

    gzRefPointer<gzShadowVolumeGeometry>    m_shadowVolume;
    
    gzULong                                 m_transformUpdateDiff;

    gzULong                                 m_lightUpdateID;

    gzULong                                 m_nodeUpdateID;

    gzULong                                 m_weightUpdateID;

    gzArray<gzTriConnectivity>              m_triConnectivity;

    gzULong                                 m_currentUpdate;

    gzULong                                 m_updateCount;

    gzShadowGeneratorType                   m_type;
};

//---------------------------- User defined mask geometry -------------------------------

const gzString  GZ_USERDATA_MASK_GEOMETRY       ="_mskG";

class gzShadowGeometryMask : public gzUserData
{
public:

    gzRefPointer<gzGeometry>    maskData;
};

#endif

---