nux-1.14.0
GLRenderStates.h
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_RenderStateChanges[GFXRS_MAX_RENDERSTATES];
00346     RenderStateMap m_SamplerStateChanges[4][GFXSS_MAX_SAMPLERSTATES];
00347   };
00348 
00349 
00350 
00351 #define SET_RS_VALUE(a, b)  (a).iValue = (b)
00352 #define RS_VALUE(a)      (a).iValue
00353 
00354 //#define SET_RS_VALUE_FLOAT(a, b)  (a).fValue = (b)
00355 //#define RS_VALUE_FLOAT(a, b)      (a).fValue
00356 
00357 
00358   inline void GpuRenderStates::SetAlphaTest (
00359     bool EnableAlphaTest_,
00360     t_u32 AlphaTestFunc_,
00361     BYTE AlphaTestRef_)
00362   {
00363     if (EnableAlphaTest_)
00364     {
00365       if (!RS_VALUE (m_RenderStateChanges[GFXRS_ALPHATESTENABLE]) )
00366       {
00367         HW__EnableAlphaTest (TRUE);
00368       }
00369 
00370       if ( (RS_VALUE (m_RenderStateChanges[GFXRS_ALPHATESTFUNC]) != AlphaTestFunc_) ||
00371            (RS_VALUE (m_RenderStateChanges[GFXRS_ALPHATESTREF]) != AlphaTestRef_) )
00372       {
00373         HW__SetAlphaTestFunc (AlphaTestFunc_, AlphaTestRef_);
00374       }
00375     }
00376     else
00377     {
00378       HW__EnableAlphaTest (GL_FALSE);
00379       HW__SetAlphaTestFunc (AlphaTestFunc_, AlphaTestRef_);
00380     }
00381   }
00382 
00383   inline void GpuRenderStates::SetBlend (bool AlphaBlendEnable_)
00384   {
00385     if (AlphaBlendEnable_)
00386     {
00387       if (!RS_VALUE (m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]) )
00388       {
00389         HW__EnableAlphaBlend (TRUE);
00390       }
00391     }
00392     else
00393     {
00394       if (RS_VALUE (m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]) )
00395       {
00396         HW__EnableAlphaBlend (GL_FALSE);
00397       }
00398     }
00399   }
00400 
00401   inline void GpuRenderStates::SetBlend (bool AlphaBlendEnable_,
00402                                         t_u32 SrcBlendFactor_,
00403                                         t_u32 DestBlendFactor_)
00404   {
00405     SetBlend (AlphaBlendEnable_);
00406 
00407     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_SRCBLEND]) != SrcBlendFactor_) ||
00408          (RS_VALUE (m_RenderStateChanges[GFXRS_DESTBLEND]) != DestBlendFactor_) )
00409     {
00410       HW__SetSeparateAlphaBlendFactors (
00411         SrcBlendFactor_,
00412         DestBlendFactor_,
00413         SrcBlendFactor_,
00414         DestBlendFactor_);
00415     }
00416   }
00417 
00418   inline void GpuRenderStates::GetBlend (t_u32& AlphaBlendEnable_,
00419                     t_u32& SrcBlendFactor_,
00420                     t_u32& DestBlendFactor_)
00421   {
00422     AlphaBlendEnable_ = RS_VALUE (m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]);
00423     SrcBlendFactor_   = RS_VALUE (m_RenderStateChanges[GFXRS_SRCBLEND]);
00424     DestBlendFactor_  = RS_VALUE (m_RenderStateChanges[GFXRS_DESTBLEND]);
00425   }
00426     
00427   inline void GpuRenderStates::SetSeparateBlend (bool EnableSeparateAlphaBlend,
00428       t_u32 SrcBlendFactor_,
00429       t_u32 DestBlendFactor_,
00430       t_u32 SrcBlendFactorAlpha_,
00431       t_u32 DestBlendFactorAlpha_)
00432   {
00433     SetBlend (EnableSeparateAlphaBlend);
00434 
00435 //     if(EnableSeparateAlphaBlend)
00436 //     {
00437 //         if(!RS_VALUE(m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]))
00438 //         {
00439 //             HW__EnableAlphaBlend(TRUE);
00440 //         }
00441 
00442     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_SRCBLEND]) != SrcBlendFactor_) ||
00443          (RS_VALUE (m_RenderStateChanges[GFXRS_DESTBLEND]) != DestBlendFactor_) ||
00444          (RS_VALUE (m_RenderStateChanges[GFXRS_SRCBLENDALPHA]) != SrcBlendFactorAlpha_) ||
00445          (RS_VALUE (m_RenderStateChanges[GFXRS_DESTBLENDALPHA]) != DestBlendFactorAlpha_) )
00446     {
00447       HW__SetSeparateAlphaBlendFactors (
00448         SrcBlendFactor_,
00449         DestBlendFactor_,
00450         SrcBlendFactorAlpha_,
00451         DestBlendFactorAlpha_);
00452     }
00453 
00454 //     }
00455 //     else
00456 //     {
00457 //         HW__EnableAlphaBlend(GL_FALSE);
00458 //         HW__SetSeparateAlphaBlendFactors(
00459 //             SrcBlendFactor_,
00460 //             DestBlendFactor_,
00461 //             SrcBlendFactorAlpha_,
00462 //             DestBlendFactorAlpha_);
00463 //     }
00464   }
00465 
00466   inline void GpuRenderStates::SetPremultipliedBlend (PorterDuffOperator op)
00467   {
00468     static const struct
00469     {
00470       const t_u32 src_blend;
00471       const t_u32 dst_blend;
00472     } factor[13] =
00473     {
00474       { GL_ZERO,                GL_ZERO                }, // CLEAR
00475       { GL_ONE,                 GL_ZERO                }, // SRC
00476       { GL_ZERO,                GL_ONE                 }, // DST
00477       { GL_ONE,                 GL_ONE_MINUS_SRC_ALPHA }, // SRC_OVER
00478       { GL_ONE_MINUS_DST_ALPHA, GL_ONE                 }, // DST_OVER
00479       { GL_DST_ALPHA,           GL_ZERO                }, // SRC_IN
00480       { GL_ZERO,                GL_SRC_ALPHA           }, // DST_IN
00481       { GL_ONE_MINUS_DST_ALPHA, GL_ZERO                }, // SRC_OUT
00482       { GL_ZERO,                GL_ONE_MINUS_SRC_ALPHA }, // DST_OUT
00483       { GL_DST_ALPHA,           GL_ONE_MINUS_SRC_ALPHA }, // SRC_ATOP
00484       { GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA           }, // DST_ATOP
00485       { GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA }, // XOR
00486       { GL_ONE,                 GL_ONE                 }  // PLUS
00487     };
00488 
00489     if ((RS_VALUE (m_RenderStateChanges[GFXRS_SRCBLEND]) !=
00490          factor[op].src_blend) ||
00491         (RS_VALUE (m_RenderStateChanges[GFXRS_DESTBLEND]) !=
00492          factor[op].dst_blend))
00493     {
00494       HW__SetSeparateAlphaBlendFactors
00495         (factor[op].src_blend, factor[op].dst_blend,
00496          factor[op].src_blend, factor[op].dst_blend);
00497     }
00498   }
00499 
00500   inline void GpuRenderStates::SetBlendOp (t_u32 BlendOp)
00501   {
00502     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_BLENDOP]) != BlendOp) )
00503     {
00504       HW__SetAlphaBlendOp (BlendOp, BlendOp);
00505     }
00506   }
00507 
00508   inline void GpuRenderStates::SetSeparateBlendOp (
00509     t_u32 BlendOpRGB_,
00510     t_u32 BlendOpAlpha_)
00511   {
00512     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_BLENDOP]) != BlendOpRGB_) ||
00513          (RS_VALUE (m_RenderStateChanges[GFXRS_BLENDOPALPHA]) != BlendOpAlpha_) )
00514     {
00515       HW__SetAlphaBlendOp (BlendOpRGB_, BlendOpAlpha_);
00516     }
00517   }
00518 
00519   inline void GpuRenderStates::SetCullMode (bool EnableCullFace,
00520       t_u32 FrontFace_,
00521       t_u32 Cullface_)
00522   {
00523     if (EnableCullFace)
00524     {
00525       if (!RS_VALUE (m_RenderStateChanges[GFXRS_CULLFACEENABLE]) )
00526       {
00527         HW__EnableCulling (TRUE);
00528       }
00529 
00530       if (RS_VALUE (m_RenderStateChanges[GFXRS_FRONTFACE]) != FrontFace_)
00531       {
00532         HW__SetFrontFace (FrontFace_);
00533       }
00534 
00535       if (RS_VALUE (m_RenderStateChanges[GFXRS_CULLFACE]) != Cullface_)
00536       {
00537         HW__SetCullFace (Cullface_);
00538       }
00539     }
00540     else
00541     {
00542       HW__EnableCulling (FALSE);
00543       HW__SetFrontFace (FrontFace_);
00544       HW__SetCullFace (Cullface_);
00545     }
00546   }
00547 
00548   inline void GpuRenderStates::SetDepthTest (bool EnableDepthTest,
00549       t_u32 WriteEnable_,
00550       t_u32 DepthFunc_)
00551   {
00552     if (EnableDepthTest)
00553     {
00554       if (!RS_VALUE (m_RenderStateChanges[GFXRS_ZTESTENABLE]) )
00555       {
00556         HW__SetEnableDepthTest (TRUE);
00557       }
00558 
00559       if (RS_VALUE (m_RenderStateChanges[GFXRS_ZWRITEENABLE]) != WriteEnable_)
00560       {
00561         HW__SetDepthMask (WriteEnable_);
00562       }
00563 
00564       if (RS_VALUE (m_RenderStateChanges[GFXRS_ZFUNC]) != DepthFunc_)
00565       {
00566         HW__SetDepthFunc (DepthFunc_);
00567       }
00568     }
00569     else
00570     {
00571       HW__SetEnableDepthTest (FALSE);
00572       HW__SetDepthMask (WriteEnable_);
00573       HW__SetDepthFunc (DepthFunc_);
00574     }
00575   }
00576 
00577   inline void GpuRenderStates::SetDepthRange (float zNear, float zFar)
00578   {
00579     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_ZNEAR]) != static_cast<t_u32> (zNear) ) ||
00580          (RS_VALUE (m_RenderStateChanges[GFXRS_ZFAR]) != static_cast<t_u32> (zFar) ) )
00581     {
00582       HW__SetDepthRange (zNear, zFar);
00583     }
00584   }
00585 
00586   void GpuRenderStates::SetStencil (bool enable_stencil)
00587   {
00588     if (enable_stencil)
00589     {
00590       if (!RS_VALUE (m_RenderStateChanges[GFXRS_STENCILENABLE]))
00591       {
00592         HW__EnableStencil (TRUE);
00593       }
00594     }
00595     else
00596     {
00597       HW__EnableStencil (FALSE);
00598     }
00599   }
00600 
00601   void GpuRenderStates::SetStencilFunc (t_u32 func, int ref, t_u32 mask)
00602   {
00603     if (
00604       (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC]) != func) ||
00605       (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILREF]) != (t_u32)ref) ||
00606       (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILMASK]) != mask)
00607       )
00608     {
00609       HW__SetStencilFunc (func, ref, mask);
00610     }
00611   }
00612 
00613   void GpuRenderStates::SetStencilOp (t_u32 stencil_fail, t_u32 stencil_pass_depth_fail, t_u32 stencil_pass_depth_pass)
00614   {
00615     if (
00616       (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL]) != stencil_fail) ||
00617       (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL]) != stencil_pass_depth_fail) ||
00618       (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS]) != stencil_pass_depth_pass)
00619       )
00620     {
00621       HW__SetStencilOp (stencil_fail, stencil_pass_depth_fail, stencil_pass_depth_pass);
00622     }
00623   }
00624 
00625 #if 0
00626   inline void GpuRenderStates::SetStencilFrontFace (
00627     bool EnableStencil_,                            // GL_TRUE enable stencil test
00628     t_u32 Func_,
00629     t_u32 FailOp_,
00630     t_u32 ZFailOp_,
00631     t_u32 ZPassOp_,
00632     t_u32 Ref_,
00633     t_u32 Mask_)
00634   {
00635     if (EnableStencil_)
00636     {
00637       if (!RS_VALUE (m_RenderStateChanges[GFXRS_STENCILENABLE]) )
00638       {
00639         HW__EnableStencil (TRUE);
00640       }
00641 
00642       if (
00643         (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC]) != Func_) ||
00644         (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILREF]) != Ref_) ||
00645         (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILMASK]) != Mask_) ||
00646         (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL]) != FailOp_) ||
00647         (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL]) != ZFailOp_) ||
00648         (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS]) != ZPassOp_)
00649       )
00650       {
00651         HW__SetFrontFaceStencilFunc (Func_, Ref_, Mask_);
00652         HW__SetFrontFaceStencilOp (FailOp_, ZFailOp_, ZPassOp_);
00653       }
00654     }
00655     else
00656     {
00657       HW__EnableStencil (FALSE);
00658       HW__SetFrontFaceStencilFunc (Func_, Ref_, Mask_);
00659       HW__SetFrontFaceStencilOp (FailOp_, ZFailOp_, ZPassOp_);
00660     }
00661   }
00662 
00663   inline void GpuRenderStates::SetStencilBackFace (
00664     bool EnableTwoSideStencil_,                     // GL_TRUE enable Two Sided Stencil test
00665     t_u32 Func_,
00666     t_u32 FailOp_,
00667     t_u32 ZFailOp_,
00668     t_u32 ZPassOp_,
00669     t_u32 Ref_,
00670     t_u32 Mask_)
00671   {
00672     if (EnableTwoSideStencil_)
00673     {
00674       if (!RS_VALUE (m_RenderStateChanges[GFXRS_STENCILENABLE]) )
00675       {
00676         HW__EnableStencil (TRUE);
00677       }
00678 
00679       if (!RS_VALUE (m_RenderStateChanges[GFXRS_TWOSIDEDSTENCILENABLE]) )
00680       {
00681         HW__EnableTwoSidedStencil (TRUE);
00682       }
00683 
00684       if (
00685         (RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILFUNC]) != Func_) ||
00686         (RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILREF]) != Ref_) ||
00687         (RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILMASK]) != Mask_) ||
00688         (RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILFAIL]) != FailOp_) ||
00689         (RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILZFAIL]) != ZFailOp_) ||
00690         (RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILZPASS]) != ZPassOp_)
00691       )
00692       {
00693         HW__SetBackFaceStencilFunc (Func_, Ref_, Mask_);
00694         HW__SetBackFaceStencilOp (FailOp_, ZFailOp_, ZPassOp_);
00695       }
00696     }
00697     else
00698     {
00699       HW__EnableTwoSidedStencil (FALSE);
00700       HW__SetBackFaceStencilFunc (Func_, Ref_, Mask_);
00701       HW__SetBackFaceStencilOp (FailOp_, ZFailOp_, ZPassOp_);
00702     }
00703   }
00704 
00705   inline void GpuRenderStates::SetFrontFaceStencilWriteMask (
00706     t_u32 WriteMask_)
00707   {
00708     HW__SetStencilFrontFaceWriteMask (WriteMask_);
00709   }
00710 
00711   inline void GpuRenderStates::SetBackFaceStencilWriteMask (
00712     t_u32 WriteMask_)
00713   {
00714     HW__SetStencilBackFaceWriteMask (WriteMask_);
00715   }
00716 #endif
00717 
00718   inline void GpuRenderStates::EnableLineSmooth (
00719     bool EnableLineSmooth,
00720     t_u32  LineWidth,
00721     t_u32 Hint)
00722   {
00723     if (EnableLineSmooth)
00724     {
00725       if (!RS_VALUE (m_RenderStateChanges[GFXRS_LINESMOOTHENABLE]) )
00726       {
00727         HW__EnableLineSmooth (GL_TRUE);
00728       }
00729 
00730       if ( (RS_VALUE (m_RenderStateChanges[GFXRS_LINEWIDTH]) != LineWidth) ||
00731            (RS_VALUE (m_RenderStateChanges[GFXRS_LINEHINT]) != Hint) )
00732       {
00733         HW__SetLineWidth (LineWidth, Hint);
00734       }
00735     }
00736     else
00737     {
00738       HW__EnableLineSmooth (GL_FALSE);
00739       HW__SetLineWidth (LineWidth, Hint);
00740     }
00741   }
00742 
00743   inline void GpuRenderStates::EnablePointSmooth (
00744     bool EnablePointSmooth,
00745     t_u32  PointSize,
00746     t_u32 Hint)
00747   {
00748     if (EnablePointSmooth)
00749     {
00750       if (!RS_VALUE (m_RenderStateChanges[GFXRS_POINTSMOOTHENABLE]) )
00751       {
00752         HW__EnablePointSmooth (GL_TRUE);
00753       }
00754 
00755       if ( (RS_VALUE (m_RenderStateChanges[GFXRS_POINTSIZE]) != PointSize) ||
00756            (RS_VALUE (m_RenderStateChanges[GFXRS_POINTHINT]) != Hint) )
00757       {
00758         HW__SetLineWidth (PointSize, Hint);
00759       }
00760     }
00761     else
00762     {
00763       HW__EnablePointSmooth (GL_FALSE);
00764       HW__SetLineWidth (PointSize, Hint);
00765     }
00766   }
00767 
00768   inline void GpuRenderStates::SetColorMask (
00769     t_u32 bRed,
00770     t_u32 bGreen,
00771     t_u32 bBlue,
00772     t_u32 bAlpha)
00773   {
00774     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_R]) != bRed) ||
00775          (RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_G]) != bGreen) ||
00776          (RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_B]) != bBlue) ||
00777          (RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_A]) != bAlpha) )
00778     {
00779       HW__SetColorMask (bRed, bGreen, bBlue, bAlpha);
00780     }
00781 
00782   }
00783 
00784   inline void GpuRenderStates::GetColorMask (
00785     t_u32& bRed,
00786     t_u32& bGreen,
00787     t_u32& bBlue,
00788     t_u32& bAlpha)
00789   {
00790     bRed    = RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_R]);
00791     bGreen  = RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_G]);
00792     bBlue   = RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_B]);
00793     bAlpha  = RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_A]);
00794   }
00795   
00796   inline void GpuRenderStates::SetDepthMask (t_u32 bDepth)
00797   {
00798     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_ZWRITEENABLE]) != bDepth) )
00799     {
00800       HW__SetDepthMask (bDepth);
00801     }
00802   }
00803 
00804   inline void GpuRenderStates::EnableScissor (t_u32 bScissor)
00805   {
00806     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_SCISSORTESTENABLE]) != bScissor) )
00807     {
00808       HW__EnableScissor (bScissor);
00809     }
00810   }
00811 
00812   inline void GpuRenderStates::EnableFog (t_u32 bFog)
00813   {
00814     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_FOGENABLE]) != bFog) )
00815     {
00816       HW__EnableFog (bFog);
00817     }
00818   }
00819 
00820   inline void GpuRenderStates::SetPolygonMode (t_u32 FrontMode, t_u32 BackMode)
00821   {
00822     if ( (RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_POLYGONMODE]) != FrontMode) ||
00823          (RS_VALUE (m_RenderStateChanges[GFXRS_BACK_POLYGONMODE]) != BackMode) )
00824     {
00825       HW__SetPolygonMode (FrontMode, BackMode);
00826     }
00827   }
00828 
00829   inline void GpuRenderStates::SetPolygonOffset (t_u32 bEnable,
00830       float Factor, float Units)
00831   {
00832     if (bEnable)
00833     {
00834       if (!RS_VALUE (m_RenderStateChanges[GFXRS_POLYGONOFFSETENABLE]) )
00835       {
00836         HW__EnablePolygonOffset (GL_TRUE);
00837       }
00838 
00839       if ( (RS_VALUE (m_RenderStateChanges[GFXRS_POLYGONOFFSETFACTOR]) != static_cast<t_u32> (Factor) ) ||
00840            (RS_VALUE (m_RenderStateChanges[GFXRS_POLYGONOFFSETUNITS]) != static_cast<t_u32> (Units) ) )
00841       {
00842         HW__SetPolygonOffset (Factor, Units);
00843       }
00844     }
00845     else
00846     {
00847       HW__EnablePolygonOffset (GL_FALSE);
00848     }
00849   }
00850 
00851 
00853   inline void GpuRenderStates::HW__EnableAlphaTest (t_u32 b)
00854   {
00855     if (b)
00856     {
00857       CHECKGL (glEnable (GL_ALPHA_TEST) );
00858     }
00859     else
00860     {
00861       CHECKGL (glDisable (GL_ALPHA_TEST) );
00862     }
00863 
00864     SET_RS_VALUE (m_RenderStateChanges[GFXRS_ALPHATESTENABLE], b ? GL_TRUE : GL_FALSE);
00865   }
00866 
00867   inline void GpuRenderStates::HW__SetAlphaTestFunc (t_u32 AlphaTestFunc_,
00868       BYTE  AlphaTestRef_)
00869   {
00870     nuxAssertMsg (
00871       (AlphaTestFunc_ == GL_NEVER) ||
00872       (AlphaTestFunc_ == GL_LESS) ||
00873       (AlphaTestFunc_ == GL_EQUAL) ||
00874       (AlphaTestFunc_ == GL_LEQUAL) ||
00875       (AlphaTestFunc_ == GL_GREATER) ||
00876       (AlphaTestFunc_ == GL_NOTEQUAL) ||
00877       (AlphaTestFunc_ == GL_GEQUAL) ||
00878       (AlphaTestFunc_ == GL_ALWAYS),
00879       TEXT ("Error(HW__SetAlphaTestFunc): Invalid Alpha Test Function RenderState") );
00880 
00881     CHECKGL (glAlphaFunc (AlphaTestFunc_, (float) AlphaTestRef_ * (1.0f / 255.0f) ) );
00882     SET_RS_VALUE (m_RenderStateChanges[GFXRS_ALPHATESTFUNC], AlphaTestFunc_);
00883     SET_RS_VALUE (m_RenderStateChanges[GFXRS_ALPHATESTREF], AlphaTestRef_);
00884   }
00885 
00886   inline void GpuRenderStates::HW__EnableAlphaBlend (t_u32 b)
00887   {
00888     if (b)
00889     {
00890       CHECKGL (glEnable (GL_BLEND) );
00891     }
00892     else
00893     {
00894       CHECKGL (glDisable (GL_BLEND) );
00895     }
00896 
00897     SET_RS_VALUE (m_RenderStateChanges[GFXRS_ALPHABLENDENABLE], b ? GL_TRUE : GL_FALSE);
00898   }
00899 
00900   inline void GpuRenderStates::HW__SetSeparateAlphaBlendFactors (
00901     t_u32 SrcBlendFactor_,
00902     t_u32 DestBlendFactor_,
00903     t_u32 SrcFactorAlpha_,
00904     t_u32 DestFactorAlpha_)
00905   {
00906     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),
00907                    TEXT ("Error(HW__SetSeparateAlphaBlendFactors): Invalid Blend RenderState") );
00908     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),
00909                    TEXT ("Error(HW__SetSeparateAlphaBlendFactors): Invalid Blend RenderState") );
00910     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),
00911                    TEXT ("Error(HW__SetSeparateAlphaBlendFactors): Invalid Blend RenderState") );
00912     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),
00913                    TEXT ("Error(HW__SetSeparateAlphaBlendFactors): Invalid Blend RenderState") );
00914 
00915     CHECKGL (glBlendFuncSeparate (
00916                SrcBlendFactor_,
00917                DestBlendFactor_,
00918                SrcFactorAlpha_,
00919                DestFactorAlpha_) );
00920 
00921     SET_RS_VALUE (m_RenderStateChanges[GFXRS_SRCBLEND], SrcBlendFactor_);
00922     SET_RS_VALUE (m_RenderStateChanges[GFXRS_DESTBLEND], DestBlendFactor_);
00923     SET_RS_VALUE (m_RenderStateChanges[GFXRS_SRCBLENDALPHA], SrcFactorAlpha_);
00924     SET_RS_VALUE (m_RenderStateChanges[GFXRS_DESTBLENDALPHA], DestFactorAlpha_);
00925   }
00926 
00927   inline void GpuRenderStates::HW__SetAlphaBlendOp (
00928     t_u32 BlendOpRGB_,
00929     t_u32 BlendOpAlpha_)
00930   {
00931     nuxAssertMsg (
00932       (BlendOpRGB_ == GL_FUNC_ADD) ||
00933       (BlendOpRGB_ == GL_FUNC_SUBTRACT) ||
00934       (BlendOpRGB_ == GL_FUNC_REVERSE_SUBTRACT) ||
00935       (BlendOpRGB_ == GL_MIN) ||
00936       (BlendOpRGB_ == GL_MAX),
00937       TEXT ("Error(HW__SetAlphaBlendOp): Invalid Blend Equation RenderState") );
00938     nuxAssertMsg (
00939       (BlendOpAlpha_ == GL_FUNC_ADD) ||
00940       (BlendOpAlpha_ == GL_FUNC_SUBTRACT) ||
00941       (BlendOpAlpha_ == GL_FUNC_REVERSE_SUBTRACT) ||
00942       (BlendOpAlpha_ == GL_MIN) ||
00943       (BlendOpAlpha_ == GL_MAX),
00944       TEXT ("Error(HW__SetAlphaBlendOp): Invalid Blend Equation RenderState") );
00945 
00946     if (_gpu_info->SupportOpenGL20 ())
00947     {
00948       CHECKGL (glBlendEquationSeparate (BlendOpRGB_, BlendOpAlpha_) );
00949     }
00950     else if (_gpu_info->Support_EXT_Blend_Equation_Separate ())
00951     {
00952       CHECKGL (glBlendEquationSeparateEXT (BlendOpRGB_, BlendOpAlpha_) );
00953     }
00954     else
00955     {
00956       CHECKGL (glBlendEquation (BlendOpRGB_) );
00957     }
00958 
00959     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BLENDOP], BlendOpRGB_);
00960     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BLENDOPALPHA], BlendOpAlpha_);
00961   }
00962 
00963   inline void GpuRenderStates::HW__EnableCulling (t_u32 b)
00964   {
00965     if (b)
00966     {
00967       CHECKGL (glEnable (GL_CULL_FACE) );
00968     }
00969     else
00970     {
00971       CHECKGL (glDisable (GL_CULL_FACE) );
00972     }
00973 
00974     SET_RS_VALUE (m_RenderStateChanges[GFXRS_CULLFACEENABLE], b ? GL_TRUE : GL_FALSE);
00975   }
00976 
00977 
00978   inline void GpuRenderStates::HW__SetFrontFace (t_u32 FrontFace_)
00979   {
00980     nuxAssertMsg (
00981       (FrontFace_ == GL_CW) ||
00982       (FrontFace_ == GL_CCW),
00983       TEXT ("Error(HW__SetFrontFace): Invalid Front Face RenderState") );
00984 
00985     CHECKGL (glFrontFace (FrontFace_) );
00986     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONTFACE], FrontFace_);
00987   }
00988 
00989   inline void GpuRenderStates::HW__SetCullFace (t_u32 CullFace_)
00990   {
00991     nuxAssertMsg (
00992       (CullFace_ == GL_FRONT) ||
00993       (CullFace_ == GL_BACK) ||
00994       (CullFace_ == GL_FRONT_AND_BACK),
00995       TEXT ("Error(HW__SetCullFace): Invalid Cull Face RenderState") );
00996 
00997     CHECKGL (glCullFace (CullFace_) );
00998     SET_RS_VALUE (m_RenderStateChanges[GFXRS_CULLFACE], CullFace_);
00999   }
01000 
01001   inline void GpuRenderStates::HW__SetEnableDepthTest (t_u32 b)
01002   {
01003     if (b)
01004     {
01005       CHECKGL (glEnable (GL_DEPTH_TEST) );
01006     }
01007     else
01008     {
01009       CHECKGL (glDisable (GL_DEPTH_TEST) );
01010     }
01011 
01012     SET_RS_VALUE (m_RenderStateChanges[GFXRS_ZTESTENABLE], b ? GL_TRUE : GL_FALSE);
01013   }
01014 
01015   inline void GpuRenderStates::HW__SetDepthRange (float zNear, float zFar)
01016   {
01017     CHECKGL (glDepthRange (zNear, zFar) );
01018     SET_RS_VALUE (m_RenderStateChanges[GFXRS_ZNEAR], static_cast<t_u32> (Clamp (zNear, 0.0f, 1.0f) ) );
01019     SET_RS_VALUE (m_RenderStateChanges[GFXRS_ZFAR], static_cast<t_u32> (Clamp (zFar, 0.0f, 1.0f) ) );
01020   }
01021 
01022   inline void GpuRenderStates::HW__SetDepthFunc (t_u32 Func)
01023   {
01024     nuxAssertMsg (
01025       (Func == GL_NEVER) ||
01026       (Func == GL_LESS) ||
01027       (Func == GL_EQUAL) ||
01028       (Func == GL_LEQUAL) ||
01029       (Func == GL_GREATER) ||
01030       (Func == GL_NOTEQUAL) ||
01031       (Func == GL_GEQUAL) ||
01032       (Func == GL_ALWAYS),
01033       TEXT ("Error(HW__SetDepthFunc): Invalid Depth Func RenderState") );
01034 
01035     CHECKGL (glDepthFunc (Func) );
01036     SET_RS_VALUE (m_RenderStateChanges[GFXRS_ZFUNC], Func);
01037   }
01038 
01039   inline void GpuRenderStates::HW__EnableStencil (t_u32 b)
01040   {
01041     if (b)
01042     {
01043       CHECKGL (glEnable (GL_STENCIL_TEST) );
01044     }
01045     else
01046     {
01047       CHECKGL (glDisable (GL_STENCIL_TEST) );
01048     }
01049 
01050     SET_RS_VALUE (m_RenderStateChanges[GFXRS_STENCILENABLE], b ? GL_TRUE : GL_FALSE);
01051   }
01052 
01053   inline void GpuRenderStates::HW__SetStencilFunc (t_u32 func, int ref, t_u32 mask)
01054   {
01055     nuxAssertMsg (
01056       (func == GL_NEVER) ||
01057       (func == GL_LESS) ||
01058       (func == GL_EQUAL) ||
01059       (func == GL_LEQUAL) ||
01060       (func == GL_GREATER) ||
01061       (func == GL_NOTEQUAL) ||
01062       (func == GL_GEQUAL) ||
01063       (func == GL_ALWAYS),
01064       TEXT ("Error(HW__SetFrontFaceStencilFunc): Invalid Stencil Function RenderState"));
01065 
01066     CHECKGL (glStencilFunc (func, ref, mask));
01067 
01068     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC], func);
01069     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILREF], ref);
01070     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILMASK], mask);
01071   }
01072 
01073   inline void GpuRenderStates::HW__SetStencilOp (t_u32 stencil_fail, t_u32 stencil_pass_depth_fail, t_u32 stencil_pass_depth_pass)
01074   {
01075     nuxAssertMsg (
01076       (stencil_fail == GL_KEEP) ||
01077       (stencil_fail == GL_ZERO) ||
01078       (stencil_fail == GL_REPLACE) ||
01079       (stencil_fail == GL_INCR) ||
01080       (stencil_fail == GL_INCR_WRAP) ||
01081       (stencil_fail == GL_DECR) ||
01082       (stencil_fail == GL_DECR_WRAP) ||
01083       (stencil_fail == GL_INVERT),
01084       TEXT ("Error(HW__SetFrontFaceStencilOp): Invalid FailOp RenderState"));
01085 
01086     nuxAssertMsg (
01087       (stencil_pass_depth_fail == GL_KEEP) ||
01088       (stencil_pass_depth_fail == GL_ZERO) ||
01089       (stencil_pass_depth_fail == GL_REPLACE) ||
01090       (stencil_pass_depth_fail == GL_INCR) ||
01091       (stencil_pass_depth_fail == GL_INCR_WRAP) ||
01092       (stencil_pass_depth_fail == GL_DECR) ||
01093       (stencil_pass_depth_fail == GL_DECR_WRAP) ||
01094       (stencil_pass_depth_fail == GL_INVERT),
01095       TEXT ("Error(HW__SetFrontFaceStencilOp): Invalid ZFailOp RenderState"));
01096 
01097     nuxAssertMsg (
01098       (stencil_pass_depth_pass == GL_KEEP) ||
01099       (stencil_pass_depth_pass == GL_ZERO) ||
01100       (stencil_pass_depth_pass == GL_REPLACE) ||
01101       (stencil_pass_depth_pass == GL_INCR) ||
01102       (stencil_pass_depth_pass == GL_INCR_WRAP) ||
01103       (stencil_pass_depth_pass == GL_DECR) ||
01104       (stencil_pass_depth_pass == GL_DECR_WRAP) ||
01105       (stencil_pass_depth_pass == GL_INVERT),
01106       TEXT ("Error(HW__SetFrontFaceStencilOp): Invalid ZPassOp RenderState"));
01107 
01108     CHECKGL (glStencilOp (stencil_fail, stencil_pass_depth_fail, stencil_pass_depth_pass));
01109 
01110     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL], stencil_fail);
01111     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL], stencil_pass_depth_fail);
01112     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS], stencil_pass_depth_pass);
01113   }
01114 
01115 #if 0
01116   inline void GpuRenderStates::HW__EnableTwoSidedStencil (t_u32 b)
01117   {
01118     if (b)
01119     {
01120       if (_gpu_brand == GPU_BRAND_AMD)
01121       {
01122         CHECKGL (glEnable (GL_STENCIL_TEST) );
01123       }
01124       else
01125       {
01126         CHECKGL (glEnable (GL_STENCIL_TEST_TWO_SIDE_EXT) );
01127       }
01128     }
01129     else
01130     {
01131       if (_gpu_brand == GPU_BRAND_AMD)
01132       {
01133         CHECKGL (glDisable (GL_STENCIL_TEST) );
01134       }
01135       else
01136       {
01137         CHECKGL (glDisable (GL_STENCIL_TEST_TWO_SIDE_EXT) );
01138       }
01139     }
01140 
01141     SET_RS_VALUE (m_RenderStateChanges[GFXRS_TWOSIDEDSTENCILENABLE], b ? GL_TRUE : GL_FALSE);
01142   }
01143 
01144   inline void GpuRenderStates::HW__SetStencilFrontFaceWriteMask (t_u32 WriteMask_)
01145   {
01146     CHECKGL (glActiveStencilFaceEXT (GL_FRONT) );
01147     CHECKGL (glStencilMask (WriteMask_) );
01148     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILWRITEMASK], WriteMask_);
01149   }
01150 
01151   inline void GpuRenderStates::HW__SetStencilBackFaceWriteMask (t_u32 WriteMask_)
01152   {
01153     CHECKGL (glActiveStencilFaceEXT (GL_BACK) );
01154     CHECKGL (glStencilMask (WriteMask_) );
01155     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILWRITEMASK], WriteMask_);
01156   }
01157 
01158   inline void GpuRenderStates::HW__SetFrontFaceStencilFunc (t_u32 Func_,
01159       t_u32 Ref_,
01160       t_u32 Mask_)
01161   {
01162     nuxAssertMsg (
01163       (Func_ == GL_NEVER) ||
01164       (Func_ == GL_LESS) ||
01165       (Func_ == GL_EQUAL) ||
01166       (Func_ == GL_LEQUAL) ||
01167       (Func_ == GL_GREATER) ||
01168       (Func_ == GL_NOTEQUAL) ||
01169       (Func_ == GL_GEQUAL) ||
01170       (Func_ == GL_ALWAYS),
01171       TEXT ("Error(HW__SetFrontFaceStencilFunc): Invalid Stencil Function RenderState") );
01172 
01173     CHECKGL (glActiveStencilFaceEXT (GL_FRONT) );
01174     CHECKGL (glStencilFunc (Func_, Ref_, Mask_) );
01175 
01176     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC], Func_);
01177     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILREF], Ref_);
01178     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILMASK], Mask_);
01179   }
01180 
01181   inline void GpuRenderStates::HW__SetBackFaceStencilFunc (
01182     t_u32 Func_,
01183     t_u32 Ref_,
01184     t_u32 Mask_)
01185   {
01186     nuxAssertMsg (
01187       (Func_ == GL_NEVER) ||
01188       (Func_ == GL_LESS) ||
01189       (Func_ == GL_EQUAL) ||
01190       (Func_ == GL_LEQUAL) ||
01191       (Func_ == GL_GREATER) ||
01192       (Func_ == GL_NOTEQUAL) ||
01193       (Func_ == GL_GEQUAL) ||
01194       (Func_ == GL_ALWAYS),
01195       TEXT ("Error(HW__SetBackFaceStencilFunc): Invalid Stencil Function RenderState") );
01196 
01197     if (_gpu_brand == GPU_BRAND_AMD)
01198     {
01199       CHECKGL (glStencilFuncSeparateATI (Func_/*Front function*/, Func_/*Back function*/, Ref_, Mask_) ); // incorrect
01200     }
01201     else
01202     {
01203       CHECKGL (glActiveStencilFaceEXT (GL_BACK) );
01204       CHECKGL (glStencilFunc (Func_, Ref_, Mask_) );
01205     }
01206 
01207     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILFUNC], Func_);
01208     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILREF], Ref_);
01209     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILMASK], Mask_);
01210   }
01211 
01212   inline void GpuRenderStates::HW__SetFrontFaceStencilOp (
01213     t_u32 FailOp_,
01214     t_u32 ZFailOp_,
01215     t_u32 ZPassOp_)
01216   {
01217     nuxAssertMsg (
01218       (FailOp_ == GL_KEEP) ||
01219       (FailOp_ == GL_ZERO) ||
01220       (FailOp_ == GL_REPLACE) ||
01221       (FailOp_ == GL_INCR) ||
01222       (FailOp_ == GL_INCR_WRAP) ||
01223       (FailOp_ == GL_DECR) ||
01224       (FailOp_ == GL_DECR_WRAP) ||
01225       (FailOp_ == GL_INVERT),
01226       TEXT ("Error(HW__SetFrontFaceStencilOp): Invalid FailOp RenderState") );
01227 
01228     nuxAssertMsg (
01229       (ZFailOp_ == GL_KEEP) ||
01230       (ZFailOp_ == GL_ZERO) ||
01231       (ZFailOp_ == GL_REPLACE) ||
01232       (ZFailOp_ == GL_INCR) ||
01233       (ZFailOp_ == GL_INCR_WRAP) ||
01234       (ZFailOp_ == GL_DECR) ||
01235       (ZFailOp_ == GL_DECR_WRAP) ||
01236       (ZFailOp_ == GL_INVERT),
01237       TEXT ("Error(HW__SetFrontFaceStencilOp): Invalid ZFailOp RenderState") );
01238 
01239     nuxAssertMsg (
01240       (ZPassOp_ == GL_KEEP) ||
01241       (ZPassOp_ == GL_ZERO) ||
01242       (ZPassOp_ == GL_REPLACE) ||
01243       (ZPassOp_ == GL_INCR) ||
01244       (ZPassOp_ == GL_INCR_WRAP) ||
01245       (ZPassOp_ == GL_DECR) ||
01246       (ZPassOp_ == GL_DECR_WRAP) ||
01247       (ZPassOp_ == GL_INVERT),
01248       TEXT ("Error(HW__SetFrontFaceStencilOp): Invalid ZPassOp RenderState") );
01249 
01250     if (_gpu_brand == GPU_BRAND_AMD)
01251     {
01252       CHECKGL (glStencilOpSeparateATI (GL_FRONT, FailOp_, ZFailOp_, ZPassOp_) );
01253     }
01254     else
01255     {
01256       CHECKGL (glActiveStencilFaceEXT (GL_FRONT) );
01257       CHECKGL (glStencilOp (FailOp_, ZFailOp_, ZPassOp_) );
01258     }
01259 
01260     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL], FailOp_);
01261     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL], ZFailOp_);
01262     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS], ZPassOp_);
01263   }
01264 
01265   inline void GpuRenderStates::HW__SetBackFaceStencilOp (
01266     t_u32 FailOp_,
01267     t_u32 ZFailOp_,
01268     t_u32 ZPassOp_)
01269   {
01270     nuxAssertMsg (
01271       (FailOp_ == GL_KEEP) ||
01272       (FailOp_ == GL_ZERO) ||
01273       (FailOp_ == GL_REPLACE) ||
01274       (FailOp_ == GL_INCR) ||
01275       (FailOp_ == GL_INCR_WRAP) ||
01276       (FailOp_ == GL_DECR) ||
01277       (FailOp_ == GL_DECR_WRAP) ||
01278       (FailOp_ == GL_INVERT),
01279       TEXT ("Error(HW__SetBackFaceStencilOp): Invalid FailOp RenderState") );
01280 
01281     nuxAssertMsg (
01282       (ZFailOp_ == GL_KEEP) ||
01283       (ZFailOp_ == GL_ZERO) ||
01284       (ZFailOp_ == GL_REPLACE) ||
01285       (ZFailOp_ == GL_INCR) ||
01286       (ZFailOp_ == GL_INCR_WRAP) ||
01287       (ZFailOp_ == GL_DECR) ||
01288       (ZFailOp_ == GL_DECR_WRAP) ||
01289       (ZFailOp_ == GL_INVERT),
01290       TEXT ("Error(HW__SetBackFaceStencilOp): Invalid ZFailOp RenderState") );
01291 
01292     nuxAssertMsg (
01293       (ZPassOp_ == GL_KEEP) ||
01294       (ZPassOp_ == GL_ZERO) ||
01295       (ZPassOp_ == GL_REPLACE) ||
01296       (ZPassOp_ == GL_INCR) ||
01297       (ZPassOp_ == GL_INCR_WRAP) ||
01298       (ZPassOp_ == GL_DECR) ||
01299       (ZPassOp_ == GL_DECR_WRAP) ||
01300       (ZPassOp_ == GL_INVERT),
01301       TEXT ("Error(HW__SetBackFaceStencilOp): Invalid ZPassOp RenderState") );
01302 
01303     if (_gpu_brand == GPU_BRAND_AMD)
01304     {
01305       CHECKGL (glStencilOpSeparateATI (GL_BACK, FailOp_, ZFailOp_, ZPassOp_) );
01306     }
01307     else
01308     {
01309       CHECKGL (glActiveStencilFaceEXT (GL_BACK) );
01310       CHECKGL (glStencilOp (FailOp_, ZFailOp_, ZPassOp_) );
01311     }
01312 
01313     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILFAIL], FailOp_);
01314     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILZFAIL], ZFailOp_);
01315     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILZPASS], ZPassOp_);
01316   }
01317 #endif
01318 
01319   inline void GpuRenderStates::HW__EnableLineSmooth (t_u32 EnableLineSmooth)
01320   {
01321     if (EnableLineSmooth)
01322     {
01323       CHECKGL (glEnable (GL_LINE_SMOOTH) );
01324     }
01325     else
01326     {
01327       CHECKGL (glDisable (GL_LINE_SMOOTH) );
01328     }
01329 
01330     SET_RS_VALUE (m_RenderStateChanges[GFXRS_LINESMOOTHENABLE], EnableLineSmooth ? GL_TRUE : GL_FALSE);
01331   }
01332 
01333   inline void GpuRenderStates::HW__SetLineWidth (t_u32 width,  t_u32 Hint)
01334   {
01335     nuxAssertMsg (
01336       (Hint == GL_NICEST) ||
01337       (Hint == GL_FASTEST) ||
01338       (Hint == GL_DONT_CARE),
01339       TEXT ("Error(HW__SetLineWidth): Invalid Line Hint RenderState") );
01340 
01341     CHECKGL (glLineWidth (width) );
01342     CHECKGL (glHint (GL_LINE_SMOOTH_HINT, Hint) );
01343     SET_RS_VALUE (m_RenderStateChanges[GFXRS_LINEWIDTH], width);
01344     SET_RS_VALUE (m_RenderStateChanges[GFXRS_LINEHINT], Hint);
01345   }
01346 
01347   inline void GpuRenderStates::HW__EnablePointSmooth (t_u32 EnablePointSmooth)
01348   {
01349     if (EnablePointSmooth)
01350     {
01351       CHECKGL (glEnable (GL_POINT_SMOOTH) );
01352     }
01353     else
01354     {
01355       CHECKGL (glDisable (GL_POINT_SMOOTH) );
01356     }
01357 
01358     SET_RS_VALUE (m_RenderStateChanges[GFXRS_POINTSMOOTHENABLE], EnablePointSmooth ? GL_TRUE : GL_FALSE);
01359   }
01360 
01361   inline void GpuRenderStates::HW__SetPointSize (t_u32 size,  t_u32 Hint)
01362   {
01363     nuxAssertMsg (
01364       (Hint == GL_NICEST) ||
01365       (Hint == GL_FASTEST) ||
01366       (Hint == GL_DONT_CARE),
01367       TEXT ("Error(HW__SetPointSize): Invalid Point Hint RenderState") );
01368 
01369     CHECKGL (glPointSize (size) );
01370     CHECKGL (glHint (GL_POINT_SMOOTH_HINT, Hint);)
01371     SET_RS_VALUE (m_RenderStateChanges[GFXRS_POINTSIZE], size);
01372     SET_RS_VALUE (m_RenderStateChanges[GFXRS_POINTHINT], Hint);
01373   }
01374 
01375   inline void GpuRenderStates::HW__SetColorMask (
01376     t_u32 bRed,
01377     t_u32 bGreen,
01378     t_u32 bBlue,
01379     t_u32 bAlpha)
01380   {
01381     CHECKGL (glColorMask (bRed, bGreen, bBlue, bAlpha) );
01382     SET_RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_R], bRed);
01383     SET_RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_G], bGreen);
01384     SET_RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_B], bBlue);
01385     SET_RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_A], bAlpha);
01386   }
01387 
01388   inline void GpuRenderStates::HW__SetDepthMask (t_u32 bDepth)
01389   {
01390     CHECKGL (glDepthMask (bDepth) );
01391     SET_RS_VALUE (m_RenderStateChanges[GFXRS_ZWRITEENABLE], bDepth);
01392   }
01393 
01394   inline void GpuRenderStates::HW__EnableScissor (t_u32 bScissor)
01395   {
01396     if (bScissor)
01397     {
01398       CHECKGL (glEnable (GL_SCISSOR_TEST) );
01399     }
01400     else
01401     {
01402       CHECKGL (glDisable (GL_SCISSOR_TEST) );
01403     }
01404 
01405     SET_RS_VALUE (m_RenderStateChanges[GFXRS_SCISSORTESTENABLE], bScissor ? GL_TRUE : GL_FALSE);
01406   }
01407 
01408   inline void GpuRenderStates::HW__EnableFog (t_u32 bFog)
01409   {
01410     if (bFog)
01411     {
01412       CHECKGL (glEnable (GL_FOG) );
01413     }
01414     else
01415     {
01416       CHECKGL (glDisable (GL_FOG) );
01417     }
01418 
01419     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FOGENABLE], bFog ? GL_TRUE : GL_FALSE);
01420   }
01421 
01422   inline void GpuRenderStates::HW__SetPolygonMode (t_u32 FrontMode, t_u32 BackMode)
01423   {
01424     nuxAssertMsg (
01425       (FrontMode == GL_FILL) ||
01426       (FrontMode == GL_LINE) ||
01427       (FrontMode == GL_POINT),
01428       TEXT ("Error(HW__SetPolygonMode): Invalid Point Hint RenderState") );
01429 
01430     nuxAssertMsg (
01431       (BackMode == GL_FILL) ||
01432       (BackMode == GL_LINE) ||
01433       (BackMode == GL_POINT),
01434       TEXT ("Error(HW__SetPolygonMode): Invalid Point Hint RenderState") );
01435 
01436     CHECKGL (glPolygonMode (GL_FRONT, FrontMode) );
01437     CHECKGL (glPolygonMode (GL_BACK, BackMode) );
01438 
01439     SET_RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_POLYGONMODE], FrontMode);
01440     SET_RS_VALUE (m_RenderStateChanges[GFXRS_BACK_POLYGONMODE], BackMode);
01441   }
01442 
01443   inline void GpuRenderStates::HW__EnablePolygonOffset (t_u32 EnablePolygonOffset)
01444   {
01445     if (EnablePolygonOffset)
01446     {
01447       CHECKGL (glEnable (GL_POLYGON_OFFSET_FILL) );
01448     }
01449     else
01450     {
01451       CHECKGL (glDisable (GL_POLYGON_OFFSET_FILL) );
01452     }
01453 
01454     SET_RS_VALUE (m_RenderStateChanges[GL_POLYGON_OFFSET_FILL], EnablePolygonOffset ? GL_TRUE : GL_FALSE);
01455   }
01456 
01457   inline void GpuRenderStates::HW__SetPolygonOffset (float Factor, float Units)
01458   {
01459     CHECKGL (glPolygonOffset (Factor, Units) );
01460 
01461     SET_RS_VALUE (m_RenderStateChanges[GFXRS_POLYGONOFFSETFACTOR], static_cast<t_u32> (Factor) );
01462     SET_RS_VALUE (m_RenderStateChanges[GFXRS_POLYGONOFFSETUNITS], static_cast<t_u32> (Units) );
01463   }
01464 
01465 #undef SET_RS_VALUE
01466 #undef RS_VALUE
01467 
01468 //#undef SET_RS_VALUE_FLOAT
01469 //#undef RS_VALUE_FLOAT
01470 
01471 }
01472 
01473 #endif // GLRENDERSTATES_H
01474 
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends