nux-0.9.48

NuxGraphics/GLRenderStates.h

Go to the documentation of this file.
00001 /*
00002  * Copyright 2010 Inalogic® Inc.
00003  *
00004  * This program is free software: you can redistribute it and/or modify it
00005  * under the terms of the GNU Lesser General Public License, as
00006  * published by the  Free Software Foundation; either version 2.1 or 3.0
00007  * of the License.
00008  *
00009  * This program is distributed in the hope that it will be useful, but
00010  * WITHOUT ANY WARRANTY; without even the implied warranties of
00011  * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
00012  * PURPOSE.  See the applicable version of the GNU Lesser General Public
00013  * License for more details.
00014  *
00015  * You should have received a copy of both the GNU Lesser General Public
00016  * License along with this program. If not, see <http://www.gnu.org/licenses/>
00017  *
00018  * Authored by: Jay Taoko <jaytaoko@inalogic.com>
00019  *
00020  */
00021 
00022 
00023 #ifndef GLRENDERSTATES_H
00024 #define GLRENDERSTATES_H
00025 
00026 #include "NuxCore/NuxCore.h"
00027 #include "GpuDevice.h"
00028 
00029 namespace nux
00030 {
00031 
00032   enum
00033   {
00034     GFXRS_FRONT_POLYGONMODE,                                    // GL_FILL
00035     GFXRS_BACK_POLYGONMODE,                                     // GL_FILL
00036     GFXRS_CULLFACEENABLE,                                       // GL_FALSE
00037     GFXRS_CULLFACE,                                             // GL_BACK
00038     GFXRS_FRONTFACE,                                            // GL_CCW
00039 
00040     GFXRS_SCISSORTESTENABLE,                                    // GL_FALSE
00041     GFXRS_FOGENABLE,                                            // GL_FALSE
00042 
00043     GFXRS_ZTESTENABLE,                                          // GL_TRUE
00044     GFXRS_ZWRITEENABLE,                                         // GL_TRUE
00045     GFXRS_ZFUNC,                                                // GL_LESS
00046     GFXRS_ZNEAR,                                                // 0.0f
00047     GFXRS_ZFAR,                                                 // 1.0f
00048 
00049     GFXRS_ALPHABLENDENABLE,                                     // GL_FALSE
00050     GFXRS_BLENDOP,                                              // GL_FUNC_ADD
00051     GFXRS_BLENDOPALPHA,                                         // GL_FUNC_ADD
00052     GFXRS_SRCBLEND,                                             // GL_ONE
00053     GFXRS_DESTBLEND,                                            // GL_ZERO
00054     GFXRS_SRCBLENDALPHA,                                        // GL_ONE
00055     GFXRS_DESTBLENDALPHA,                                       // GL_ZERO
00056 
00057     GFXRS_ALPHATESTENABLE,                                      // GL_FALSE
00058     GFXRS_ALPHATESTREF,                                         // 0x0
00059     GFXRS_ALPHATESTFUNC,                                        // GL_ALWAYS
00060 
00061     GFXRS_STENCILENABLE,                                        // GL_FALSE
00062     GFXRS_TWOSIDEDSTENCILENABLE,                                // GL_FALSE
00063     GFXRS_FRONT_STENCILWRITEMASK,                               // 0xFFFFFFFF
00064     GFXRS_BACK_STENCILWRITEMASK,                                // 0xFFFFFFFF
00065 
00066     GFXRS_FRONT_STENCILFUNC,                                    // GL_ALWAYS
00067     GFXRS_FRONT_STENCILREF,                                     // 0x0
00068     GFXRS_FRONT_STENCILMASK,                                    // 0xFF
00069     GFXRS_FRONT_STENCILFAIL,                                    // GL_KEEP
00070     GFXRS_FRONT_STENCILZFAIL,                                   // GL_KEEP
00071     GFXRS_FRONT_STENCILZPASS,                                   // GL_KEEP
00072 
00073     GFXRS_BACK_STENCILFUNC,                                     // GL_ALWAYS
00074     GFXRS_BACK_STENCILREF,                                      // 0x0
00075     GFXRS_BACK_STENCILMASK,                                     // 0xFF
00076     GFXRS_BACK_STENCILFAIL,                                     // GL_KEEP
00077     GFXRS_BACK_STENCILZFAIL,                                    // GL_KEEP
00078     GFXRS_BACK_STENCILZPASS,                                    // GL_KEEP
00079 
00080 
00081     GFXRS_POINTSMOOTHENABLE,                                    // GL_FLASE
00082     GFXRS_LINESMOOTHENABLE,                                     // GL_FALSE
00083     GFXRS_POINTSIZE,                                            // 1.0f
00084     GFXRS_LINEWIDTH,                                            // 1.0f
00085     GFXRS_POINTHINT,                                            // GL_FASTEST
00086     GFXRS_LINEHINT,                                             // GL_FASTEST
00087 
00088     GFXRS_COLORWRITEENABLE_R,                                   // TRUE or FALSE
00089     GFXRS_COLORWRITEENABLE_G,                                   // TRUE or FALSE
00090     GFXRS_COLORWRITEENABLE_B,                                   // TRUE or FALSE
00091     GFXRS_COLORWRITEENABLE_A,                                   // TRUE or FALSE
00092 
00093     GFXRS_POLYGONOFFSETENABLE,                                  // GL_FALSE
00094     GFXRS_POLYGONOFFSETFACTOR,                                  // 0.0f
00095     GFXRS_POLYGONOFFSETUNITS,                                   // 0.0f
00096 
00097     GFXRS_MAX_RENDERSTATES,
00098   };
00099 
00100   enum
00101   {
00102     GFXSS_ADDRESSU,
00103     GFXSS_ADDRESSV,
00104     GFXSS_ADDRESSW,
00105     GFXSS_MINFILTER,
00106     GFXSS_MAGFILTER,
00107     GFXSS_MIPMAPFILTER,
00108     GFXSS_MIPMAPLODBIAS,
00109     GFXSS_MAXANISOTROPY,
00110     GFXSS_SRGBWRITEENABLE,
00111 
00112     GFXSS_MAX_SAMPLERSTATES,
00113   };
00114 
00115   typedef enum
00116   {
00117     CLEAR = 0,
00118     SRC,
00119     DST,
00120     SRC_OVER,
00121     DST_OVER,
00122     SRC_IN,
00123     DST_IN,
00124     SRC_OUT,
00125     DST_OUT,
00126     SRC_ATOP,
00127     DST_ATOP,
00128     XOR,
00129     PLUS
00130   } PorterDuffOperator;
00131 
00132   struct RenderStateMap
00133   {
00134     t_u32   Checked;
00135     t_u32    State;
00136     t_u32    iValue;
00137     float   fValue;
00138   };
00139 
00140   class GpuRenderStates
00141   {
00142   public:
00143     GpuRenderStates (GpuBrand board, GpuInfo* info);
00144     ~GpuRenderStates();
00145 
00146     void ResetDefault();
00147     void ResetStateChangeToDefault();
00148     void CommitStateChangeToDefault();
00149     void CheckStateChange();
00150 
00151     void SubmitChangeStates();
00153     void CheckRenderStatesConformity();
00154 
00155 
00156     void SetRenderStates (t_u32 rs, t_u32 value);
00157 
00158     // Render states
00159     inline void SetAlphaTest (
00160       bool EnableAlphaTest_,
00161       t_u32 AlphaTestFunc_    = GL_ALWAYS,
00162       BYTE  AlphaTestRef_     = 0);
00163 
00164     inline void SetBlend (bool AlphaBlendEnable_);
00165     inline void SetBlend (bool AlphaBlendEnable_,
00166                           t_u32 SrcBlendFactor_   /*= GL_ONE*/,
00167                           t_u32 DestBlendFactor_  /*= GL_ZERO*/);
00168 
00169     inline void GetBlend (t_u32& AlphaBlendEnable_,
00170                       t_u32& SrcBlendFactor_,
00171                       t_u32& DestBlendFactor_);
00172     
00173     inline void SetSeparateBlend (bool _bEnable,
00174                                   t_u32 SrcBlendFactor_   /*= GL_ONE*/,
00175                                   t_u32 DestBlendFactor_  /*= GL_ZERO*/,
00176                                   t_u32 SrcFactorAlpha_   /*= GL_ONE*/,
00177                                   t_u32 DestFactorAlpha_  /*= GL_ZERO*/);
00178 
00179     inline void SetPremultipliedBlend (PorterDuffOperator op);
00180 
00181     inline void SetBlendOp (
00182       t_u32 BlendOp       = GL_FUNC_ADD);
00183 
00184     inline void SetSeparateBlendOp (
00185       t_u32 BlendOpRGB_       = GL_FUNC_ADD,
00186       t_u32 BlendOpAlpha_     = GL_FUNC_ADD);
00187 
00188     inline void SetCullMode (bool EnableCullFace,
00189                              t_u32 FrontFace_        = GL_CCW,
00190                              t_u32 Cullface_         = GL_BACK);
00191 
00192     inline void SetDepthTest (bool EnableDepthTest,
00193                               t_u32 WriteEnable_      = GL_TRUE,
00194                               t_u32 DepthFunc_        = GL_LEQUAL);
00195 
00196     inline void SetDepthRange (
00197       float zNear = 0.0f,
00198       float zFar = 1.0f);
00199 
00200 
00201     inline void SetStencil (bool enable_stencil);
00202     inline void SetStencilFunc (t_u32 func, int ref, t_u32 mask);
00203     inline void SetStencilOp (t_u32 stencil_fail, t_u32 stencil_pass_depth_fail, t_u32 stencil_pass_depth_pass);
00204 
00205 #if 0
00206     // If two sided stencil is not activated, the setting is also used for the back face.
00207     inline void SetStencilFrontFace (
00208       bool EnableStencil_,                            // GL_TRUE enable stencil test
00209       t_u32 Func_             = GL_ALWAYS,
00210       t_u32 FailOp_           = GL_KEEP,
00211       t_u32 ZFailOp_          = GL_KEEP,
00212       t_u32 ZPassOp_          = GL_KEEP,
00213       t_u32 Ref_              = 0,
00214       t_u32 Mask_             = 0xffffffff);
00215 
00216     // Set stencil test for the back face.
00217     inline void SetStencilBackFace (
00218       bool EnableTwoSideStencil_,                     // GL_TRUE enable Two Sided Stencil test
00219       t_u32 Func_             = GL_ALWAYS,
00220       t_u32 FailOp_           = GL_KEEP,
00221       t_u32 ZFailOp_          = GL_KEEP,
00222       t_u32 ZPassOp_          = GL_KEEP,
00223       t_u32 Ref_              = 0,
00224       t_u32 Mask_             = 0xffffffff);
00225 
00226     inline void SetFrontFaceStencilWriteMask (
00227       t_u32 WriteMask_        = 0xffffffff);
00228 
00229     inline void SetBackFaceStencilWriteMask (
00230       t_u32 WriteMask_        = 0xffffffff);
00231 #endif
00232 
00233     inline void EnableLineSmooth (
00234       bool EnableLineSmooth = TRUE,
00235       t_u32  LineWidth = 1,
00236       t_u32 HINT = GL_FASTEST);
00237 
00238     inline void EnablePointSmooth (
00239       bool EnablePointSmooth = TRUE,
00240       t_u32  PointSize = 1,
00241       t_u32 HINT = GL_FASTEST);
00242 
00243     inline void SetColorMask (
00244       t_u32 bRed      = TRUE,
00245       t_u32 bGreen    = TRUE,
00246       t_u32 bBlue     = TRUE,
00247       t_u32 bAlpha    = TRUE);
00248 
00249     inline void GetColorMask (
00250       t_u32& bRed,
00251       t_u32& bGreen,
00252       t_u32& bBlue,
00253       t_u32& bAlpha);
00254     
00255     inline void SetDepthMask (t_u32 bDepth = TRUE);
00256 
00257     inline void EnableScissor (t_u32 bScissor = FALSE);
00258     inline void EnableFog (t_u32 bFog = FALSE);
00259     inline void SetPolygonMode (t_u32 FrontMode = GL_FILL, t_u32 BackMode = GL_FILL);
00260 
00261     inline void SetPolygonOffset (t_u32 bEnable,
00262                                   float Factor = 0.0f, float Units = 0.0f);
00263 
00264   private:
00265 
00266     GpuBrand _gpu_brand;
00267     GpuInfo *_gpu_info;
00268 
00269     inline void HW__EnableAlphaTest (t_u32 b);
00270 
00271     inline void HW__SetAlphaTestFunc (
00272       t_u32 AlphaTestFunc_,
00273       BYTE  AlphaTestRef_);
00274 
00275     inline void HW__EnableAlphaBlend (t_u32 b);
00276 
00277     inline void HW__SetSeparateAlphaBlend_Enable (t_u32 b);
00278 
00279     inline void HW__SetSeparateAlphaBlendFactors (
00280       t_u32 SrcBlendFactor_,
00281       t_u32 DestBlendFactor_,
00282       t_u32 SrcFactorAlpha_,
00283       t_u32 DestFactorAlpha_);
00284 
00285     inline void HW__SetAlphaBlendOp (t_u32 BlendOpRGB_,
00286                                      t_u32 BlendOpAlpha_);
00287 
00288     inline void HW__EnableCulling (t_u32 b);
00289 
00290     inline void HW__SetFrontFace (t_u32 FrontFace_);
00291 
00292     inline void HW__SetCullFace (t_u32 CullFace_);
00293 
00294     inline void HW__SetEnableDepthTest (t_u32 b);
00295     inline void HW__SetDepthFunc (t_u32 Func);
00296     inline void HW__SetDepthRange (float zNear, float zFar);
00297 
00298 
00299     inline void HW__EnableStencil (t_u32 b);
00300     inline void HW__SetStencilOp (t_u32 FailOp_, t_u32 ZFailOp_, t_u32 ZPassOp_);
00301     inline void HW__SetStencilFunc (t_u32 func, int ref, t_u32 mask);
00302 
00303 #if 0
00304     inline void HW__EnableTwoSidedStencil (t_u32 b);
00305     inline void HW__SetStencilFrontFaceWriteMask (t_u32 WriteMask_);
00306     inline void HW__SetStencilBackFaceWriteMask (t_u32 WriteMask_);
00307 
00308     inline void HW__SetFrontFaceStencilFunc (t_u32 Func_,
00309         t_u32 Ref_,
00310         t_u32 Mask_);
00311 
00312     inline void HW__SetBackFaceStencilFunc (
00313       t_u32 Func_,
00314       t_u32 Ref_,
00315       t_u32 Mask_);
00316 
00317     inline void HW__SetFrontFaceStencilOp (
00318       t_u32 FailOp_,
00319       t_u32 ZFailOp_,
00320       t_u32 ZPassOp_);
00321 
00322     inline void HW__SetBackFaceStencilOp (
00323       t_u32 FailOp_,
00324       t_u32 ZFailOp_,
00325       t_u32 ZPassOp_);
00326 #endif
00327 
00328     inline void HW__EnableLineSmooth (t_u32 EnableLineSmooth);
00329     inline void HW__SetLineWidth (t_u32 width, t_u32 HINT);
00330 
00331     inline void HW__EnablePointSmooth (t_u32 EnablePointSmooth);
00332     inline void HW__SetPointSize (t_u32 size, t_u32 HINT);
00333 
00334     inline void HW__SetColorMask (t_u32 bRed, t_u32 bGreen, t_u32 bBlue, t_u32 bAlpha);
00335     inline void HW__SetDepthMask (t_u32 bDepth);
00336 
00337     inline void HW__EnableScissor (t_u32 bScissor);
00338     inline void HW__EnableFog (t_u32 bFog);
00339 
00340     inline void HW__SetPolygonMode (t_u32 FrontMode, t_u32 BackMode);
00341     inline void HW__EnablePolygonOffset (t_u32 EnablePolygonOffset);
00342     inline void HW__SetPolygonOffset (float Factor, float Units);
00343 
00344   private:
00345     RenderStateMap *m_RenderStateChangeList;
00346     RenderStateMap *m_SamplerStateChangeList;
00347     RenderStateMap m_RenderStateChanges[GFXRS_MAX_RENDERSTATES];
00348     RenderStateMap m_SamplerStateChanges[4][GFXSS_MAX_SAMPLERSTATES];
00349 
00350   };
00351 
00352 
00353 
00354 #define SET_RS_VALUE(a, b)  (a).iValue = (b)
00355 #define RS_VALUE(a)      (a).iValue
00356 
00357 //#define SET_RS_VALUE_FLOAT(a, b)  (a).fValue = (b)
00358 //#define RS_VALUE_FLOAT(a, b)      (a).fValue
00359 
00360 
00361   inline void GpuRenderStates::SetAlphaTest (
00362     bool EnableAlphaTest_,
00363     t_u32 AlphaTestFunc_,
00364     BYTE AlphaTestRef_)
00365   {
00366     if (EnableAlphaTest_)
00367     {
00368       if (!RS_VALUE (m_RenderStateChanges[GFXRS_ALPHATESTENABLE]) )
00369       {
00370         HW__EnableAlphaTest (TRUE);
00371       }
00372 
00373       if ( (RS_VALUE (m_RenderStateChanges[GFXRS_ALPHATESTFUNC]) != AlphaTestFunc_) ||
00374            (RS_VALUE (m_RenderStateChanges[GFXRS_ALPHATESTREF]) != AlphaTestRef_) )
00375       {
00376         HW__SetAlphaTestFunc (AlphaTestFunc_, AlphaTestRef_);
00377       }
00378     }
00379     else
00380     {
00381       HW__EnableAlphaTest (GL_FALSE);
00382       HW__SetAlphaTestFunc (AlphaTestFunc_, AlphaTestRef_);
00383     }
00384   }
00385 
00386   inline void GpuRenderStates::SetBlend (bool AlphaBlendEnable_)
00387   {
00388     if (AlphaBlendEnable_)
00389     {
00390       if (!RS_VALUE (m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]) )
00391       {
00392         HW__EnableAlphaBlend (TRUE);
00393       }
00394     }
00395     else
00396     {
00397       if (RS_VALUE (m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]) )
00398       {
00399         HW__EnableAlphaBlend (GL_FALSE);
00400       }
00401     }
00402   }
00403 
00404   inline void GpuRenderStates::SetBlend (bool AlphaBlendEnable_,
00405                                         t_u32 SrcBlendFactor_,
00406                                         t_u32 DestBlendFactor_)
00407   {
00408     SetBlend (AlphaBlendEnable_);
00409 
00410     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_SRCBLEND]) != SrcBlendFactor_) ||
00411          (RS_VALUE (m_RenderStateChanges[GFXRS_DESTBLEND]) != DestBlendFactor_) )
00412     {
00413       HW__SetSeparateAlphaBlendFactors (
00414         SrcBlendFactor_,
00415         DestBlendFactor_,
00416         SrcBlendFactor_,
00417         DestBlendFactor_);
00418     }
00419   }
00420 
00421   inline void GpuRenderStates::GetBlend (t_u32& AlphaBlendEnable_,
00422                     t_u32& SrcBlendFactor_,
00423                     t_u32& DestBlendFactor_)
00424   {
00425     AlphaBlendEnable_ = RS_VALUE (m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]);
00426     SrcBlendFactor_   = RS_VALUE (m_RenderStateChanges[GFXRS_SRCBLEND]);
00427     DestBlendFactor_  = RS_VALUE (m_RenderStateChanges[GFXRS_DESTBLEND]);
00428   }
00429     
00430   inline void GpuRenderStates::SetSeparateBlend (bool EnableSeparateAlphaBlend,
00431       t_u32 SrcBlendFactor_,
00432       t_u32 DestBlendFactor_,
00433       t_u32 SrcBlendFactorAlpha_,
00434       t_u32 DestBlendFactorAlpha_)
00435   {
00436     SetBlend (EnableSeparateAlphaBlend);
00437 
00438 //     if(EnableSeparateAlphaBlend)
00439 //     {
00440 //         if(!RS_VALUE(m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]))
00441 //         {
00442 //             HW__EnableAlphaBlend(TRUE);
00443 //         }
00444 
00445     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_SRCBLEND]) != SrcBlendFactor_) ||
00446          (RS_VALUE (m_RenderStateChanges[GFXRS_DESTBLEND]) != DestBlendFactor_) ||
00447          (RS_VALUE (m_RenderStateChanges[GFXRS_SRCBLENDALPHA]) != SrcBlendFactorAlpha_) ||
00448          (RS_VALUE (m_RenderStateChanges[GFXRS_DESTBLENDALPHA]) != DestBlendFactorAlpha_) )
00449     {
00450       HW__SetSeparateAlphaBlendFactors (
00451         SrcBlendFactor_,
00452         DestBlendFactor_,
00453         SrcBlendFactorAlpha_,
00454         DestBlendFactorAlpha_);
00455     }
00456 
00457 //     }
00458 //     else
00459 //     {
00460 //         HW__EnableAlphaBlend(GL_FALSE);
00461 //         HW__SetSeparateAlphaBlendFactors(
00462 //             SrcBlendFactor_,
00463 //             DestBlendFactor_,
00464 //             SrcBlendFactorAlpha_,
00465 //             DestBlendFactorAlpha_);
00466 //     }
00467   }
00468 
00469   inline void GpuRenderStates::SetPremultipliedBlend (PorterDuffOperator op)
00470   {
00471     static const struct
00472     {
00473       const t_u32 src_blend;
00474       const t_u32 dst_blend;
00475     } factor[13] =
00476     {
00477       { GL_ZERO,                GL_ZERO                }, // CLEAR
00478       { GL_ONE,                 GL_ZERO                }, // SRC
00479       { GL_ZERO,                GL_ONE                 }, // DST
00480       { GL_ONE,                 GL_ONE_MINUS_SRC_ALPHA }, // SRC_OVER
00481       { GL_ONE_MINUS_DST_ALPHA, GL_ONE                 }, // DST_OVER
00482       { GL_DST_ALPHA,           GL_ZERO                }, // SRC_IN
00483       { GL_ZERO,                GL_SRC_ALPHA           }, // DST_IN
00484       { GL_ONE_MINUS_DST_ALPHA, GL_ZERO                }, // SRC_OUT
00485       { GL_ZERO,                GL_ONE_MINUS_SRC_ALPHA }, // DST_OUT
00486       { GL_DST_ALPHA,           GL_ONE_MINUS_SRC_ALPHA }, // SRC_ATOP
00487       { GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA           }, // DST_ATOP
00488       { GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA }, // XOR
00489       { GL_ONE,                 GL_ONE                 }  // PLUS
00490     };
00491 
00492     if ((RS_VALUE (m_RenderStateChanges[GFXRS_SRCBLEND]) !=
00493          factor[op].src_blend) ||
00494         (RS_VALUE (m_RenderStateChanges[GFXRS_DESTBLEND]) !=
00495          factor[op].dst_blend))
00496     {
00497       HW__SetSeparateAlphaBlendFactors
00498         (factor[op].src_blend, factor[op].dst_blend,
00499          factor[op].src_blend, factor[op].dst_blend);
00500     }
00501   }
00502 
00503   inline void GpuRenderStates::SetBlendOp (t_u32 BlendOp)
00504   {
00505     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_BLENDOP]) != BlendOp) )
00506     {
00507       HW__SetAlphaBlendOp (BlendOp, BlendOp);
00508     }
00509   }
00510 
00511   inline void GpuRenderStates::SetSeparateBlendOp (
00512     t_u32 BlendOpRGB_,
00513     t_u32 BlendOpAlpha_)
00514   {
00515     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_BLENDOP]) != BlendOpRGB_) ||
00516          (RS_VALUE (m_RenderStateChanges[GFXRS_BLENDOPALPHA]) != BlendOpAlpha_) )
00517     {
00518       HW__SetAlphaBlendOp (BlendOpRGB_, BlendOpAlpha_);
00519     }
00520   }
00521 
00522   inline void GpuRenderStates::SetCullMode (bool EnableCullFace,
00523       t_u32 FrontFace_,
00524       t_u32 Cullface_)
00525   {
00526     if (EnableCullFace)
00527     {
00528       if (!RS_VALUE (m_RenderStateChanges[GFXRS_CULLFACEENABLE]) )
00529       {
00530         HW__EnableCulling (TRUE);
00531       }
00532 
00533       if (RS_VALUE (m_RenderStateChanges[GFXRS_FRONTFACE]) != FrontFace_)
00534       {
00535         HW__SetFrontFace (FrontFace_);
00536       }
00537 
00538       if (RS_VALUE (m_RenderStateChanges[GFXRS_CULLFACE]) != Cullface_)
00539       {
00540         HW__SetCullFace (Cullface_);
00541       }
00542     }
00543     else
00544     {
00545       HW__EnableCulling (FALSE);
00546       HW__SetFrontFace (FrontFace_);
00547       HW__SetCullFace (Cullface_);
00548     }
00549   }
00550 
00551   inline void GpuRenderStates::SetDepthTest (bool EnableDepthTest,
00552       t_u32 WriteEnable_,
00553       t_u32 DepthFunc_)
00554   {
00555     if (EnableDepthTest)
00556     {
00557       if (!RS_VALUE (m_RenderStateChanges[GFXRS_ZTESTENABLE]) )
00558       {
00559         HW__SetEnableDepthTest (TRUE);
00560       }
00561 
00562       if (RS_VALUE (m_RenderStateChanges[GFXRS_ZWRITEENABLE]) != WriteEnable_)
00563       {
00564         HW__SetDepthMask (WriteEnable_);
00565       }
00566 
00567       if (RS_VALUE (m_RenderStateChanges[GFXRS_ZFUNC]) != DepthFunc_)
00568       {
00569         HW__SetDepthFunc (DepthFunc_);
00570       }
00571     }
00572     else
00573     {
00574       HW__SetEnableDepthTest (FALSE);
00575       HW__SetDepthMask (WriteEnable_);
00576       HW__SetDepthFunc (DepthFunc_);
00577     }
00578   }
00579 
00580   inline void GpuRenderStates::SetDepthRange (float zNear, float zFar)
00581   {
00582     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_ZNEAR]) != static_cast<t_u32> (zNear) ) ||
00583          (RS_VALUE (m_RenderStateChanges[GFXRS_ZFAR]) != static_cast<t_u32> (zFar) ) )
00584     {
00585       HW__SetDepthRange (zNear, zFar);
00586     }
00587   }
00588 
00589   void GpuRenderStates::SetStencil (bool enable_stencil)
00590   {
00591     if (enable_stencil)
00592     {
00593       if (!RS_VALUE (m_RenderStateChanges[GFXRS_STENCILENABLE]))
00594       {
00595         HW__EnableStencil (TRUE);
00596       }
00597     }
00598     else
00599     {
00600       HW__EnableStencil (FALSE);
00601     }
00602   }
00603 
00604   void GpuRenderStates::SetStencilFunc (t_u32 func, int ref, t_u32 mask)
00605   {
00606     if (
00607       (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC]) != func) ||
00608       (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILREF]) != (t_u32)ref) ||
00609       (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILMASK]) != mask)
00610       )
00611     {
00612       HW__SetStencilFunc (func, ref, mask);
00613     }
00614   }
00615 
00616   void GpuRenderStates::SetStencilOp (t_u32 stencil_fail, t_u32 stencil_pass_depth_fail, t_u32 stencil_pass_depth_pass)
00617   {
00618     if (
00619       (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL]) != stencil_fail) ||
00620       (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL]) != stencil_pass_depth_fail) ||
00621       (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS]) != stencil_pass_depth_pass)
00622       )
00623     {
00624       HW__SetStencilOp (stencil_fail, stencil_pass_depth_fail, stencil_pass_depth_pass);
00625     }
00626   }
00627 
00628 #if 0
00629   inline void GpuRenderStates::SetStencilFrontFace (
00630     bool EnableStencil_,                            // GL_TRUE enable stencil test
00631     t_u32 Func_,
00632     t_u32 FailOp_,
00633     t_u32 ZFailOp_,
00634     t_u32 ZPassOp_,
00635     t_u32 Ref_,
00636     t_u32 Mask_)
00637   {
00638     if (EnableStencil_)
00639     {
00640       if (!RS_VALUE (m_RenderStateChanges[GFXRS_STENCILENABLE]) )
00641       {
00642         HW__EnableStencil (TRUE);
00643       }
00644 
00645       if (
00646         (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC]) != Func_) ||
00647         (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILREF]) != Ref_) ||
00648         (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILMASK]) != Mask_) ||
00649         (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL]) != FailOp_) ||
00650         (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL]) != ZFailOp_) ||
00651         (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS]) != ZPassOp_)
00652       )
00653       {
00654         HW__SetFrontFaceStencilFunc (Func_, Ref_, Mask_);
00655         HW__SetFrontFaceStencilOp (FailOp_, ZFailOp_, ZPassOp_);
00656       }
00657     }
00658     else
00659     {
00660       HW__EnableStencil (FALSE);
00661       HW__SetFrontFaceStencilFunc (Func_, Ref_, Mask_);
00662       HW__SetFrontFaceStencilOp (FailOp_, ZFailOp_, ZPassOp_);
00663     }
00664   }
00665 
00666   inline void GpuRenderStates::SetStencilBackFace (
00667     bool EnableTwoSideStencil_,                     // GL_TRUE enable Two Sided Stencil test
00668     t_u32 Func_,
00669     t_u32 FailOp_,
00670     t_u32 ZFailOp_,
00671     t_u32 ZPassOp_,
00672     t_u32 Ref_,
00673     t_u32 Mask_)
00674   {
00675     if (EnableTwoSideStencil_)
00676     {
00677       if (!RS_VALUE (m_RenderStateChanges[GFXRS_STENCILENABLE]) )
00678       {
00679         HW__EnableStencil (TRUE);
00680       }
00681 
00682       if (!RS_VALUE (m_RenderStateChanges[GFXRS_TWOSIDEDSTENCILENABLE]) )
00683       {
00684         HW__EnableTwoSidedStencil (TRUE);
00685       }
00686 
00687       if (
00688         (RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILFUNC]) != Func_) ||
00689         (RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILREF]) != Ref_) ||
00690         (RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILMASK]) != Mask_) ||
00691         (RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILFAIL]) != FailOp_) ||
00692         (RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILZFAIL]) != ZFailOp_) ||
00693         (RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILZPASS]) != ZPassOp_)
00694       )
00695       {
00696         HW__SetBackFaceStencilFunc (Func_, Ref_, Mask_);
00697         HW__SetBackFaceStencilOp (FailOp_, ZFailOp_, ZPassOp_);
00698       }
00699     }
00700     else
00701     {
00702       HW__EnableTwoSidedStencil (FALSE);
00703       HW__SetBackFaceStencilFunc (Func_, Ref_, Mask_);
00704       HW__SetBackFaceStencilOp (FailOp_, ZFailOp_, ZPassOp_);
00705     }
00706   }
00707 
00708   inline void GpuRenderStates::SetFrontFaceStencilWriteMask (
00709     t_u32 WriteMask_)
00710   {
00711     HW__SetStencilFrontFaceWriteMask (WriteMask_);
00712   }
00713 
00714   inline void GpuRenderStates::SetBackFaceStencilWriteMask (
00715     t_u32 WriteMask_)
00716   {
00717     HW__SetStencilBackFaceWriteMask (WriteMask_);
00718   }
00719 #endif
00720 
00721   inline void GpuRenderStates::EnableLineSmooth (
00722     bool EnableLineSmooth,
00723     t_u32  LineWidth,
00724     t_u32 Hint)
00725   {
00726     if (EnableLineSmooth)
00727     {
00728       if (!RS_VALUE (m_RenderStateChanges[GFXRS_LINESMOOTHENABLE]) )
00729       {
00730         HW__EnableLineSmooth (GL_TRUE);
00731       }
00732 
00733       if ( (RS_VALUE (m_RenderStateChanges[GFXRS_LINEWIDTH]) != LineWidth) ||
00734            (RS_VALUE (m_RenderStateChanges[GFXRS_LINEHINT]) != Hint) )
00735       {
00736         HW__SetLineWidth (LineWidth, Hint);
00737       }
00738     }
00739     else
00740     {
00741       HW__EnableLineSmooth (GL_FALSE);
00742       HW__SetLineWidth (LineWidth, Hint);
00743     }
00744   }
00745 
00746   inline void GpuRenderStates::EnablePointSmooth (
00747     bool EnablePointSmooth,
00748     t_u32  PointSize,
00749     t_u32 Hint)
00750   {
00751     if (EnablePointSmooth)
00752     {
00753       if (!RS_VALUE (m_RenderStateChanges[GFXRS_POINTSMOOTHENABLE]) )
00754       {
00755         HW__EnablePointSmooth (GL_TRUE);
00756       }
00757 
00758       if ( (RS_VALUE (m_RenderStateChanges[GFXRS_POINTSIZE]) != PointSize) ||
00759            (RS_VALUE (m_RenderStateChanges[GFXRS_POINTHINT]) != Hint) )
00760       {
00761         HW__SetLineWidth (PointSize, Hint);
00762       }
00763     }
00764     else
00765     {
00766       HW__EnablePointSmooth (GL_FALSE);
00767       HW__SetLineWidth (PointSize, Hint);
00768     }
00769   }
00770 
00771   inline void GpuRenderStates::SetColorMask (
00772     t_u32 bRed,
00773     t_u32 bGreen,
00774     t_u32 bBlue,
00775     t_u32 bAlpha)
00776   {
00777     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_R]) != bRed) ||
00778          (RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_G]) != bGreen) ||
00779          (RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_B]) != bBlue) ||
00780          (RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_A]) != bAlpha) )
00781     {
00782       HW__SetColorMask (bRed, bGreen, bBlue, bAlpha);
00783     }
00784 
00785   }
00786 
00787   inline void GpuRenderStates::GetColorMask (
00788     t_u32& bRed,
00789     t_u32& bGreen,
00790     t_u32& bBlue,
00791     t_u32& bAlpha)
00792   {
00793     bRed    = RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_R]);
00794     bGreen  = RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_G]);
00795     bBlue   = RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_B]);
00796     bAlpha  = RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_A]);
00797   }
00798   
00799   inline void GpuRenderStates::SetDepthMask (t_u32 bDepth)
00800   {
00801     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_ZWRITEENABLE]) != bDepth) )
00802     {
00803       HW__SetDepthMask (bDepth);
00804     }
00805   }
00806 
00807   inline void GpuRenderStates::EnableScissor (t_u32 bScissor)
00808   {
00809     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_SCISSORTESTENABLE]) != bScissor) )
00810     {
00811       HW__EnableScissor (bScissor);
00812     }
00813   }
00814 
00815   inline void GpuRenderStates::EnableFog (t_u32 bFog)
00816   {
00817     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_FOGENABLE]) != bFog) )
00818     {
00819       HW__EnableFog (bFog);
00820     }
00821   }
00822 
00823   inline void GpuRenderStates::SetPolygonMode (t_u32 FrontMode, t_u32 BackMode)
00824   {
00825     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_POLYGONMODE]) != FrontMode) ||
00826          (RS_VALUE (m_RenderStateChanges[GFXRS_BACK_POLYGONMODE]) != BackMode) )
00827     {
00828       HW__SetPolygonMode (FrontMode, BackMode);
00829     }
00830   }
00831 
00832   inline void GpuRenderStates::SetPolygonOffset (t_u32 bEnable,
00833       float Factor, float Units)
00834   {
00835     if (bEnable)
00836     {
00837       if (!RS_VALUE (m_RenderStateChanges[GFXRS_POLYGONOFFSETENABLE]) )
00838       {
00839         HW__EnablePolygonOffset (GL_TRUE);
00840       }
00841 
00842       if ( (RS_VALUE (m_RenderStateChanges[GFXRS_POLYGONOFFSETFACTOR]) != static_cast<t_u32> (Factor) ) ||
00843            (RS_VALUE (m_RenderStateChanges[GFXRS_POLYGONOFFSETUNITS]) != static_cast<t_u32> (Units) ) )
00844       {
00845         HW__SetPolygonOffset (Factor, Units);
00846       }
00847     }
00848     else
00849     {
00850       HW__EnablePolygonOffset (GL_FALSE);
00851     }
00852   }
00853 
00854 
00856   inline void GpuRenderStates::HW__EnableAlphaTest (t_u32 b)
00857   {
00858     if (b)
00859     {
00860       CHECKGL (glEnable (GL_ALPHA_TEST) );
00861     }
00862     else
00863     {
00864       CHECKGL (glDisable (GL_ALPHA_TEST) );
00865     }
00866 
00867     SET_RS_VALUE (m_RenderStateChanges[GFXRS_ALPHATESTENABLE], b ? GL_TRUE : GL_FALSE);
00868   }
00869 
00870   inline void GpuRenderStates::HW__SetAlphaTestFunc (t_u32 AlphaTestFunc_,
00871       BYTE  AlphaTestRef_)
00872   {
00873     nuxAssertMsg (
00874       (AlphaTestFunc_ == GL_NEVER) ||
00875       (AlphaTestFunc_ == GL_LESS) ||
00876       (AlphaTestFunc_ == GL_EQUAL) ||
00877       (AlphaTestFunc_ == GL_LEQUAL) ||
00878       (AlphaTestFunc_ == GL_GREATER) ||
00879       (AlphaTestFunc_ == GL_NOTEQUAL) ||
00880       (AlphaTestFunc_ == GL_GEQUAL) ||
00881       (AlphaTestFunc_ == GL_ALWAYS),
00882       TEXT ("Error(HW__SetAlphaTestFunc): Invalid Alpha Test Function RenderState") );
00883 
00884     CHECKGL (glAlphaFunc (AlphaTestFunc_, (float) AlphaTestRef_ * (1.0f / 255.0f) ) );
00885     SET_RS_VALUE (m_RenderStateChanges[GFXRS_ALPHATESTFUNC], AlphaTestFunc_);
00886     SET_RS_VALUE (m_RenderStateChanges[GFXRS_ALPHATESTREF], AlphaTestRef_);
00887   }
00888 
00889   inline void GpuRenderStates::HW__EnableAlphaBlend (t_u32 b)
00890   {
00891     if (b)
00892     {
00893       CHECKGL (glEnable (GL_BLEND) );
00894     }
00895     else
00896     {
00897       CHECKGL (glDisable (GL_BLEND) );
00898     }
00899 
00900     SET_RS_VALUE (m_RenderStateChanges[GFXRS_ALPHABLENDENABLE], b ? GL_TRUE : GL_FALSE);
00901   }
00902 
00903   inline void GpuRenderStates::HW__SetSeparateAlphaBlendFactors (
00904     t_u32 SrcBlendFactor_,
00905     t_u32 DestBlendFactor_,
00906     t_u32 SrcFactorAlpha_,
00907     t_u32 DestFactorAlpha_)
00908   {
00909     nuxAssertMsg ( (SrcBlendFactor_ == GL_ZERO) || (SrcBlendFactor_ == GL_ONE) || (SrcBlendFactor_ == GL_SRC_COLOR) || (SrcBlendFactor_ == GL_ONE_MINUS_SRC_COLOR) || (SrcBlendFactor_ == GL_DST_COLOR) || (SrcBlendFactor_ == GL_ONE_MINUS_DST_COLOR) || (SrcBlendFactor_ == GL_SRC_ALPHA) || (SrcBlendFactor_ == GL_ONE_MINUS_SRC_ALPHA) || (SrcBlendFactor_ == GL_DST_ALPHA) || (SrcBlendFactor_ == GL_ONE_MINUS_DST_ALPHA) || (SrcBlendFactor_ == GL_CONSTANT_COLOR) || (SrcBlendFactor_ == GL_ONE_MINUS_CONSTANT_COLOR) || (SrcBlendFactor_ == GL_CONSTANT_ALPHA) || (SrcBlendFactor_ == GL_ONE_MINUS_CONSTANT_ALPHA) || (SrcBlendFactor_ == GL_SRC_ALPHA_SATURATE),
00910                    TEXT ("Error(HW__SetSeparateAlphaBlendFactors): Invalid Blend RenderState") );
00911     nuxAssertMsg ( (DestBlendFactor_ == GL_ZERO) || (DestBlendFactor_ == GL_ONE) || (DestBlendFactor_ == GL_SRC_COLOR) || (DestBlendFactor_ == GL_ONE_MINUS_SRC_COLOR) || (DestBlendFactor_ == GL_DST_COLOR) || (DestBlendFactor_ == GL_ONE_MINUS_DST_COLOR) || (DestBlendFactor_ == GL_SRC_ALPHA) || (DestBlendFactor_ == GL_ONE_MINUS_SRC_ALPHA) || (DestBlendFactor_ == GL_DST_ALPHA) || (DestBlendFactor_ == GL_ONE_MINUS_DST_ALPHA) || (DestBlendFactor_ == GL_CONSTANT_COLOR) || (DestBlendFactor_ == GL_ONE_MINUS_CONSTANT_COLOR) || (DestBlendFactor_ == GL_CONSTANT_ALPHA) || (DestBlendFactor_ == GL_ONE_MINUS_CONSTANT_ALPHA),
00912                    TEXT ("Error(HW__SetSeparateAlphaBlendFactors): Invalid Blend RenderState") );
00913     nuxAssertMsg ( (SrcFactorAlpha_ == GL_ZERO) || (SrcFactorAlpha_ == GL_ONE) || (SrcFactorAlpha_ == GL_SRC_COLOR) || (SrcFactorAlpha_ == GL_ONE_MINUS_SRC_COLOR) || (SrcFactorAlpha_ == GL_DST_COLOR) || (SrcFactorAlpha_ == GL_ONE_MINUS_DST_COLOR) || (SrcFactorAlpha_ == GL_SRC_ALPHA) || (SrcFactorAlpha_ == GL_ONE_MINUS_SRC_ALPHA) || (SrcFactorAlpha_ == GL_DST_ALPHA) || (SrcFactorAlpha_ == GL_ONE_MINUS_DST_ALPHA) || (SrcFactorAlpha_ == GL_CONSTANT_COLOR) || (SrcFactorAlpha_ == GL_ONE_MINUS_CONSTANT_COLOR) || (SrcFactorAlpha_ == GL_CONSTANT_ALPHA) || (SrcFactorAlpha_ == GL_ONE_MINUS_CONSTANT_ALPHA) || (SrcFactorAlpha_ == GL_SRC_ALPHA_SATURATE),
00914                    TEXT ("Error(HW__SetSeparateAlphaBlendFactors): Invalid Blend RenderState") );
00915     nuxAssertMsg ( (DestFactorAlpha_ == GL_ZERO) || (DestFactorAlpha_ == GL_ONE) || (DestFactorAlpha_ == GL_SRC_COLOR) || (DestFactorAlpha_ == GL_ONE_MINUS_SRC_COLOR) || (DestFactorAlpha_ == GL_DST_COLOR) || (DestFactorAlpha_ == GL_ONE_MINUS_DST_COLOR) || (DestFactorAlpha_ == GL_SRC_ALPHA) || (DestFactorAlpha_ == GL_ONE_MINUS_SRC_ALPHA) || (DestFactorAlpha_ == GL_DST_ALPHA) || (DestFactorAlpha_ == GL_ONE_MINUS_DST_ALPHA) || (DestFactorAlpha_ == GL_CONSTANT_COLOR) || (DestFactorAlpha_ == GL_ONE_MINUS_CONSTANT_COLOR) || (DestFactorAlpha_ == GL_CONSTANT_ALPHA) || (DestFactorAlpha_ == GL_ONE_MINUS_CONSTANT_ALPHA),
00916                    TEXT ("Error(HW__SetSeparateAlphaBlendFactors): Invalid Blend RenderState") );
00917 
00918     CHECKGL (glBlendFuncSeparate (
00919                SrcBlendFactor_,
00920                DestBlendFactor_,
00921                SrcFactorAlpha_,
00922                DestFactorAlpha_) );
00923 
00924     SET_RS_VALUE (m_RenderStateChanges[GFXRS_SRCBLEND], SrcBlendFactor_);
00925     SET_RS_VALUE (m_RenderStateChanges[GFXRS_DESTBLEND], DestBlendFactor_);
00926     SET_RS_VALUE (m_RenderStateChanges[GFXRS_SRCBLENDALPHA], SrcFactorAlpha_);
00927     SET_RS_VALUE (m_RenderStateChanges[GFXRS_DESTBLENDALPHA], DestFactorAlpha_);
00928   }
00929 
00930   inline void GpuRenderStates::HW__SetAlphaBlendOp (
00931     t_u32 BlendOpRGB_,
00932     t_u32 BlendOpAlpha_)
00933   {
00934     nuxAssertMsg (
00935       (BlendOpRGB_ == GL_FUNC_ADD) ||
00936       (BlendOpRGB_ == GL_FUNC_SUBTRACT) ||
00937       (BlendOpRGB_ == GL_FUNC_REVERSE_SUBTRACT) ||
00938       (BlendOpRGB_ == GL_MIN) ||
00939       (BlendOpRGB_ == GL_MAX),
00940       TEXT ("Error(HW__SetAlphaBlendOp): Invalid Blend Equation RenderState") );
00941     nuxAssertMsg (
00942       (BlendOpAlpha_ == GL_FUNC_ADD) ||
00943       (BlendOpAlpha_ == GL_FUNC_SUBTRACT) ||
00944       (BlendOpAlpha_ == GL_FUNC_REVERSE_SUBTRACT) ||
00945       (BlendOpAlpha_ == GL_MIN) ||
00946       (BlendOpAlpha_ == GL_MAX),
00947       TEXT ("Error(HW__SetAlphaBlendOp): Invalid Blend Equation RenderState") );
00948 
00949     if (_gpu_info->SupportOpenGL20 ())
00950     {
00951       CHECKGL (glBlendEquationSeparate (BlendOpRGB_, BlendOpAlpha_) );
00952     }
00953     else if (_gpu_info->Support_EXT_Blend_Equation_Separate ())
00954     {
00955       CHECKGL (glBlendEquationSeparateEXT (BlendOpRGB_, BlendOpAlpha_) );
00956     }
00957     else
00958     {
00959       CHECKGL (glBlendEquation (BlendOpRGB_) );
00960     }
00961 
00962     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BLENDOP], BlendOpRGB_);
00963     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BLENDOPALPHA], BlendOpAlpha_);
00964   }
00965 
00966   inline void GpuRenderStates::HW__EnableCulling (t_u32 b)
00967   {
00968     if (b)
00969     {
00970       CHECKGL (glEnable (GL_CULL_FACE) );
00971     }
00972     else
00973     {
00974       CHECKGL (glDisable (GL_CULL_FACE) );
00975     }
00976 
00977     SET_RS_VALUE (m_RenderStateChanges[GFXRS_CULLFACEENABLE], b ? GL_TRUE : GL_FALSE);
00978   }
00979 
00980 
00981   inline void GpuRenderStates::HW__SetFrontFace (t_u32 FrontFace_)
00982   {
00983     nuxAssertMsg (
00984       (FrontFace_ == GL_CW) ||
00985       (FrontFace_ == GL_CCW),
00986       TEXT ("Error(HW__SetFrontFace): Invalid Front Face RenderState") );
00987 
00988     CHECKGL (glFrontFace (FrontFace_) );
00989     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONTFACE], FrontFace_);
00990   }
00991 
00992   inline void GpuRenderStates::HW__SetCullFace (t_u32 CullFace_)
00993   {
00994     nuxAssertMsg (
00995       (CullFace_ == GL_FRONT) ||
00996       (CullFace_ == GL_BACK) ||
00997       (CullFace_ == GL_FRONT_AND_BACK),
00998       TEXT ("Error(HW__SetCullFace): Invalid Cull Face RenderState") );
00999 
01000     CHECKGL (glCullFace (CullFace_) );
01001     SET_RS_VALUE (m_RenderStateChanges[GFXRS_CULLFACE], CullFace_);
01002   }
01003 
01004   inline void GpuRenderStates::HW__SetEnableDepthTest (t_u32 b)
01005   {
01006     if (b)
01007     {
01008       CHECKGL (glEnable (GL_DEPTH_TEST) );
01009     }
01010     else
01011     {
01012       CHECKGL (glDisable (GL_DEPTH_TEST) );
01013     }
01014 
01015     SET_RS_VALUE (m_RenderStateChanges[GFXRS_ZTESTENABLE], b ? GL_TRUE : GL_FALSE);
01016   }
01017 
01018   inline void GpuRenderStates::HW__SetDepthRange (float zNear, float zFar)
01019   {
01020     CHECKGL (glDepthRange (zNear, zFar) );
01021     SET_RS_VALUE (m_RenderStateChanges[GFXRS_ZNEAR], static_cast<t_u32> (Clamp (zNear, 0.0f, 1.0f) ) );
01022     SET_RS_VALUE (m_RenderStateChanges[GFXRS_ZFAR], static_cast<t_u32> (Clamp (zFar, 0.0f, 1.0f) ) );
01023   }
01024 
01025   inline void GpuRenderStates::HW__SetDepthFunc (t_u32 Func)
01026   {
01027     nuxAssertMsg (
01028       (Func == GL_NEVER) ||
01029       (Func == GL_LESS) ||
01030       (Func == GL_EQUAL) ||
01031       (Func == GL_LEQUAL) ||
01032       (Func == GL_GREATER) ||
01033       (Func == GL_NOTEQUAL) ||
01034       (Func == GL_GEQUAL) ||
01035       (Func == GL_ALWAYS),
01036       TEXT ("Error(HW__SetDepthFunc): Invalid Depth Func RenderState") );
01037 
01038     CHECKGL (glDepthFunc (Func) );
01039     SET_RS_VALUE (m_RenderStateChanges[GFXRS_ZFUNC], Func);
01040   }
01041 
01042   inline void GpuRenderStates::HW__EnableStencil (t_u32 b)
01043   {
01044     if (b)
01045     {
01046       CHECKGL (glEnable (GL_STENCIL_TEST) );
01047     }
01048     else
01049     {
01050       CHECKGL (glDisable (GL_STENCIL_TEST) );
01051     }
01052 
01053     SET_RS_VALUE (m_RenderStateChanges[GFXRS_STENCILENABLE], b ? GL_TRUE : GL_FALSE);
01054   }
01055 
01056   inline void GpuRenderStates::HW__SetStencilFunc (t_u32 func, int ref, t_u32 mask)
01057   {
01058     nuxAssertMsg (
01059       (func == GL_NEVER) ||
01060       (func == GL_LESS) ||
01061       (func == GL_EQUAL) ||
01062       (func == GL_LEQUAL) ||
01063       (func == GL_GREATER) ||
01064       (func == GL_NOTEQUAL) ||
01065       (func == GL_GEQUAL) ||
01066       (func == GL_ALWAYS),
01067       TEXT ("Error(HW__SetFrontFaceStencilFunc): Invalid Stencil Function RenderState"));
01068 
01069     CHECKGL (glStencilFunc (func, ref, mask));
01070 
01071     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC], func);
01072     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILREF], ref);
01073     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILMASK], mask);
01074   }
01075 
01076   inline void GpuRenderStates::HW__SetStencilOp (t_u32 stencil_fail, t_u32 stencil_pass_depth_fail, t_u32 stencil_pass_depth_pass)
01077   {
01078     nuxAssertMsg (
01079       (stencil_fail == GL_KEEP) ||
01080       (stencil_fail == GL_ZERO) ||
01081       (stencil_fail == GL_REPLACE) ||
01082       (stencil_fail == GL_INCR) ||
01083       (stencil_fail == GL_INCR_WRAP) ||
01084       (stencil_fail == GL_DECR) ||
01085       (stencil_fail == GL_DECR_WRAP) ||
01086       (stencil_fail == GL_INVERT),
01087       TEXT ("Error(HW__SetFrontFaceStencilOp): Invalid FailOp RenderState"));
01088 
01089     nuxAssertMsg (
01090       (stencil_pass_depth_fail == GL_KEEP) ||
01091       (stencil_pass_depth_fail == GL_ZERO) ||
01092       (stencil_pass_depth_fail == GL_REPLACE) ||
01093       (stencil_pass_depth_fail == GL_INCR) ||
01094       (stencil_pass_depth_fail == GL_INCR_WRAP) ||
01095       (stencil_pass_depth_fail == GL_DECR) ||
01096       (stencil_pass_depth_fail == GL_DECR_WRAP) ||
01097       (stencil_pass_depth_fail == GL_INVERT),
01098       TEXT ("Error(HW__SetFrontFaceStencilOp): Invalid ZFailOp RenderState"));
01099 
01100     nuxAssertMsg (
01101       (stencil_pass_depth_pass == GL_KEEP) ||
01102       (stencil_pass_depth_pass == GL_ZERO) ||
01103       (stencil_pass_depth_pass == GL_REPLACE) ||
01104       (stencil_pass_depth_pass == GL_INCR) ||
01105       (stencil_pass_depth_pass == GL_INCR_WRAP) ||
01106       (stencil_pass_depth_pass == GL_DECR) ||
01107       (stencil_pass_depth_pass == GL_DECR_WRAP) ||
01108       (stencil_pass_depth_pass == GL_INVERT),
01109       TEXT ("Error(HW__SetFrontFaceStencilOp): Invalid ZPassOp RenderState"));
01110 
01111     CHECKGL (glStencilOp (stencil_fail, stencil_pass_depth_fail, stencil_pass_depth_pass));
01112 
01113     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL], stencil_fail);
01114     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL], stencil_pass_depth_fail);
01115     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS], stencil_pass_depth_pass);
01116   }
01117 
01118 #if 0
01119   inline void GpuRenderStates::HW__EnableTwoSidedStencil (t_u32 b)
01120   {
01121     if (b)
01122     {
01123       if (_gpu_brand == GPU_BRAND_AMD)
01124       {
01125         CHECKGL (glEnable (GL_STENCIL_TEST) );
01126       }
01127       else
01128       {
01129         CHECKGL (glEnable (GL_STENCIL_TEST_TWO_SIDE_EXT) );
01130       }
01131     }
01132     else
01133     {
01134       if (_gpu_brand == GPU_BRAND_AMD)
01135       {
01136         CHECKGL (glDisable (GL_STENCIL_TEST) );
01137       }
01138       else
01139       {
01140         CHECKGL (glDisable (GL_STENCIL_TEST_TWO_SIDE_EXT) );
01141       }
01142     }
01143 
01144     SET_RS_VALUE (m_RenderStateChanges[GFXRS_TWOSIDEDSTENCILENABLE], b ? GL_TRUE : GL_FALSE);
01145   }
01146 
01147   inline void GpuRenderStates::HW__SetStencilFrontFaceWriteMask (t_u32 WriteMask_)
01148   {
01149     CHECKGL (glActiveStencilFaceEXT (GL_FRONT) );
01150     CHECKGL (glStencilMask (WriteMask_) );
01151     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILWRITEMASK], WriteMask_);
01152   }
01153 
01154   inline void GpuRenderStates::HW__SetStencilBackFaceWriteMask (t_u32 WriteMask_)
01155   {
01156     CHECKGL (glActiveStencilFaceEXT (GL_BACK) );
01157     CHECKGL (glStencilMask (WriteMask_) );
01158     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILWRITEMASK], WriteMask_);
01159   }
01160 
01161   inline void GpuRenderStates::HW__SetFrontFaceStencilFunc (t_u32 Func_,
01162       t_u32 Ref_,
01163       t_u32 Mask_)
01164   {
01165     nuxAssertMsg (
01166       (Func_ == GL_NEVER) ||
01167       (Func_ == GL_LESS) ||
01168       (Func_ == GL_EQUAL) ||
01169       (Func_ == GL_LEQUAL) ||
01170       (Func_ == GL_GREATER) ||
01171       (Func_ == GL_NOTEQUAL) ||
01172       (Func_ == GL_GEQUAL) ||
01173       (Func_ == GL_ALWAYS),
01174       TEXT ("Error(HW__SetFrontFaceStencilFunc): Invalid Stencil Function RenderState") );
01175 
01176     CHECKGL (glActiveStencilFaceEXT (GL_FRONT) );
01177     CHECKGL (glStencilFunc (Func_, Ref_, Mask_) );
01178 
01179     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC], Func_);
01180     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILREF], Ref_);
01181     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILMASK], Mask_);
01182   }
01183 
01184   inline void GpuRenderStates::HW__SetBackFaceStencilFunc (
01185     t_u32 Func_,
01186     t_u32 Ref_,
01187     t_u32 Mask_)
01188   {
01189     nuxAssertMsg (
01190       (Func_ == GL_NEVER) ||
01191       (Func_ == GL_LESS) ||
01192       (Func_ == GL_EQUAL) ||
01193       (Func_ == GL_LEQUAL) ||
01194       (Func_ == GL_GREATER) ||
01195       (Func_ == GL_NOTEQUAL) ||
01196       (Func_ == GL_GEQUAL) ||
01197       (Func_ == GL_ALWAYS),
01198       TEXT ("Error(HW__SetBackFaceStencilFunc): Invalid Stencil Function RenderState") );
01199 
01200     if (_gpu_brand == GPU_BRAND_AMD)
01201     {
01202       CHECKGL (glStencilFuncSeparateATI (Func_/*Front function*/, Func_/*Back function*/, Ref_, Mask_) ); // incorrect
01203     }
01204     else
01205     {
01206       CHECKGL (glActiveStencilFaceEXT (GL_BACK) );
01207       CHECKGL (glStencilFunc (Func_, Ref_, Mask_) );
01208     }
01209 
01210     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILFUNC], Func_);
01211     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILREF], Ref_);
01212     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILMASK], Mask_);
01213   }
01214 
01215   inline void GpuRenderStates::HW__SetFrontFaceStencilOp (
01216     t_u32 FailOp_,
01217     t_u32 ZFailOp_,
01218     t_u32 ZPassOp_)
01219   {
01220     nuxAssertMsg (
01221       (FailOp_ == GL_KEEP) ||
01222       (FailOp_ == GL_ZERO) ||
01223       (FailOp_ == GL_REPLACE) ||
01224       (FailOp_ == GL_INCR) ||
01225       (FailOp_ == GL_INCR_WRAP) ||
01226       (FailOp_ == GL_DECR) ||
01227       (FailOp_ == GL_DECR_WRAP) ||
01228       (FailOp_ == GL_INVERT),
01229       TEXT ("Error(HW__SetFrontFaceStencilOp): Invalid FailOp RenderState") );
01230 
01231     nuxAssertMsg (
01232       (ZFailOp_ == GL_KEEP) ||
01233       (ZFailOp_ == GL_ZERO) ||
01234       (ZFailOp_ == GL_REPLACE) ||
01235       (ZFailOp_ == GL_INCR) ||
01236       (ZFailOp_ == GL_INCR_WRAP) ||
01237       (ZFailOp_ == GL_DECR) ||
01238       (ZFailOp_ == GL_DECR_WRAP) ||
01239       (ZFailOp_ == GL_INVERT),
01240       TEXT ("Error(HW__SetFrontFaceStencilOp): Invalid ZFailOp RenderState") );
01241 
01242     nuxAssertMsg (
01243       (ZPassOp_ == GL_KEEP) ||
01244       (ZPassOp_ == GL_ZERO) ||
01245       (ZPassOp_ == GL_REPLACE) ||
01246       (ZPassOp_ == GL_INCR) ||
01247       (ZPassOp_ == GL_INCR_WRAP) ||
01248       (ZPassOp_ == GL_DECR) ||
01249       (ZPassOp_ == GL_DECR_WRAP) ||
01250       (ZPassOp_ == GL_INVERT),
01251       TEXT ("Error(HW__SetFrontFaceStencilOp): Invalid ZPassOp RenderState") );
01252 
01253     if (_gpu_brand == GPU_BRAND_AMD)
01254     {
01255       CHECKGL (glStencilOpSeparateATI (GL_FRONT, FailOp_, ZFailOp_, ZPassOp_) );
01256     }
01257     else
01258     {
01259       CHECKGL (glActiveStencilFaceEXT (GL_FRONT) );
01260       CHECKGL (glStencilOp (FailOp_, ZFailOp_, ZPassOp_) );
01261     }
01262 
01263     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL], FailOp_);
01264     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL], ZFailOp_);
01265     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS], ZPassOp_);
01266   }
01267 
01268   inline void GpuRenderStates::HW__SetBackFaceStencilOp (
01269     t_u32 FailOp_,
01270     t_u32 ZFailOp_,
01271     t_u32 ZPassOp_)
01272   {
01273     nuxAssertMsg (
01274       (FailOp_ == GL_KEEP) ||
01275       (FailOp_ == GL_ZERO) ||
01276       (FailOp_ == GL_REPLACE) ||
01277       (FailOp_ == GL_INCR) ||
01278       (FailOp_ == GL_INCR_WRAP) ||
01279       (FailOp_ == GL_DECR) ||
01280       (FailOp_ == GL_DECR_WRAP) ||
01281       (FailOp_ == GL_INVERT),
01282       TEXT ("Error(HW__SetBackFaceStencilOp): Invalid FailOp RenderState") );
01283 
01284     nuxAssertMsg (
01285       (ZFailOp_ == GL_KEEP) ||
01286       (ZFailOp_ == GL_ZERO) ||
01287       (ZFailOp_ == GL_REPLACE) ||
01288       (ZFailOp_ == GL_INCR) ||
01289       (ZFailOp_ == GL_INCR_WRAP) ||
01290       (ZFailOp_ == GL_DECR) ||
01291       (ZFailOp_ == GL_DECR_WRAP) ||
01292       (ZFailOp_ == GL_INVERT),
01293       TEXT ("Error(HW__SetBackFaceStencilOp): Invalid ZFailOp RenderState") );
01294 
01295     nuxAssertMsg (
01296       (ZPassOp_ == GL_KEEP) ||
01297       (ZPassOp_ == GL_ZERO) ||
01298       (ZPassOp_ == GL_REPLACE) ||
01299       (ZPassOp_ == GL_INCR) ||
01300       (ZPassOp_ == GL_INCR_WRAP) ||
01301       (ZPassOp_ == GL_DECR) ||
01302       (ZPassOp_ == GL_DECR_WRAP) ||
01303       (ZPassOp_ == GL_INVERT),
01304       TEXT ("Error(HW__SetBackFaceStencilOp): Invalid ZPassOp RenderState") );
01305 
01306     if (_gpu_brand == GPU_BRAND_AMD)
01307     {
01308       CHECKGL (glStencilOpSeparateATI (GL_BACK, FailOp_, ZFailOp_, ZPassOp_) );
01309     }
01310     else
01311     {
01312       CHECKGL (glActiveStencilFaceEXT (GL_BACK) );
01313       CHECKGL (glStencilOp (FailOp_, ZFailOp_, ZPassOp_) );
01314     }
01315 
01316     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILFAIL], FailOp_);
01317     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILZFAIL], ZFailOp_);
01318     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILZPASS], ZPassOp_);
01319   }
01320 #endif
01321 
01322   inline void GpuRenderStates::HW__EnableLineSmooth (t_u32 EnableLineSmooth)
01323   {
01324     if (EnableLineSmooth)
01325     {
01326       CHECKGL (glEnable (GL_LINE_SMOOTH) );
01327     }
01328     else
01329     {
01330       CHECKGL (glDisable (GL_LINE_SMOOTH) );
01331     }
01332 
01333     SET_RS_VALUE (m_RenderStateChanges[GFXRS_LINESMOOTHENABLE], EnableLineSmooth ? GL_TRUE : GL_FALSE);
01334   }
01335 
01336   inline void GpuRenderStates::HW__SetLineWidth (t_u32 width,  t_u32 Hint)
01337   {
01338     nuxAssertMsg (
01339       (Hint == GL_NICEST) ||
01340       (Hint == GL_FASTEST) ||
01341       (Hint == GL_DONT_CARE),
01342       TEXT ("Error(HW__SetLineWidth): Invalid Line Hint RenderState") );
01343 
01344     CHECKGL (glLineWidth (width) );
01345     CHECKGL (glHint (GL_LINE_SMOOTH_HINT, Hint) );
01346     SET_RS_VALUE (m_RenderStateChanges[GFXRS_LINEWIDTH], width);
01347     SET_RS_VALUE (m_RenderStateChanges[GFXRS_LINEHINT], Hint);
01348   }
01349 
01350   inline void GpuRenderStates::HW__EnablePointSmooth (t_u32 EnablePointSmooth)
01351   {
01352     if (EnablePointSmooth)
01353     {
01354       CHECKGL (glEnable (GL_POINT_SMOOTH) );
01355     }
01356     else
01357     {
01358       CHECKGL (glDisable (GL_POINT_SMOOTH) );
01359     }
01360 
01361     SET_RS_VALUE (m_RenderStateChanges[GFXRS_POINTSMOOTHENABLE], EnablePointSmooth ? GL_TRUE : GL_FALSE);
01362   }
01363 
01364   inline void GpuRenderStates::HW__SetPointSize (t_u32 size,  t_u32 Hint)
01365   {
01366     nuxAssertMsg (
01367       (Hint == GL_NICEST) ||
01368       (Hint == GL_FASTEST) ||
01369       (Hint == GL_DONT_CARE),
01370       TEXT ("Error(HW__SetPointSize): Invalid Point Hint RenderState") );
01371 
01372     CHECKGL (glPointSize (size) );
01373     CHECKGL (glHint (GL_POINT_SMOOTH_HINT, Hint);)
01374     SET_RS_VALUE (m_RenderStateChanges[GFXRS_POINTSIZE], size);
01375     SET_RS_VALUE (m_RenderStateChanges[GFXRS_POINTHINT], Hint);
01376   }
01377 
01378   inline void GpuRenderStates::HW__SetColorMask (
01379     t_u32 bRed,
01380     t_u32 bGreen,
01381     t_u32 bBlue,
01382     t_u32 bAlpha)
01383   {
01384     CHECKGL (glColorMask (bRed, bGreen, bBlue, bAlpha) );
01385     SET_RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_R], bRed);
01386     SET_RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_G], bGreen);
01387     SET_RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_B], bBlue);
01388     SET_RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_A], bAlpha);
01389   }
01390 
01391   inline void GpuRenderStates::HW__SetDepthMask (t_u32 bDepth)
01392   {
01393     CHECKGL (glDepthMask (bDepth) );
01394     SET_RS_VALUE (m_RenderStateChanges[GFXRS_ZWRITEENABLE], bDepth);
01395   }
01396 
01397   inline void GpuRenderStates::HW__EnableScissor (t_u32 bScissor)
01398   {
01399     if (bScissor)
01400     {
01401       CHECKGL (glEnable (GL_SCISSOR_TEST) );
01402     }
01403     else
01404     {
01405       CHECKGL (glDisable (GL_SCISSOR_TEST) );
01406     }
01407 
01408     SET_RS_VALUE (m_RenderStateChanges[GFXRS_SCISSORTESTENABLE], bScissor ? GL_TRUE : GL_FALSE);
01409   }
01410 
01411   inline void GpuRenderStates::HW__EnableFog (t_u32 bFog)
01412   {
01413     if (bFog)
01414     {
01415       CHECKGL (glEnable (GL_FOG) );
01416     }
01417     else
01418     {
01419       CHECKGL (glDisable (GL_FOG) );
01420     }
01421 
01422     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FOGENABLE], bFog ? GL_TRUE : GL_FALSE);
01423   }
01424 
01425   inline void GpuRenderStates::HW__SetPolygonMode (t_u32 FrontMode, t_u32 BackMode)
01426   {
01427     nuxAssertMsg (
01428       (FrontMode == GL_FILL) ||
01429       (FrontMode == GL_LINE) ||
01430       (FrontMode == GL_POINT),
01431       TEXT ("Error(HW__SetPolygonMode): Invalid Point Hint RenderState") );
01432 
01433     nuxAssertMsg (
01434       (BackMode == GL_FILL) ||
01435       (BackMode == GL_LINE) ||
01436       (BackMode == GL_POINT),
01437       TEXT ("Error(HW__SetPolygonMode): Invalid Point Hint RenderState") );
01438 
01439     CHECKGL (glPolygonMode (GL_FRONT, FrontMode) );
01440     CHECKGL (glPolygonMode (GL_BACK, BackMode) );
01441 
01442     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_POLYGONMODE], FrontMode);
01443     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BACK_POLYGONMODE], BackMode);
01444   }
01445 
01446   inline void GpuRenderStates::HW__EnablePolygonOffset (t_u32 EnablePolygonOffset)
01447   {
01448     if (EnablePolygonOffset)
01449     {
01450       CHECKGL (glEnable (GL_POLYGON_OFFSET_FILL) );
01451     }
01452     else
01453     {
01454       CHECKGL (glDisable (GL_POLYGON_OFFSET_FILL) );
01455     }
01456 
01457     SET_RS_VALUE (m_RenderStateChanges[GL_POLYGON_OFFSET_FILL], EnablePolygonOffset ? GL_TRUE : GL_FALSE);
01458   }
01459 
01460   inline void GpuRenderStates::HW__SetPolygonOffset (float Factor, float Units)
01461   {
01462     CHECKGL (glPolygonOffset (Factor, Units) );
01463 
01464     SET_RS_VALUE (m_RenderStateChanges[GFXRS_POLYGONOFFSETFACTOR], static_cast<t_u32> (Factor) );
01465     SET_RS_VALUE (m_RenderStateChanges[GFXRS_POLYGONOFFSETUNITS], static_cast<t_u32> (Units) );
01466   }
01467 
01468 #undef SET_RS_VALUE
01469 #undef RS_VALUE
01470 
01471 //#undef SET_RS_VALUE_FLOAT
01472 //#undef RS_VALUE_FLOAT
01473 
01474 }
01475 
01476 #endif // GLRENDERSTATES_H
01477