gzState.h

Go to the documentation of this file.

//*****************************************************************************
// File         : gzState.h
// Module       : 
// Description  : Class definition of the gzState 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  981111  Created file    
//
//******************************************************************************
#ifndef __GZ_STATE_H__
#define __GZ_STATE_H__

typedef enum {  GZ_ACTION_STAGE_TRAVERSE                    =-1,    
                GZ_ACTION_STAGE_DEFAULT                     =3,     

                GZ_ACTION_STAGE_UNDERLAY                    =0,     
                GZ_ACTION_STAGE_FRONT_TO_BACK               =1,     
                GZ_ACTION_STAGE_USER_1                      =2,     
                GZ_ACTION_STAGE_SORTED_TEXTURE              =3,     
                GZ_ACTION_STAGE_SORTED_NOFLIP_TEXTURE       =4,     
                GZ_ACTION_STAGE_MULTIPASS_TEXTURE           =5,     
                GZ_ACTION_STAGE_SCENE_GRAPH_ORDER           =6,     
                GZ_ACTION_STAGE_USER_2                      =7,     
                GZ_ACTION_STAGE_BACK_TO_FRONT               =8,     
                GZ_ACTION_STAGE_USER_3                      =9,     
                GZ_ACTION_STAGE_ALPHA_SORTED_TRANSPARENCY   =10,    
                GZ_ACTION_STAGE_SEPARATE_ALPHA_HIGHQ        =11,    
                GZ_ACTION_STAGE_SEPARATE_ALPHA              =12,    
                GZ_ACTION_STAGE_USER_4                      =13,    
                GZ_ACTION_STAGE_SHADOWED_TRANSPARENCY       =14,    
                GZ_ACTION_STAGE_NO_DEPTH_UPDATE             =15,    
                GZ_ACTION_STAGE_SHADOW                      =16,    
                GZ_ACTION_STAGE_TRANSPARENCY                =17,    
                GZ_ACTION_STAGE_USER_5                      =18,    
                GZ_ACTION_STAGE_OVERLAY                     =19,    
                GZ_ACTION_STAGE_COUNT                       =20,    
                GZ_ACTION_STAGE_PRE_RENDER                  =21,    
                GZ_ACTION_STAGE_POST_RENDER                 =22,    
             } gzActionStage;

typedef enum { GZ_STATE_ON , GZ_STATE_OFF , GZ_STATE_GLOBAL } gzStateModeActivation;


#include "gzObject.h"
#include "gzMatrix.h"
#include "gzTexture.h"
#include "gzMaterial.h"
#include "gzTexEnv.h"
#include "gzTexGen.h"
#include "gzShader.h"

class gzContext;    // Forward decl of graphics context

typedef enum {  
                GZ_STATE_EMPTY              = 0 ,
                GZ_STATE_LINE_STIPPLE       = (1 << 0), 
                GZ_STATE_POLYGON_MODE       = (1 << 1), 
                GZ_STATE_BLENDING           = (1 << 2), 
                GZ_STATE_TEXTURE            = (1 << 3), 
                GZ_STATE_MATERIAL           = (1 << 4), 
                GZ_STATE_TEXENV             = (1 << 5), 
                GZ_STATE_TEXGEN             = (1 << 6), 
                GZ_STATE_POLYGON_OFFSET     = (1 << 7), 
                GZ_STATE_ACTION_STAGE       = (1 << 8), 
                GZ_STATE_GENERATE_DEBUG_INFO= (1 << 9), 
                GZ_STATE_ALPHA_FUNC         = (1 << 10),
                GZ_STATE_GFX_PROGRAM        = (1 << 11),

             } gzStateMode;

GZ_USE_BIT_LOGIC(gzStateMode);      // Allow | & operators for gzStateMode

enum gzPolygonModeType 
{
    GZ_POLYGON_MODE_FILL,   
    GZ_POLYGON_MODE_LINE,   
    GZ_POLYGON_MODE_POINT,  
    GZ_POLYGON_MODE_CULL    
};

enum gzStateBlendFactor
{   
    GZ_BLEND_ZERO                   =GZ_ZERO ,                  
    GZ_BLEND_ONE                    =GZ_ONE,                    
    GZ_BLEND_DST_COLOR              =GZ_DST_COLOR ,             
    GZ_BLEND_SRC_COLOR              =GZ_SRC_COLOR ,             
    GZ_BLEND_ONE_MINUS_DST_COLOR    =GZ_ONE_MINUS_DST_COLOR,    
    GZ_BLEND_ONE_MINUS_SRC_COLOR    =GZ_ONE_MINUS_SRC_COLOR,    
    GZ_BLEND_SRC_ALPHA              =GZ_SRC_ALPHA,              
    GZ_BLEND_ONE_MINUS_SRC_ALPHA    =GZ_ONE_MINUS_SRC_ALPHA,    
    GZ_BLEND_DST_ALPHA              =GZ_DST_ALPHA,              
    GZ_BLEND_ONE_MINUS_DST_ALPHA    =GZ_ONE_MINUS_DST_ALPHA,    
    GZ_BLEND_SRC_ALPHA_SATURATE     =GZ_SRC_ALPHA_SATURATE      
};

