- Main Page
- Related Pages
- Modules
- Classes
- Examples

# Observer.h

    //-
    // ==========================================================================
    // Copyright 1995,2006,2008 Autodesk, Inc. All rights reserved.
    //
    // Use of this software is subject to the terms of the Autodesk
    // license agreement provided at the time of installation or download,
    // or which otherwise accompanies this software in either electronic
    // or hard copy form.
    // ==========================================================================
    //+
    #ifndef OBSERVER_H
    #define OBSERVER_H

    #include <map>
    #include <vector>
    #include <string>

    #include <IAshliFX.h>

    #include "glExtensions.h"

    //
    //
    class stateItem {
      public:
        virtual ~stateItem() {};
        virtual void apply() = 0;
    };

    //
    //
    class blendStateItem : public stateItem {
      // enable, src_factor, dst_factor, blend_func, blend factor
      GLenum m_enable;
      GLenum m_srcFactor;
      GLenum m_dstFactor;
      GLenum m_blendOp;

      //anonymous struct + anonymous union
      // this might be a bit too tricky for gcc, but it makes the cleanest code
      union {
        GLbitfield m_options;
        struct {
          unsigned int m_useEnable : 1;    //call glEnable
          unsigned int m_useBlend : 1;     //call glBlend
          unsigned int m_getSrcFactor : 1; //call glGet for srcFactor
          unsigned int m_getDstFactor : 1; //call glGet for dstFactor
          unsigned int m_useBlendFunc : 1; //call glBlendFunction
          unsigned int m_useBlendOp : 1;  //call glBlendOp
        };
      };
      public:
        blendStateItem() : m_enable(GL_FALSE), m_srcFactor(GL_ONE), m_dstFactor(GL_ZERO), m_blendOp(GL_FUNC_ADD), m_options(0) {};
        virtual ~blendStateItem() {};
        virtual void apply();

        friend class stateObserver;
    };

    //
    //
    class depthStateItem : public stateItem {
      // enable, depth func, depth mask
      GLenum m_enable;
      GLenum m_depthFunc;
      GLboolean m_depthMask;

      //anonymous struct + anonymous union
      // this might be a bit too tricky for gcc, but it makes the cleanest code
      union {
        GLbitfield m_options;
        struct {
          unsigned int m_useEnable : 1;    //call glEnable
          unsigned int m_useDepthFunc : 1; //call glDepthFunc
          unsigned int m_useDepthMask : 1; //call glDepthMask
        };
      };

      public:
        depthStateItem() : m_enable(0), m_depthFunc(GL_LEQUAL), m_depthMask(GL_TRUE), m_options(0) {};
        virtual ~depthStateItem() {};
        virtual void apply();

        friend class stateObserver;
    };

    //
    //
    class stencilStateItem : public stateItem {
      // enable, read mask, write mask, depth fail, stencil fail, stecil pass, ref
      GLenum m_enable;
      GLenum m_func;
      GLuint m_rmask;
      GLuint m_ref;
      GLenum m_depthPassOp;
      GLenum m_depthFailOp;
      GLenum m_stencilFailOp;
      GLuint m_mask;

      //anonymous struct + anonymous union
      // this might be a bit too tricky for gcc, but it makes the cleanest code
      union {
        GLbitfield m_options;
        struct {
          unsigned int m_useEnable : 1;    //call glEnable
          unsigned int m_useStencilFunc : 1;     //call glBlend
          unsigned int m_getStencilFunc : 1; //call glGet for srcFactor
          unsigned int m_getStencilRMask : 1; //call glGet for dstFactor
          unsigned int m_getStencilRef : 1; //call glBlendFunction
          unsigned int m_useStencilOp : 1;
          unsigned int m_getDepthPass : 1;
          unsigned int m_getDepthFail : 1;
          unsigned int m_getStencilFail : 1;
          unsigned int m_useStencilMask : 1;
        };
      };
      public:
        stencilStateItem() : m_enable(0), m_func(GL_EQUAL), m_rmask(0xff), m_ref(0), m_depthPassOp(GL_KEEP), m_depthFailOp(GL_KEEP),
          m_stencilFailOp(GL_KEEP), m_mask(0xff), m_options(0) {};
        virtual ~stencilStateItem() {};
        virtual void apply();

        friend class stateObserver;
    };

    //
    //
    class primitiveStateItem : public stateItem {
      // polygon mode, cull, polygon offset
      GLenum m_polygonMode;
      GLenum m_enableCull;
      GLenum m_cullFace;
      GLenum m_enablePolygonOffset;
      GLfloat m_factor;
      GLfloat m_units;

      //anonymous struct + anonymous union
      // this might be a bit too tricky for gcc, but it makes the cleanest code
      union {
        GLbitfield m_options;
        struct {
          unsigned int m_usePolygonMode : 1;     //call glBlend
          unsigned int m_useEnableCull : 1; //call glGet for srcFactor
          unsigned int m_useCullFace : 1; //call glGet for dstFactor
          unsigned int m_useEnablePolygonOffset : 1; //call glBlendFunction
          unsigned int m_usePolygonOffset : 1; //call glBlendFunction
          unsigned int m_getFactor : 1; //call glBlendFunction
          unsigned int m_getUnits : 1; //call glBlendFunction
        };
      };
      public:
        primitiveStateItem() : m_polygonMode(GL_FILL), m_enableCull(GL_FALSE), m_cullFace(GL_BACK), m_enablePolygonOffset(GL_FALSE),
          m_factor(0.0f), m_units(0.0f), m_options(0) {};
        virtual ~primitiveStateItem() {};
        virtual void apply();

        friend class stateObserver;
    };

    //
    //
    class alphaStateItem : public stateItem {
      // alpha_test_enable, alpha_func, ref
      GLenum m_enable;
      GLenum m_alphaFunc;
      GLfloat m_ref;

      //anonymous struct + anonymous union
      // this might be a bit too tricky for gcc, but it makes the cleanest code
      union {
        GLbitfield m_options;
        struct {
          unsigned int m_useEnable : 1;    //call glEnable
          unsigned int m_useAlphaFunc : 1;     //call glBlend
          unsigned int m_getAlphaFunc : 1; //call glGet for srcFactor
          unsigned int m_getRef : 1; //call glGet for dstFactor
        };
      };

      public:
        alphaStateItem() : m_enable(GL_FALSE), m_alphaFunc(GL_ALWAYS), m_ref(0.0f), m_options(0) {};
        virtual ~alphaStateItem() {};
        virtual void apply();

        friend class stateObserver;
    };

    //
    //
    class colorStateItem : public stateItem {
      // dither, color mask
      GLenum m_dither;
      GLboolean m_mask[4];

      //anonymous struct + anonymous union
      // this might be a bit too tricky for gcc, but it makes the cleanest code
      union {
        GLbitfield m_options;
        struct {
          unsigned int m_useDither : 1;    //call glEnable
          unsigned int m_useMask : 1;     //call glBlend
        };
      };

      public:
        colorStateItem() : m_dither(GL_TRUE), m_options(0) {};
        virtual ~colorStateItem() {};
        virtual void apply();

        friend class stateObserver;
    };

    //
    //
    class fogStateItem : public stateItem {
      // enable, start, end, density, color
      GLenum m_enable;
      GLenum m_mode;
      GLfloat m_start;
      GLfloat m_end;
      GLfloat m_density;
      GLfloat m_color[3];

      //anonymous struct + anonymous union
      // this might be a bit too tricky for gcc, but it makes the cleanest code
      union {
        GLbitfield m_options;
        struct {
          unsigned int m_useEnable : 1;    //call glEnable
          unsigned int m_useMode : 1;    //set Fog Mode
          unsigned int m_useFogStart : 1;     //call glBlend
          unsigned int m_useFogEnd : 1; //call glGet for srcFactor
          unsigned int m_useFogDensity : 1; //call glGet for dstFactor
          unsigned int m_useFogColor : 1; //call glBlendFunction
        };
      };

      public:
        fogStateItem() : m_enable(GL_FALSE), m_mode(GL_LINEAR), m_start(0.0f), m_end(1.0f), m_density(1.0f), m_options(0) {};
        virtual ~fogStateItem() {};
        virtual void apply();

        friend class stateObserver;
    };

    //
    //
    class pointStateItem : public stateItem {
      GLfloat m_pointSize;
      GLfloat m_pointSizeMin;
      GLfloat m_pointSizeMax;
      GLfloat m_pointAtten[3];
      GLenum m_pointSprite;

      //anonymous struct + anonymous union
      // this might be a bit too tricky for gcc, but it makes the cleanest code
      union {
        GLbitfield m_options;
        struct {
          unsigned int m_usePointSize : 1;    //call glPointSzie
          unsigned int m_usePointSizeMin : 1;     //set Pt size Min
          unsigned int m_usePointSizeMax : 1; //set Pt size Max
          unsigned int m_usePointAtten : 1;  //set Pt Atten
          unsigned int m_getAttenA : 1;
          unsigned int m_getAttenB : 1;
          unsigned int m_getAttenC : 1;
          unsigned int m_usePointSprite : 1; //call glGet for dstFactor
        };
      };

      public:
        pointStateItem() : m_pointSize(1.0f), m_pointSizeMin(1.0f), m_pointSizeMax(32.0f), m_pointSprite(GL_FALSE), m_options(0) {};
        virtual ~pointStateItem() {};
        virtual void apply();

        friend class stateObserver;
    };

    //
    //
    class passState {
      public:
        passState() {};
        ~passState();

        void setState();

        std::map< std::string, int> m_vRegMap;
        std::map< std::string, int> m_fRegMap;

        std::vector<stateItem*> m_stateList;
    };

    //
    //
    class stateObserver : IObserveFX {
      public:

        stateObserver() : m_state(NULL), m_bs(NULL), m_ds(NULL), m_ss(NULL), m_ps(NULL), m_as(NULL), m_cs(NULL), m_fs(NULL), m_ptS(NULL) {};
        ~stateObserver() {};

        //these are the interface functions used by Ashli
        void setLightState(LightState state, int handle, const char* value);
        void setMaterialState(MaterialState state, int handle, const char* value);
        void setVertexRenderState(VertexRenderState state, int handle, const char* value);
        void setPixelRenderState(PixelRenderState state, int handle, const char* value);
        void setSamplerState(SamplerState state, int handle, const char* value);
        void setVertexShaderState(VertexShaderState state, int handle, const char* value);
        void setPixelShaderState(PixelShaderState state, int handle, const char* value);
        void setTextureState(TextureState state, int handle, const char* value);
        void setTransformState(TransformState state, int handle, const char* value);

        //this is used to configure a pass monitor
        void setPassMonitor( passState *state);
        void finalizePassMonitor();

      protected:

        //These functions parse the values and convert them to GL values
        bool isTrue( const char* value);
        bool isFalse( const char* value);
        GLenum compareFunc( const char* value);
        GLenum blendFactor( const char* value);
        GLenum stencilOp( const char* value);
        GLenum blendOp( const char* value);
        GLenum polyMode( const char* value);

        passState *m_state;

        blendStateItem *m_bs;
        depthStateItem *m_ds;
        stencilStateItem *m_ss;
        primitiveStateItem *m_ps;
        alphaStateItem *m_as;
        colorStateItem *m_cs;
        fogStateItem *m_fs;
        pointStateItem *m_ptS;
    };

    #endif //OBSERVER_H