---

sglStatelet.hpp

/*****************************************************************************
 * SGL: A Scene Graph Library
 *
 * Copyright (C) 1997-2001  Scott McMillan   All Rights Reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the Free
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *****************************************************************************
 *     File: sglStatelet.hpp
 *   Author: Tom Stimson
 *  Created: 25 June 2000
 *  Summary: elements of OpenGL state that are managed by SGL
 *****************************************************************************/

#ifndef __SGL_STATELET_HPP
#define __SGL_STATELET_HPP

#include <sgl.h>
#include <sglObject.hpp>
#include <sglMatrix.hpp>

class sglCurrState;

//============================================================================

class SGL_DLL_API sglStatelet : public sglObject
{
public:
   enum StateEnum
   {
      eALPHA_TEST,
      eANTI_ALIAS_LINE,
      eANTI_ALIAS_POINT,
      eANTI_ALIAS_POLYGON,
      eBLENDING,
      eCOLOR_MASK,
      eCULL_MODE,
      eDEPTH_MASK,
      eDEPTH_RANGE,
      eDEPTH_TEST,
      eDITHERING,
      eFOG,                    // see sglFog.hpp
      eFRONT_FACE,
      eHIGHLIGHT,
      eLIGHTING,
      eLINE_STIPPLE,
      eLINE_WIDTH,
      eLOGIC_OP,
      eMATERIAL,               // see sglMaterial.hpp
      eOCCLUSION_CULL,
      ePOINT_SIZE,
      ePOINT_PARAMETERS,
      ePOLY_BACK_STYLE,
      ePOLY_FRONT_STYLE,
      ePOLYGON_OFFSET,
      ePOLYGON_STIPPLE,
      eSHADE_MODEL,
      eTRANSFORM_MATRIX,       // see sglCull.hpp
      eTRANSPARENCY,

      // DO NOT ADD ANY NEW STATLETS BEYOND THIS POINT.

      eTEX_ENV,                // see sglTexEnv.hpp
      eTEX_GEN,                // see sglTexGen.hpp
      eTEXTURE,                // see sglTexture.hpp
      eTEXTURE_MATRIX,
      eNUM_BASIC_STATES

      // eTEX_ENV_UNIT_2
      // eTEX_GEN_UNIT_2
      // eTEXTURE_UNIT_2
      // eTEXTURE_MATRIX_UNIT_2
      // eTEX_ENV_UNIT_3
      // eTEX_GEN_UNIT_3
      // eTEXTURE_UNIT_3
      // eTEXTURE_MATRIX_UNIT_3
      // etc...
   };

public:
   virtual ~sglStatelet() {}

   virtual unsigned int getType() const { return m_type; }

   virtual void apply(sglCurrState* curr_state) const = 0;

   virtual bool getSorted() const { return false; }

   inline const void* getSortKey() const
      {
         if (m_index == UINT_MAX)
            return this;
         else
            return (const void*)m_index;
      }

   unsigned int getIndex() const { return m_index; }

   bool operator==(const sglStatelet &rhs) const
      {
         return (this == &rhs) || (m_type == rhs.m_type &&
                                   m_index == rhs.m_index &&
                                   m_index != UINT_MAX);
      }

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

protected:
   // constructor
   sglStatelet(StateEnum type)
      : m_index(0), m_type(type) {}

private:
   sglStatelet();  // not implemented
   sglStatelet(const sglStatelet &); // not implemented
   sglStatelet &operator=(const sglStatelet &); // not implemented

protected:
   // If getSorted() == false
   //    m_index is an array index where every index fully defines that state
   // If getSorted() == true
   //    0:        default state; sort key = 0
   //    UINT_MAX: sort key = this pointer
   mutable unsigned int m_index;   // should be set by subclass

private:
   StateEnum    m_type;
};


//============================================================================

class SGL_DLL_API sglBooleanStatelet : public sglStatelet
{
public:
   sglBooleanStatelet(StateEnum type, bool on)
      : sglStatelet(type), m_on(on) { setIndex(); }

   virtual ~sglBooleanStatelet() {}

   void enable(bool on) { m_on = on; setIndex(); }

   bool isEnabled() const { return m_on; }

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   void setIndex() { m_index = (m_on ? 1 : 0); }

   sglBooleanStatelet(); // not implemented
   sglBooleanStatelet(const sglBooleanStatelet &); // not implemented
   sglBooleanStatelet &operator=(const sglBooleanStatelet &);// not implemented

protected:
   bool m_on;
};


//============================================================================

class SGL_DLL_API sglAlphaTest : public sglStatelet
{
public:
   enum AlphaFuncEnum
   {
      eLESS     = GL_LESS,
      eALWAYS   = GL_ALWAYS,    // turns alpha test off
      eLEQUAL   = GL_LEQUAL,
      eEQUAL    = GL_EQUAL,
      eGEQUAL   = GL_GEQUAL,
      eGREATER  = GL_GREATER,
      eNOTEQUAL = GL_NOTEQUAL,
      eNEVER    = GL_NEVER      // what's the point of this?
   };

public:
   sglAlphaTest(AlphaFuncEnum func = eALWAYS, float ref = 0.0f)
         : sglStatelet(eALPHA_TEST), m_alpha_func(eALWAYS), m_alpha_ref(0.f)
      {
         setAlphaFunc(func, ref);
      }

   virtual ~sglAlphaTest() {}

   void setAlphaFunc(AlphaFuncEnum  func, float  ref);

   void getAlphaFunc(AlphaFuncEnum &func, float &ref) const
      { func = m_alpha_func;  ref = m_alpha_ref; }

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

   // See sglStatelet::getSorted() for details.
   virtual bool getSorted() const { return true; }

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   sglAlphaTest(const sglAlphaTest &); // not implemented
   sglAlphaTest &operator=(const sglAlphaTest &); // not implemented

   void setIndex();

private:
   AlphaFuncEnum  m_alpha_func;
   float          m_alpha_ref;
};


//============================================================================

class SGL_DLL_API sglAntiAliasLine : public sglBooleanStatelet
{
public:
   sglAntiAliasLine(bool on = false)
      : sglBooleanStatelet(eANTI_ALIAS_LINE, on) {}

   virtual ~sglAntiAliasLine() {}

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

private:
   sglAntiAliasLine(const sglAntiAliasLine &); // not implemented
   sglAntiAliasLine &operator=(const sglAntiAliasLine &); // not implemented
};


//============================================================================

class SGL_DLL_API sglAntiAliasPoint : public sglBooleanStatelet
{
public:
   sglAntiAliasPoint(bool on = false)
      : sglBooleanStatelet(eANTI_ALIAS_POINT, on) {}

   virtual ~sglAntiAliasPoint() {}

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

private:
   sglAntiAliasPoint(const sglAntiAliasPoint &); // not implemented
   sglAntiAliasPoint &operator=(const sglAntiAliasPoint &); // not implemented
};


//============================================================================

class SGL_DLL_API sglAntiAliasPolygon : public sglBooleanStatelet
{
public:
   sglAntiAliasPolygon(bool on = false)
      : sglBooleanStatelet(eANTI_ALIAS_POLYGON, on) {}

   virtual ~sglAntiAliasPolygon() {}

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

private:
   sglAntiAliasPolygon(const sglAntiAliasPolygon &); // not implemented
   sglAntiAliasPolygon &operator=(const sglAntiAliasPolygon &); // not impl'ed
};

//============================================================================

class SGL_DLL_API sglBlending : public sglStatelet
{
public:
   enum BlendFuncEnum
   {
      eZERO                = GL_ZERO,
      eONE                 = GL_ONE,
      eSRC_COLOR           = GL_SRC_COLOR,
      eONE_MINUS_SRC_COLOR = GL_ONE_MINUS_SRC_COLOR,
      eDST_COLOR           = GL_DST_COLOR,
      eONE_MINUS_DST_COLOR = GL_ONE_MINUS_DST_COLOR,
      eSRC_ALPHA           = GL_SRC_ALPHA,
      eONE_MINUS_SRC_ALPHA = GL_ONE_MINUS_SRC_ALPHA,
      eDST_ALPHA           = GL_DST_ALPHA,
      eONE_MINUS_DST_ALPHA = GL_ONE_MINUS_DST_ALPHA,
      eSRC_ALPHA_SATURATE  = GL_SRC_ALPHA_SATURATE
   };

public:
   sglBlending(BlendFuncEnum src_func = eSRC_ALPHA,
               BlendFuncEnum dst_func = eONE_MINUS_SRC_ALPHA,
               bool on = false)
         : sglStatelet(eBLENDING),
           m_src_func(src_func), m_dst_func(dst_func), m_on(on)
      { setIndex(); }

   virtual ~sglBlending() {}

   void enable(bool on) { m_on = on; setIndex(); }

   bool isEnabled() const  { return m_on; }

   void setBlendFunc(BlendFuncEnum src_func, BlendFuncEnum dst_func)
      { m_src_func = src_func; m_dst_func = dst_func; setIndex(); }

   void getBlendFunc(BlendFuncEnum &src_func, BlendFuncEnum &dst_func) const
      { src_func = m_src_func; dst_func = m_dst_func; }

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

   // See sglStatelet::getSorted() for details.
   virtual bool getSorted() const { return true; }

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   sglBlending(const sglBlending &); // not implemented
   sglBlending &operator=(const sglBlending &); // not implemented

   void setIndex()
      {
         m_index = ((m_on == false && m_src_func == eSRC_ALPHA &&
                     m_dst_func == eONE_MINUS_SRC_ALPHA) ? 0 : UINT_MAX);
      }

   void printFuncName(ostream &ostrm, BlendFuncEnum func) const;

private:
   BlendFuncEnum m_src_func;
   BlendFuncEnum m_dst_func;
   bool          m_on;
};


//============================================================================

class SGL_DLL_API sglColorMask : public sglStatelet
{
public:
   sglColorMask(bool red = true, bool green = true,
                bool blue = true, bool alpha = true)
      : sglStatelet(eCOLOR_MASK) { setMask(red, green, blue, alpha); }
   virtual ~sglColorMask() {}

   void setMask(bool red, bool green, bool blue, bool alpha);

   void getMask(bool &red, bool &green, bool &blue, bool &alpha) const;

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   sglColorMask(const sglColorMask &); // not implemented
   sglColorMask &operator=(const sglColorMask &); // not implemented

private:
   GLboolean m_red;
   GLboolean m_green;
   GLboolean m_blue;
   GLboolean m_alpha;
};


//============================================================================

class SGL_DLL_API sglCullMode : public sglStatelet
{
public:
   enum CullModeEnum
   {
      eBACK = 0,
      eOFF,
      eFRONT,
      eFRONT_AND_BACK
   };

public:
   sglCullMode(CullModeEnum mode = eBACK)
      : sglStatelet(eCULL_MODE), m_cull_mode(mode) { setIndex(); }

   virtual ~sglCullMode() {}

   void setCullMode(CullModeEnum mode) { m_cull_mode = mode; setIndex(); }

   CullModeEnum getCullMode() const    { return m_cull_mode; }

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   sglCullMode(const sglCullMode &); // not implemented
   sglCullMode &operator=(const sglCullMode &); // not implemented

private:
   void setIndex()
      {
         m_index = m_cull_mode;
      }

private:
   CullModeEnum m_cull_mode;
};


//============================================================================

class SGL_DLL_API sglDepthMask : public sglBooleanStatelet
{
public:
   sglDepthMask(bool on = true)
      : sglBooleanStatelet(eDEPTH_MASK, on) {}

   virtual ~sglDepthMask() {}

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

private:
   sglDepthMask(const sglDepthMask &); // not implemented
   sglDepthMask &operator=(const sglDepthMask &); // not implemented
};


//============================================================================

class SGL_DLL_API sglDepthRange : public sglStatelet
{
public:
   sglDepthRange(double near_val = 0.0, double far_val = 1.0)
         : sglStatelet(eDEPTH_RANGE)
      { setDepthRange(near_val, far_val); }

   virtual ~sglDepthRange() {}

   void setDepthRange(double  near_val, double  far_val);

   void getDepthRange(double &near_val, double &far_val) const
      {
         near_val = m_near;
         far_val  = m_far;
      }

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

   // See sglStatelet::getSorted() for details.
   virtual bool getSorted() const { return true; }

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   sglDepthRange(const sglDepthRange &); // not implemented
   sglDepthRange &operator=(const sglDepthRange &); // not implemented

   void setIndex()
      {
         m_index = ((m_near == 0.0 && m_far == 1.0) ? 0 : UINT_MAX);
      }

private:
   double m_near, m_far;
};


//============================================================================

class SGL_DLL_API sglDepthTest : public sglStatelet
{
public:
   enum DepthFuncEnum
   {
      eLESS     = GL_LESS,
      eALWAYS   = GL_ALWAYS,
      eLEQUAL   = GL_LEQUAL,
      eEQUAL    = GL_EQUAL,
      eGEQUAL   = GL_GEQUAL,
      eGREATER  = GL_GREATER,
      eNOTEQUAL = GL_NOTEQUAL,
      eNEVER    = GL_NEVER
   };

public:
   sglDepthTest(DepthFuncEnum func = eLESS)
         : sglStatelet(eDEPTH_TEST), m_depth_func(func)
      {
         setIndex();
      }

   virtual ~sglDepthTest() {}

   void setDepthFunc(DepthFuncEnum func);

   DepthFuncEnum getDepthFunc() const { return m_depth_func; }

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   sglDepthTest(const sglDepthTest &); // not implemented
   sglDepthTest &operator=(const sglDepthTest &); // not implemented

   void setIndex();

private:
   DepthFuncEnum m_depth_func;
};


//============================================================================

class SGL_DLL_API sglDithering : public sglBooleanStatelet
{
public:
   sglDithering(bool on = true)
      : sglBooleanStatelet(eDITHERING, on) {}

   virtual ~sglDithering() {}

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

private:
   sglDithering(const sglDithering &); // not implemented
   sglDithering &operator=(const sglDithering &); // not implemented
};

//============================================================================

class SGL_DLL_API sglFrontFace : public sglStatelet
{
public:
   enum FrontFaceEnum
   {
      eCCW = GL_CCW,

      eCW = GL_CW
   };

public:
   sglFrontFace(FrontFaceEnum winding = eCCW)
      : sglStatelet(eFRONT_FACE), m_winding(winding) { setIndex(); }

   virtual ~sglFrontFace() {}

   void setFrontFace(FrontFaceEnum winding) { m_winding = winding; setIndex(); }

   FrontFaceEnum getFrontFace() const { return m_winding; }

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   void setIndex() { m_index = ((m_winding == eCCW) ? 0 : 1); }

   sglFrontFace(const sglFrontFace &); // not implemented
   sglFrontFace &operator=(const sglFrontFace &);// not implemented

protected:
   FrontFaceEnum m_winding;
};

//============================================================================

class SGL_DLL_API sglHighlight : public sglBooleanStatelet
{
public:
   sglHighlight(bool on = false)
      : sglBooleanStatelet(eHIGHLIGHT, on) {}

   virtual ~sglHighlight() {}

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

private:
   sglHighlight(const sglHighlight &); // not implemented
   sglHighlight &operator=(const sglHighlight &); // not implemented
};

//============================================================================

class SGL_DLL_API sglLighting : public sglBooleanStatelet
{
public:
   sglLighting(bool on = false)
      : sglBooleanStatelet(eLIGHTING, on) {}

   virtual ~sglLighting() {}

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

private:
   sglLighting(const sglLighting &); // not implemented
   sglLighting &operator=(const sglLighting &); // not implemented
};


//============================================================================

class SGL_DLL_API sglLineStipple : public sglStatelet
{
public:
   sglLineStipple(GLushort pattern = 0xffff, int factor = 1)
      : sglStatelet(eLINE_STIPPLE)
      { setLineStipple(pattern, factor); }

   virtual ~sglLineStipple() {}

   void setLineStipple(GLushort  pattern, int  factor);

   void getLineStipple(GLushort &pattern, int &factor) const
      {
         pattern = m_pattern;
         factor  = m_factor;
      }

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

   // See sglStatelet::getSorted() for details.
   virtual bool getSorted() const { return true; }

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   sglLineStipple(const sglLineStipple &); // not implemented
   sglLineStipple &operator=(const sglLineStipple &); // not implemented

   void setIndex()
      {
         m_index = ((m_pattern == 0xffff) ? 0 : UINT_MAX);
      }

private:
   GLushort m_pattern;
   int      m_factor;
};

//============================================================================

class SGL_DLL_API sglLineWidth : public sglStatelet
{
public:
   sglLineWidth(float line_width = 1.0f)
      : sglStatelet(eLINE_WIDTH)
      { setLineWidth(line_width); }

   virtual ~sglLineWidth() {}

   void setLineWidth(float line_width);

   float getLineWidth() const { return m_line_width; }

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

   // See sglStatelet::getSorted() for details.
   virtual bool getSorted() const { return true; }

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   sglLineWidth(const sglLineWidth &); // not implemented
   sglLineWidth &operator=(const sglLineWidth &); // not implemented

   void setIndex()
      {
         m_index = ((m_line_width == 1.0f) ? 0 : UINT_MAX);
      }

private:
   float m_line_width;
};


//============================================================================

class SGL_DLL_API sglLogicOp : public sglStatelet
{
public:
   enum LogicOpEnum
   {
      eCOPY          = GL_COPY,
      eCLEAR         = GL_CLEAR,
      eSET           = GL_SET,
      eCOPY_INVERTED = GL_COPY_INVERTED,
      eNOOP          = GL_NOOP,
      eINVERT        = GL_INVERT,
      eAND           = GL_AND,
      eNAND          = GL_NAND,
      eOR            = GL_OR,
      eNOR           = GL_NOR,
      eXOR           = GL_XOR,
      eEQUIV         = GL_EQUIV,
      eAND_REVERSE   = GL_AND_REVERSE,
      eAND_INVERTED  = GL_AND_INVERTED,
      eOR_REVERSE    = GL_OR_REVERSE,
      eOR_INVERTED   = GL_OR_INVERTED
   };

public:
   sglLogicOp(LogicOpEnum op = eCOPY)
      : sglStatelet(eLOGIC_OP), m_logic_op(op) { setIndex(); }

   virtual ~sglLogicOp() {}

   void setLogicOp(LogicOpEnum op) { m_logic_op = op; setIndex(); }

   LogicOpEnum getLogicOp() const { return m_logic_op; }

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   void setIndex();

   sglLogicOp(const sglLogicOp &); // not implemented
   sglLogicOp &operator=(const sglLogicOp &);// not implemented

protected:
   LogicOpEnum m_logic_op;
};


//============================================================================

class SGL_DLL_API sglOcclusionCull : public sglStatelet
{
public:
   sglOcclusionCull(bool on = false)
      : sglStatelet(eOCCLUSION_CULL) { enable(on); }

   virtual ~sglOcclusionCull() {}

   void enable(bool on)
      {
         m_on = (on && sgl::s_occlusion_capable);
         setIndex();
      }

   bool isEnabled() const  { return m_on; }

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   sglOcclusionCull(const sglOcclusionCull &); // not implemented
   sglOcclusionCull &operator=(const sglOcclusionCull &); // not implemented

private:
   void setIndex() { m_index = (m_on ? 1 : 0); }

private:
   bool m_on;
};

//============================================================================

class SGL_DLL_API sglPointSize : public sglStatelet
{
public:
   sglPointSize(float point_size = 1.0f)
      : sglStatelet(ePOINT_SIZE)
      { setPointSize(point_size); }

   virtual ~sglPointSize() {}

   void setPointSize(float  point_size);

   float getPointSize() const
      {
         return m_point_size;
      }

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

   // See sglStatelet::getSorted() for details.
   virtual bool getSorted() const { return true; }

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   sglPointSize(const sglPointSize &); // not implemented
   sglPointSize &operator=(const sglPointSize &); // not implemented

   void setIndex()
      {
         m_index = ((m_point_size == 1.0f) ? 0 : UINT_MAX);
      }

private:
   float m_point_size;
};

//============================================================================

class SGL_DLL_API sglPointParameters : public sglStatelet
{
public:
   sglPointParameters(float dist_atten_A = 1.0f,
                      float dist_atten_B = 0.0f,
                      float dist_atten_C = 0.0f,
                      float fade_threshold =
                                       sgl::s_point_default_fade_threshold,
                      float min_size = sgl::s_point_default_size_min,
                      float max_size = sgl::s_point_default_size_max )
         : sglStatelet(ePOINT_PARAMETERS)
      {
         setPointParameters( dist_atten_A, dist_atten_B, dist_atten_C,
                             fade_threshold,
                             min_size, max_size );
      }

   virtual ~sglPointParameters() {}

   void setPointParameters(float dist_atten_A,
                           float dist_atten_B,
                           float dist_atten_C,
                           float fade_threshold =
                                            sgl::s_point_default_fade_threshold,
                           float min_size = sgl::s_point_default_size_min,
                           float max_size = sgl::s_point_default_size_max )
      {
         // HACK do we need to range check any of these?
         m_min_size = min_size;
         m_max_size = max_size;
         m_fade_threshold = fade_threshold;
         m_dist_atten_A = dist_atten_A;
         m_dist_atten_B = dist_atten_B;
         m_dist_atten_C = dist_atten_C;

         setIndex();
      }

   void getPointParameters(float &dist_atten_A,
                           float &dist_atten_B,
                           float &dist_atten_C,
                           float &fade_threshold,
                           float &min_size,
                           float &max_size)
      {
         min_size = m_min_size;
         max_size = m_max_size;
         fade_threshold = m_fade_threshold;
         dist_atten_A = m_dist_atten_A;
         dist_atten_B = m_dist_atten_B;
         dist_atten_C = m_dist_atten_C;
      }

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

   // See sglStatelet::getSorted() for details.
   virtual bool getSorted() const { return true; }

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   sglPointParameters(const sglPointParameters &); // not implemented
   sglPointParameters &operator=(const sglPointParameters &); // not implemented

   void setIndex()
   {
      if (m_dist_atten_A != 1.0f ||
          m_dist_atten_B != 0.0f ||
          m_dist_atten_C != 0.0f ||
          m_fade_threshold != sgl::s_point_default_fade_threshold ||
          m_min_size != sgl::s_point_default_size_min ||
          m_max_size != sgl::s_point_default_size_max )
      {
         m_index = UINT_MAX;
      }
      else
      {
         m_index = 0;
      }
   }

private:
   float m_min_size;
   float m_max_size;
   float m_dist_atten_A;
   float m_dist_atten_B;
   float m_dist_atten_C;
   float m_fade_threshold;
};

//============================================================================

class SGL_DLL_API sglPolyStyle : public sglStatelet
{
public:
   enum StyleEnum
   {
      eFILLED = 0,

      eLINE,

      ePOINT
   };

public:
   void setStyle(StyleEnum style) { m_style = style; setIndex(); }

   StyleEnum getStyle() const { return m_style; }

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

protected:
   sglPolyStyle(StateEnum type, StyleEnum style)
      : sglStatelet(type), m_style(style) { setIndex(); }
   virtual ~sglPolyStyle() {}

private:
   sglPolyStyle(); // not implemented
   sglPolyStyle(const sglPolyStyle &); // not implemented
   sglPolyStyle &operator=(const sglPolyStyle &); // not implemented

   void setIndex() { m_index = m_style; }

protected:
   StyleEnum m_style;
};

//============================================================================

class SGL_DLL_API sglPolyBackStyle : public sglPolyStyle
{
public:
   sglPolyBackStyle(StyleEnum style = eFILLED)
      : sglPolyStyle(ePOLY_BACK_STYLE, style) {}

   virtual ~sglPolyBackStyle() {}

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

private:
   sglPolyBackStyle(const sglPolyBackStyle &); // not implemented
   sglPolyBackStyle &operator=(const sglPolyBackStyle &); // not implemented
};


//============================================================================

class SGL_DLL_API sglPolyFrontStyle : public sglPolyStyle
{
public:
   sglPolyFrontStyle(StyleEnum style = eFILLED)
      : sglPolyStyle(ePOLY_FRONT_STYLE, style) {}

   virtual ~sglPolyFrontStyle() {}

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

private:
   sglPolyFrontStyle(const sglPolyFrontStyle &); // not implemented
   sglPolyFrontStyle &operator=(const sglPolyFrontStyle &); // not implemented
};

//============================================================================

class SGL_DLL_API sglPolygonOffset : public sglStatelet
{
public:
   sglPolygonOffset(float factor = 0, float  units = 0)
      : sglStatelet(ePOLYGON_OFFSET)
      { setPolygonOffset(factor, units); }

   virtual ~sglPolygonOffset() {}

   void setPolygonOffset(float  factor, float  units);

   void getPolygonOffset(float &factor, float &units) const
      {
         factor = m_factor;
         units = m_units;
      }

   bool getPolygonOffsetFlag() const { return m_polygon_offset_flag; }

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

   // See sglStatelet::getSorted() for details.
   virtual bool getSorted() const { return true; }

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   sglPolygonOffset(const sglPolygonOffset &); // not implemented
   sglPolygonOffset &operator=(const sglPolygonOffset &); // not implemented

   void setIndex()
      {
         m_index = (m_polygon_offset_flag ? UINT_MAX : 0);
      }

private:
   bool  m_polygon_offset_flag;
   float m_factor;
   float m_units;
};


//============================================================================

class SGL_DLL_API sglPolygonStipple : public sglStatelet
{
public:
   sglPolygonStipple(const GLubyte *pattern = NULL) //assuming 128 bytes packed
         : sglStatelet(ePOLYGON_STIPPLE)
      { setPolygonStipple(pattern); }

   virtual ~sglPolygonStipple() {}

   void setPolygonStipple(const GLubyte *pattern);

   const GLubyte *getPolygonStipple() const
      {
         if (m_polygon_stipple_flag)
            return m_pattern;
         else
            return NULL;
      }

   bool getPolygonStippleFlag() const { return m_polygon_stipple_flag; }

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

   // See sglStatelet::getSorted() for details.
   virtual bool getSorted() const { return true; }

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   sglPolygonStipple(const sglPolygonStipple &); // not implemented
   sglPolygonStipple &operator=(const sglPolygonStipple &); // not implemented

   void setIndex()
      {
         m_index = (m_polygon_stipple_flag ? UINT_MAX : 0);
      }

private:
   bool    m_polygon_stipple_flag;
   GLubyte m_pattern[128];
};


//============================================================================

class SGL_DLL_API sglShadeModel : public sglStatelet
{
public:
   enum ShadeModelEnum
   {
      eFLAT = GL_FLAT,