enum gzAlphaFuncFactor
{
    GZ_ALPHA_FUNC_NEVER     =GZ_NEVER,      
    GZ_ALPHA_FUNC_ALWAYS    =GZ_ALWAYS,     
    GZ_ALPHA_FUNC_LESS      =GZ_LESS,       
    GZ_ALPHA_FUNC_LEQUAL    =GZ_LEQUAL,     
    GZ_ALPHA_FUNC_EQUAL     =GZ_EQUAL,      
    GZ_ALPHA_FUNC_GEQUAL    =GZ_GEQUAL,     
    GZ_ALPHA_FUNC_GREATER   =GZ_GREATER,    
    GZ_ALPHA_FUNC_NOTEQUAL  =GZ_NOTEQUAL    
};

enum gzPolyOffsetMode
{ 
    GZ_POLYGON_OFFSET_FILL_MODE =GZ_POLYGON_OFFSET_FILL,    
    GZ_POLYGON_OFFSET_LINE_MODE =GZ_POLYGON_OFFSET_LINE,    
    GZ_POLYGON_OFFSET_POINT_MODE=GZ_POLYGON_OFFSET_POINT    
};

enum gzStateDebugMode
{
    GZ_STATE_DEBUG_OFF              =   0,          
    GZ_STATE_DEBUG_SHOW_NORMALS     =   (1<<0),     
    GZ_STATE_DEBUG_SHOW_BSPHERE     =   (1<<1),     
    GZ_STATE_DEBUG_COLLECT_STATS    =   (1<<2),     
};

GZ_USE_BIT_LOGIC(gzStateDebugMode);     // Allow | & operators for gzStateDebugMode

//******************************************************************************
// Function : gzGraphicsStats
//                                  
// Purpose  : Creates a string with statistics about the GFX pieline
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  021208  Created 
//                                  
//******************************************************************************
GZ_GRAPH_EXPORT gzString gzGraphicsStats(gzContext *context);


//******************************************************************************
// Class    : gzStateAttribute
//                                  
// Purpose  : Holds the current state attributes
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  981111  Created 
//                                  
//******************************************************************************
class gzStateAttribute
{
public:

    // State attribute management
    GZ_GRAPH_EXPORT gzVoid activate(gzContext *context,gzBool activatePrograms);

    GZ_GRAPH_EXPORT gzVoid activatePrograms(gzContext *context);
    
    GZ_GRAPH_EXPORT gzStateAttribute();

    GZ_GRAPH_EXPORT virtual ~gzStateAttribute(){};

    GZ_GRAPH_EXPORT gzVoid pushCurrentStateAttribute(gzContext *context);

    // --------------- Current States ----------------------
    
    GZ_GRAPH_EXPORT static gzTexture *      getCurrentStateTexture(gzContext *context);
    
    GZ_GRAPH_EXPORT static gzMaterial*      getCurrentStateMaterial(gzContext *context);
    

    GZ_GRAPH_EXPORT static gzGFXProgram *   getCurrentGFXProgram(gzContext *context,gzGFXProgramType type);

    GZ_GRAPH_EXPORT static gzFloat getCurrentStateTransparency(gzContext *context);

    GZ_GRAPH_EXPORT static gzBool getActiveSeparation(gzContext *context);

    // -------------- Control ------------------------------

    GZ_GRAPH_EXPORT static gzVoid resetIndex(gzContext *context);

    GZ_GRAPH_EXPORT static gzULong getCurrentStateAttributeIndex(gzContext *context);

    GZ_GRAPH_EXPORT static gzBool activateIndex(gzContext *context , gzULong index);


    GZ_GRAPH_EXPORT virtual gzVoid  setCopyMode(gzCopyMode mode);

    // State attribute data

    GZ_GRAPH_EXPORT gzBool isEnabled(gzStateMode mode) { return (m_enable_mode & mode)!=0; }

    GZ_GRAPH_EXPORT gzStateDebugMode getDebugMode();

    GZ_GRAPH_EXPORT gzVoid operator=(const gzStateAttribute & right);


    GZ_GRAPH_EXPORT gzBool operator!=(const gzStateAttribute & right);


    GZ_GRAPH_EXPORT gzBool operator==(const gzStateAttribute & right);

    GZ_GRAPH_EXPORT gzVoid clear();

private:
    friend class gzState;
    friend class gzContext;

    // Attributes

    gzStateMode         m_enable_mode;
    gzStateMode         m_disable_mode;

    gzUShort            m_lineStipple;
    gzInt               m_stippleFactor;

    gzStateBlendFactor  m_blend_src;
    gzStateBlendFactor  m_blend_dst;

    gzPolygonModeType   m_polygon_front_mode;
    gzPolygonModeType   m_polygon_back_mode;

    // Texture enabled is embedded in texture class
    gzArray< gzRefPointer<gzTexture>    >   m_texture;

    // Material enabled is embedded in material class
    gzRefPointer<gzMaterial>                m_material;

    gzRefPointer<gzMaterial>                m_backmaterial;

    // TexEnv
    gzArray< gzRefPointer<gzTexEnv> >       m_texenv;

    // TexGen
    gzArray< gzRefPointer<gzTexGen> >       m_texgen;

    gzArray< gzRefPointer<gzGFXProgram> >   m_gfxPrograms;


    // Polygon Offset
    gzPolyOffsetMode    m_polygonOffsetMode;
    gzFloat             m_polygonOffsetFactor;
    gzFloat             m_polygonOffsetUnit;

    // ActionStage

    gzActionStage       m_actionStage;

    // Debug info
    gzStateDebugMode    m_debugMode;

    // Transparency
    gzFloat             m_transparency;

    // Alpha func
    gzAlphaFuncFactor   m_alphaFunc;
    gzFloat             m_alphaRef;

    // Generic
    gzULong             m_currentStateUpdateID;
    gzBool              m_accumulateTransparency:1;
    gzBool              m_separateBackAndFrontRender:1;
    gzBool              m_useTransp:1;
};

//******************************************************************************
// Class    : gzState
//                                  
// Purpose  : Provides the user interface for state management
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  981111  Created 
//                                  
//******************************************************************************
class gzState : public gzObject 
{
public:
    GZ_DECLARE_TYPE_INTERFACE_EXPORT(GZ_GRAPH_EXPORT);  // typed interface
    
    GZ_GRAPH_EXPORT gzState();
    
    GZ_GRAPH_EXPORT virtual ~gzState(){};

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


    GZ_GRAPH_EXPORT virtual gzBool  useDeepCopy();
    

    GZ_GRAPH_EXPORT virtual gzVoid  setCopyMode(gzCopyMode mode);

    // ---------- Activation of states ----------------------------------


    GZ_GRAPH_EXPORT gzVoid activate(gzContext *context);        // Immediate mode
    GZ_GRAPH_EXPORT gzVoid deactivate(gzContext *context);      // Immediate mode

    // ---------- Global state control ( scene graph mode ) -------------


    GZ_GRAPH_EXPORT static gzVoid setGlobalState(  gzContext *context, gzState *state );
    
    //The state is applied as current state to the context.
    GZ_GRAPH_EXPORT static gzVoid setCurrentState( gzContext *context, gzState *state );
    
    //Returns the current state for the context.
    GZ_GRAPH_EXPORT static gzState *getCurrentState(gzContext *context);

    GZ_GRAPH_EXPORT static gzVoid activateCurrentState(gzContext *context);
    

    GZ_GRAPH_EXPORT static gzVoid invalidateActiveState(gzContext *context);


    GZ_GRAPH_EXPORT static gzVoid resetIndex(gzContext *context);

    GZ_GRAPH_EXPORT static gzVoid push(gzContext *context);

    GZ_GRAPH_EXPORT static gzVoid pop(gzContext *context);

    GZ_GRAPH_EXPORT static gzActionStage useActionStage(gzContext *context);


    GZ_GRAPH_EXPORT gzVoid setMode( gzStateMode mode , gzStateModeActivation activation );
    

    GZ_GRAPH_EXPORT gzVoid setOverride( gzStateMode mode , gzStateModeActivation activation );
    
    GZ_GRAPH_EXPORT gzStateModeActivation getMode(gzStateMode mode);

    GZ_GRAPH_EXPORT gzVoid disableAllNonEnabledModes();

    // Attributes


    GZ_GRAPH_EXPORT gzVoid setLineStipple( gzUShort stipple );
    

    GZ_GRAPH_EXPORT gzVoid setStippleFactor( gzInt factor );


    GZ_GRAPH_EXPORT gzVoid setBlendFunction( gzStateBlendFactor src  , gzStateBlendFactor dst );
    GZ_GRAPH_EXPORT gzVoid setSeparateFrontAndBackRender(gzBool on);

    /*
    The default mode is GZ_POLYGON_FILL.
    */
    GZ_GRAPH_EXPORT gzVoid setFrontPolygonMode( gzPolygonModeType mode );
    
    /*
    The default mode is GZ_POLYGON_FILL.
    */
    GZ_GRAPH_EXPORT gzVoid setBackPolygonMode( gzPolygonModeType mode );


    GZ_GRAPH_EXPORT gzVoid      setTexture( gzTexture *texture , gzULong unit=0);
    

    GZ_GRAPH_EXPORT gzTexture * getTexture(gzULong unit=0);
    
    GZ_GRAPH_EXPORT gzVoid      setNumberOfTextures(gzULong units);
    
    GZ_GRAPH_EXPORT gzULong     getNumberOfTextures();


    GZ_GRAPH_EXPORT gzVoid      setMaterial( gzMaterial *material );
    
    GZ_GRAPH_EXPORT gzMaterial  *getMaterial();


    GZ_GRAPH_EXPORT gzVoid      setBackMaterial( gzMaterial *material );

    GZ_GRAPH_EXPORT gzMaterial  *getBackMaterial();


    GZ_GRAPH_EXPORT gzVoid      setTexEnv( gzTexEnv *env , gzULong unit=0);
    
    GZ_GRAPH_EXPORT gzTexEnv *  getTexEnv(gzULong unit=0);
    

    GZ_GRAPH_EXPORT gzVoid      setNumberOfTexEnv(gzULong units);
    
    GZ_GRAPH_EXPORT gzULong     getNumberOfTexEnv();



    GZ_GRAPH_EXPORT gzVoid      setTexGen( gzTexGen *gen , gzULong unit=0);

    GZ_GRAPH_EXPORT gzTexGen *  getTexGen(gzULong unit=0);


    GZ_GRAPH_EXPORT gzVoid      setNumberOfTexGen(gzULong units);

    GZ_GRAPH_EXPORT gzULong     getNumberOfTexGen();


    GZ_GRAPH_EXPORT gzVoid      setTransparency( gzClampf transparency , gzBool accumTransparency=TRUE);
    
    GZ_GRAPH_EXPORT gzClampf    getTransparency( gzBool *accumTransparency=NULL);

    GZ_GRAPH_EXPORT gzVoid setPolygonOffset(gzPolyOffsetMode mode , gzFloat factor , gzFloat unit);

    /*
        Must be enabled with GZ_STATE_ACTION_STAGE
    */
    GZ_GRAPH_EXPORT gzVoid setActionStage(gzActionStage stage );

    GZ_GRAPH_EXPORT gzActionStage getActionStage();


    GZ_GRAPH_EXPORT gzVoid setDebugMode(gzStateDebugMode mode );


    GZ_GRAPH_EXPORT gzVoid setAlphaFunc(gzAlphaFuncFactor func , gzClampf refValue);

    // Utility functions

    GZ_GRAPH_EXPORT gzVoid setBestAlphaTextureSettings(gzImage *image,gzSerializeAdapterFlags flags);

    // GFX Programs

    /*
    The GZ_STATE_GFX_PROGRAM mode has to be enabled if you want to use shaders.
    */
    GZ_GRAPH_EXPORT gzVoid setGFXProgram(gzGFXProgramType type,gzGFXProgram *program);

    // ----------- Static utlities for the context ------------------


    GZ_GRAPH_EXPORT static gzVoid setCurrentDepthFunc( gzContext *context , gzEnum func);

    GZ_GRAPH_EXPORT static gzEnum getCurrentDepthFunc(gzContext *context);


    GZ_GRAPH_EXPORT static gzVoid setUseDepthBuffer( gzContext *context , gzBool on);

    GZ_GRAPH_EXPORT static gzBool getUseDepthBuffer(gzContext *context);

    // ---------- Debug function ----------------------------------------

    GZ_GRAPH_EXPORT virtual gzVoid  debugOutput(gzString base , gzString anchor , gzDebugFlags features);

    // ---------- Serializing -------------------------------------------
    GZ_GRAPH_EXPORT virtual gzVoid write(gzSerializeAdapter *adapter);

    GZ_GRAPH_EXPORT virtual gzVoid read(gzSerializeAdapter *adapter);


    GZ_GRAPH_EXPORT virtual gzULong getDataSize(gzSerializeAdapter *adapter) const;


    GZ_GRAPH_EXPORT gzBool operator==(const gzState & right);
    

    GZ_GRAPH_EXPORT gzBool operator!=(const gzState & right);


private:

    friend class gzContext;

    static gzVoid activateCurrentNow(gzContext *context);

    gzVoid updateFromState( gzContext *context,gzState *state);

    gzStateAttribute                    m_originalState;
    gzStateMode                         m_original_lock_mode;

    gzDynamicArray<gzStateAttribute>    m_currentState;
    gzDynamicArray<gzStateMode>         m_current_lock_mode;
    
    gzBool          m_active:1;

};

GZ_DECLARE_REFPTR(gzState);

#endif

---