gzContext.h

Go to the documentation of this file.

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

#include "gzBaseLibrary.h"

#include "gzGraphicsEngine.h"
#include "gzState.h"
#include "gzLight.h"
#include "gzClipPlane.h"
#include "gzRenderAction.h"
#include "gzCuller.h"
#include "gzRoi.h"
#include "gzEnvironment.h"
#include "gzRecursive.h"
#include "gzTexture.h"
#include "gzFont.h"

//******************************************************************************
// Class    : gzContext
//                                  
// Purpose  : 
//                                  
// Notes    : - 
//                                  
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  020204  Created 
//                                  
//******************************************************************************
class gzContext : public gzReference
{
public:

    // ------------------ General methods --------------------

    GZ_GRAPH_EXPORT gzContext();

    GZ_GRAPH_EXPORT gzContext(const gzContext &copy);

    GZ_GRAPH_EXPORT virtual ~gzContext();

    GZ_GRAPH_EXPORT gzVoid transferStateTo(gzContext *context);

    GZ_GRAPH_EXPORT virtual gzBool  useDeepCopy() { return FALSE; } 


    GZ_GRAPH_EXPORT static gzContext *getCurrentContext(gzULong threadID);

    GZ_GRAPH_EXPORT static gzContext *getCurrentContext();  // gets default context on a TID basis

    GZ_GRAPH_EXPORT static gzVoid     setCurrentContext(gzContext *context);

    GZ_GRAPH_EXPORT static gzVoid     clearContextStorage();

    GZ_GRAPH_EXPORT gzVoid  cleanContext();

    GZ_GRAPH_EXPORT gzVoid  cleanStateAttributes();

    GZ_GRAPH_EXPORT gzVoid  reactivate();

    // ---------------- Common methods ---------------------------------------------

    GZ_GRAPH_EXPORT gzVoid setColorMask(gzBool redMask , gzBool greenMask , gzBool blueMask , gzBool alphaMask );

    GZ_GRAPH_EXPORT gzVoid setMaxTransparencySortDistance(const gzReal & distance);

    GZ_GRAPH_EXPORT gzVoid setMinCullFactorSize(const gzReal & size);
    GZ_GRAPH_EXPORT gzVoid setMinShadowCullFactorSize(const gzReal & size);
    GZ_GRAPH_EXPORT gzVoid setCullMask(const gzCullMaskValue &cullMask);

    static GZ_GRAPH_EXPORT gzDouble getPathID(gzList<gzNode> &history);

    GZ_GRAPH_EXPORT gzVoid  setSelectedNode(gzList<gzNode> &history);
    GZ_GRAPH_EXPORT gzVoid  setNoSelectedNode();

    GZ_GRAPH_EXPORT gzVoid  readBackState(gzEnumBits bits);

    gzDynamicTypeContainer  attributeContainer;

    // ---------------- Common Attributes ------------------------------------------

    // Context info, You need to supply this on non Gizmo3D window applications

    gzWindowContext         winContext;         
    gzDeviceContext         deviceContext;      
    gzRenderContext         renderContext;      

    // General vars

    gzContext               *mainContext;       

    // State vars

    gzRefPointer<gzState>   currentState;
    gzRefPointer<gzState>   globalState;
    gzQueue<gzState *>      stackState;
    gzBool                  stateChange;

    // Depth State Bits
    gzEnum                  currentDepthFunc;
    gzBool                  enabledDepthTest;
    gzBool                  enabledDepthWriteMask;

    gzBool                  useDepthBuffer;     

    // StateAttribute vars

    gzArray< gzTexture * >  currentTexture;

    gzMaterial *            currentMaterial;
    gzMaterial *            currentBackMaterial;

    gzArray< gzTexEnv * >   currentTexEnv;

    gzArray< gzTexGen * >   currentTexGen;

    gzArray<gzGFXProgram *> currentGFXPrograms;
    gzArray<gzGFXProgram *> pendingGFXPrograms;

    gzBool                  hasActiveGFXPrograms;

    gzBool                  activeSeparation;

    gzTexture *             currentStateTexture;
    gzMaterial *            currentStateMaterial;

    // state

    gzULong                             activeStateAttributeIndex;

    gzDynamicArray<gzStateAttribute>    currentStateAttributeStack;
    gzULong                             currentStateAttributeIndex;
    gzStateAttribute *                  currentStateAttribute;


    // Blending

    gzBool currentStipple;
    gzBool currentBlend;
    gzBool currentPolygonMode;

    // Alpha Func
    gzBool currentAlphaFunc;

    gzFloat currentLineWidth;
    gzFloat currentPointSize;

    // LightState

    gzDynamicArray<gzLightState>    currentLightStateStack;
    gzULong                         currentLightStateIndex;
    gzLightState                    currentLightState;
    gzULong                         activeLightStateIndex;
    gzQueue<gzLightState>           currentLightStateStorage;

    gzLightState                    mainLightState;

    // Lights
    gzBool                          enabledLight[GZ_NUMBER_OF_ACTIVE_LIGHTS];

    // Generic lighting

    gzRGBA      globalAmbient;
    gzBool      localViewer;
    gzBool      twoSideLighting;
    gzBool      stateDisabledLighting;

    // ClipState

    gzDynamicArray<gzClipState> currentClipStateStack;
    gzULong                     currentClipStateIndex;
    gzClipState                 currentClipState;
    gzULong                     activeClipStateIndex;
    gzQueue<gzClipState>        currentClipStateStorage;

    gzClipState                 mainClipState;

    gzBool                      enabledClipStates[GZ_NUMBER_OF_ACTIVE_CLIP_PLANES];

    // Fog

    gzDynamicArray<gzFogInfo>   currentFogStateStack;
    gzULong                     currentFogStateIndex;
    gzFogInfo                   currentFogState;
    gzULong                     activeFogStateIndex;
    gzQueue<gzFogInfo>          currentFogStateStorage;

    // Transform

    gzDynamicArray<gzMatrix4>   currentTransformStack;
    gzQueue<gzMatrix4>          currentTransformStorage;

    gzULong                     currentTransformIndex;
    gzQueue<gzULong>            currentTransformIndexStorage;
    gzULong                     nextTransformIndex;
    gzULong                     activeTransformIndex;

    gzMatrix4                   currentTransform;
    gzMatrix4                   currentInvertedTransform;
    gzULong                     currentInvertedIndex;

    gzReal                      currentMaxScale;
    gzQueue<gzReal>             currentMaxScaleStorage;
    gzDynamicArray<gzReal>      currentMaxScaleStack;

    gzReal                      mainMaxScale;
    gzMatrix4                   mainTransform;
    gzMatrix4                   mainInvertedTransform;

    gzMatrix4                   mainProjTransform;
    gzMatrix4                   mainInvertedProjTransform;

    gzULong                     reservedTransforms;
    
    // Shadow Transform UpdateID
    
    gzDynamicArray<gzULong>     currentTransformUpdateIDStack;
    gzQueue<gzULong>            currentTransformUpdateIDStorage;
    gzULong                     currentTransformUpdateID;

    // Frame

    gzULong                     currentFrameIndex;
    gzDouble                    currentFrameFraction;
    gzULong                     currentNextFrameIndex;

    gzQueue<gzULong>            currentFrameIndexStorage;
    gzQueue<gzULong>            currentNextFrameIndexStorage;
    gzQueue<gzDouble>           currentFrameFractionStorage;


    // General vars

    gzULong                 pid;
    gzULong                 enumerator;
    gzDouble                renderTime;
    gzDouble                nowTime;
    gzULong                 renderID;
    gzULong                 stencilMaxValue;
    gzULong                 multiPassNumber;
    gzULong                 winWidth;
    gzULong                 winHeight;
    gzLong                  winOffsetX;
    gzLong                  winOffsetY;


    gzBool                  compiled;

    // general transparency
    gzBool                  useTransparency;
    gzFloat                 transparency;
    gzFloat                 currentMaterialTransparency;

    // unique identifier
    gzULong                 contextID;

    // Portal Recursive Mask 
    gzULong                 currentStencilValue;

    // Recursive depth

    gzReal                              currentRecursiveDepth;
    gzQueue<gzReal>                     currentRecursiveDepthStorage;
    gzDynamicArray<gzRecursiveData>     recursiveDataStorage;

    gzReal                              currentRecursiveDepthScaleFactor;
    gzQueue<gzReal>                     currentRecursiveDepthScaleFactorStorage;


    // Render engine
    gzUByte                             reverseRenderTextures;

    gzDataSort<gzRenderNode>            sortedNodes[GZ_ACTION_STAGE_COUNT];

    gzCamera                            * currentCamera;
    gzRefPointer<gzContext>             recursiveContext;

    // Cullers

    gzRefList<gzCuller>                 cullers;

    // Lods

    gzBool                              hasCalculatedInvScaleMag;
    gzFloat                             invScaleMag;
    gzFloat                             invLodFactorMag;

    gzReal                              currentLodDistance;
    gzQueue<gzReal>                     currentLodDistanceStorage;

    gzReal                              genericFadeDistance;

    // Sorting far distance for transparent objects
    gzDouble                            maxTransparencySortDistanceFactor;

    // minimal feature culling size
    gzReal                              minCullFactorSize;
    gzReal                              minShadowCullFactorSize;


    // Lod
    gzDynamicArray<gzBool>              currentLodStack;
    gzULong                             currentLodIndex;

    // Polygon Offset

    gzPolyOffsetMode                    currentPolygonOffsetMode;
    gzActionStage                       actionStage;


    // Texture IDs
    gzRefPointer<gzRefIdStorage>        unboundTextureID;

    // DisplayList IDs
    gzRefPointer<gzRefIdStorage>        unboundDisplayListID;

    // VBO IDs
    gzRefPointer<gzRefIdStorage>        unboundVboID;

    // Intersector Busy in same thread

    gzBool                              inIntersector;

    // Roi information

    gzDoubleXYZ                         currentRoiPosition;
    gzQueue<gzDoubleXYZ>                currentRoiPositionStorage;
    gzBool                              isCameraRoiPositioned;
    gzULong                             currentRoiLocalMatrixIndex;
    gzMatrix4                           currentRoiLocalMatrix;

    gzULong                             forceLodMask;

    // Lod forced renering
    gzQueue<gzULong>                    forceLodMaskStorage;

    // Shadow utilites
    gzDynamicArray<gzFloat>             imagemap;
    gzBool                              shadowRender;
    gzBool                              clearBCap;
    gzBool                              infiniteFarPlane;

    gzList<gzLight>                     shadowedLights;

    // Index utility
    gzDynamicArray<gzULong>             indArray;

    // ColorMask                        

    gzBool                              redMask;
    gzBool                              greenMask;
    gzBool                              blueMask;
    gzBool                              alphaMask;

    // Stereo info
    gzBool                              stereo;

    // State info about currentCulling modes
    gzInt                               currentCull;
    gzInt                               currentPolygonModeBack;
    gzInt                               currentPolygonModeFront;


    // Stats
    gzULong                             numberOfDrawnTris;  // All primitives

    gzULong                             primTriCount;
    gzULong                             primQuadCount;
    gzULong                             primQuadStripCount;
    gzULong                             primTriFanCount;
    gzULong                             primTriStripCount;
    gzULong                             primPointCount;
    gzULong                             primLineCount;
    gzULong                             primLineStripCount;
    gzULong                             primLineLoopCount;
    gzULong                             primPolyCount;

    gzDouble                            cullTime;
    gzDouble                            drawTime;
    gzDouble                            appTime;
    gzDouble                            lockTime;
    gzDouble                            nodeDataTime;

    gzDouble                            avgCullTime;
    gzDouble                            avgDrawTime;
    gzDouble                            avgAppTime;
    gzDouble                            avgLockTime;
    gzDouble                            avgNodeDataTime;


    gzULong                             textureTransfers;
    gzULong                             textureActivations;
    gzULong                             textureSize;

    // Random sequence

    gzULong                             currentRandomSeed;
    gzQueue<gzULong>                    currentRandomSeedStorage;

    // Sequence ordering
    gzULong                             currentSequence;
    gzQueue<gzULong>                    currentSequenceStorage;

    // Origin

    gzULong                             currentOriginID;
    gzQueue<gzULong>                    currentOriginIDStorage;
    gzReal                              currentOriginScale;


    // Update max count numbers per frame

    gzULong                             maxVBOGeomPerFrame;
    gzULong                             currentVBOGeomPerFrame;

    gzULong                             maxDisplayListGeomPerFrame;
    gzULong                             currentDisplayListGeomPerFrame;

    // GLSL

    gzHandle                            currentProgramObject;
    gzInt                               currentInvertedTransformUniformID;

    // Transform Base

    gzULong                             currentTransformBaseIndex;
    gzULong                             nextTransformBaseIndex;
    gzQueue<gzULong>                    currentTransformBaseIndexStorage;
    gzULong                             activeTransformBaseIndex;

    gzULong                             currentNumberOfTransformBases;
    gzQueue<gzULong>                    currentTransformBaseSizeStorage;

    gzDynamicArray<gzTransformID>       currentTransformBaseStack;

    gzDouble                            pathID;
    gzDouble                            pathStep;

    gzNode  *                           selectedNode;
    gzDouble                            selectedPathID;

    gzBool                              enablePathID;

    // Culling

    gzCullMaskValue                     cullMask;
    
    // Texture transfer
    
    gzUInt                              textureBufferID;

private:

    gzVoid init();

    gzRefPointer<gzLibReference>    m_libref;

    friend class gzContextStore;

    static gzRefDict<gzValueCompareInterface,gzContext> s_contextList;

    static  gzULong                 s_lastPid;
    static  gzContext *             s_lastContext;

    static gzUniqueIDManager        s_idManager;

    static  gzULong                 s_enumerator;

    static gzMutex                  s_contextMutex;
};


#endif

---