      eSMOOTH = GL_SMOOTH
   };

public:
   sglShadeModel(ShadeModelEnum model = eSMOOTH)
         : sglStatelet(eSHADE_MODEL), m_model(model) { setIndex(); }

   virtual ~sglShadeModel() {}

   void setShadeModel(ShadeModelEnum model) { m_model = model; setIndex(); }

   ShadeModelEnum getShadeModel() const { return m_model; }

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   void setIndex() { m_index = ((m_model == eFLAT) ? 1 : 0); }

   sglShadeModel(const sglShadeModel &); // not implemented
   sglShadeModel &operator=(const sglShadeModel &);// not implemented

protected:
   ShadeModelEnum m_model;
};

//============================================================================

class SGL_DLL_API sglTexturingStatelet : public sglStatelet
{
public:
   sglTexturingStatelet(StateEnum type) : sglStatelet(type) {}

   virtual ~sglTexturingStatelet() {}

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const { applyToUnit(curr_state, 0); }

   virtual void applyToUnit(sglCurrState *curr_state,
                            unsigned int unit) const = 0;
};

//============================================================================

class SGL_DLL_API sglMultiTextureStatelet : public sglStatelet
{
public:
   sglMultiTextureStatelet(sglTexturingStatelet *statelet,
                           unsigned int unit = 0)
         : sglStatelet(eNUM_BASIC_STATES),
           m_statelet(NULL),
           m_texture_unit(unit)
      { setStatelet(statelet); }

   virtual ~sglMultiTextureStatelet();

   void setTextureUnit(unsigned int unit) { m_texture_unit = unit; }

   unsigned int getTextureUnit() const { return m_texture_unit; }

   void setStatelet(sglTexturingStatelet *statelet);

   sglTexturingStatelet* getStatelet() const { return m_statelet; }

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

   // See sglStatelet::getSorted() for details.
   virtual bool getSorted() const { return m_statelet->getSorted(); }

protected:
   // See sglStatelet::getType() for details.
   unsigned int getType() const;

private: // not implemented
   sglMultiTextureStatelet();
   sglMultiTextureStatelet(const sglMultiTextureStatelet &);
   sglMultiTextureStatelet &operator=(const sglMultiTextureStatelet &);

private:
   sglTexturingStatelet *m_statelet;
   unsigned int          m_texture_unit;
};

//============================================================================

class SGL_DLL_API sglTextureMatrix : public sglTexturingStatelet
{
public:
   sglTextureMatrix(sglMat4f *tmat = NULL)
      : sglTexturingStatelet(eTEXTURE_MATRIX) { setTextureMatrix(tmat); }

   virtual ~sglTextureMatrix() {}

   void setTextureMatrix(sglMat4f *tmat);

   const sglMat4f &getTextureMatrix() const { return m_texture_matrix; }

   // See sglTexturingStatelet::applyToUnit() for details.
   void applyToUnit(sglCurrState*, unsigned int) const;

   // See sglStatelet::getSorted() for details.
   virtual bool getSorted() const { return true; }

   // See sglObject::printInfo() for details.
   virtual void printInfo(ostream &ostrm, const char *indent_string) const;

private:
   sglTextureMatrix(const sglTextureMatrix &); // not implemented
   sglTextureMatrix &operator=(const sglTextureMatrix &); // not implemented

   void setIndex()
      {
         m_index = (m_texture_matrix_flag ? UINT_MAX : 0);
      }

private:
   bool m_texture_matrix_flag;
   sglMat4f m_texture_matrix;
};


//============================================================================

class SGL_DLL_API sglTransparency : public sglBooleanStatelet
{
public:
   sglTransparency(bool on = false)
      : sglBooleanStatelet(eTRANSPARENCY, on) {}

   virtual ~sglTransparency() {}

   // See sglStatelet::apply() for details.
   void apply(sglCurrState *curr_state) const;

private:
   sglTransparency(const sglTransparency &); // not implemented
   sglTransparency &operator=(const sglTransparency &); // not implemented
};

#endif

---