nux-1.14.0
GLRenderStates.cpp
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 #include "GLResource.h"
00024 #include "GLRenderStates.h"
00025 
00026 namespace nux
00027 {
00028 
00029   const struct StateLookUpTable
00030   {
00031     StateLookUpTable()
00032     {
00033       // setup render state map
00034 #define UL_MAP(state__, default_value__, checked__)                         \
00035         default_render_state[GFXRS_##state__].iValue     = default_value__;      \
00036         default_render_state[GFXRS_##state__].Checked   = checked__;
00037 
00038 #define UL_MAP_FLOAT(state__, default_value__, checked__)                         \
00039     default_render_state[GFXRS_##state__].fValue     = default_value__;      \
00040     default_render_state[GFXRS_##state__].Checked   = checked__;            \
00041  
00042 
00043       UL_MAP (FRONT_POLYGONMODE            ,           GL_FILL         ,       1);
00044       UL_MAP (BACK_POLYGONMODE             ,           GL_FILL         ,       1);
00045       UL_MAP (CULLFACEENABLE               ,           GL_FALSE        ,       1);
00046       UL_MAP (CULLFACE                     ,           GL_BACK         ,       1);
00047       UL_MAP (FRONTFACE                    ,           GL_CCW          ,       1);
00048 
00049       UL_MAP (SCISSORTESTENABLE            ,           GL_FALSE        ,       1);
00050       UL_MAP (FOGENABLE                    ,           GL_FALSE        ,       1);
00051 
00052       UL_MAP (ZTESTENABLE                  ,           GL_FALSE        ,       1);
00053       UL_MAP (ZWRITEENABLE                 ,           GL_TRUE         ,       1);
00054       UL_MAP (ZFUNC                        ,           GL_LESS         ,       1);
00055       UL_MAP_FLOAT (ZNEAR                  ,           static_cast<t_u32> (0.0f)            ,       1);
00056       UL_MAP_FLOAT (ZFAR                   ,           static_cast<t_u32> (1.0f)            ,       1);
00057 
00058       UL_MAP (ALPHABLENDENABLE             ,           GL_FALSE        ,       1);
00059       UL_MAP (BLENDOP                      ,           GL_FUNC_ADD     ,       1);
00060       UL_MAP (BLENDOPALPHA                 ,           GL_FUNC_ADD     ,       1);
00061       UL_MAP (SRCBLEND                     ,           GL_ONE          ,       1);
00062       UL_MAP (DESTBLEND                    ,           GL_ZERO         ,       1);
00063       UL_MAP (SRCBLENDALPHA                ,           GL_ONE          ,       1);
00064       UL_MAP (DESTBLENDALPHA               ,           GL_ZERO         ,       1);
00065 
00066       UL_MAP (ALPHATESTENABLE              ,           GL_FALSE        ,       1);
00067       UL_MAP (ALPHATESTREF                 ,           0x0             ,       1);
00068       UL_MAP (ALPHATESTFUNC                ,           GL_ALWAYS       ,       1);
00069 
00070       UL_MAP (STENCILENABLE                ,           GL_FALSE        ,       1);
00071       UL_MAP (TWOSIDEDSTENCILENABLE        ,           GL_FALSE        ,       1);
00072       UL_MAP (FRONT_STENCILWRITEMASK       ,           0xFFFFFFFF      ,       1);
00073       UL_MAP (BACK_STENCILWRITEMASK        ,           0xFFFFFFFF      ,       1);
00074 
00075       UL_MAP (FRONT_STENCILFUNC            ,           GL_ALWAYS       ,       1);
00076       UL_MAP (FRONT_STENCILREF             ,           0x0             ,       1);
00077       UL_MAP (FRONT_STENCILMASK            ,           0xFF            ,       1);
00078       UL_MAP (FRONT_STENCILFAIL            ,           GL_KEEP         ,       1);
00079       UL_MAP (FRONT_STENCILZFAIL           ,           GL_KEEP         ,       1);
00080       UL_MAP (FRONT_STENCILZPASS           ,           GL_KEEP         ,       1);
00081 
00082       UL_MAP (BACK_STENCILFUNC             ,           GL_ALWAYS       ,       1);
00083       UL_MAP (BACK_STENCILREF              ,           0x0             ,       1);
00084       UL_MAP (BACK_STENCILMASK             ,           0xFF            ,       1);
00085       UL_MAP (BACK_STENCILFAIL             ,           GL_KEEP         ,       1);
00086       UL_MAP (BACK_STENCILZFAIL            ,           GL_KEEP         ,       1);
00087       UL_MAP (BACK_STENCILZPASS            ,           GL_KEEP         ,       1);
00088 
00089 
00090       UL_MAP (POINTSMOOTHENABLE            ,           GL_FALSE        ,       1);
00091       UL_MAP (LINESMOOTHENABLE             ,           GL_FALSE        ,       1);
00092       UL_MAP (POINTSIZE                    ,           1               ,       1);
00093       UL_MAP (LINEWIDTH                    ,           1               ,       1);
00094       UL_MAP (POINTHINT                    ,           GL_FASTEST      ,       1);
00095       UL_MAP (LINEHINT                     ,           GL_FASTEST      ,       1);
00096 
00097       UL_MAP (COLORWRITEENABLE_R           ,           GL_TRUE         ,       1);
00098       UL_MAP (COLORWRITEENABLE_G           ,           GL_TRUE         ,       1);
00099       UL_MAP (COLORWRITEENABLE_B           ,           GL_TRUE         ,       1);
00100       UL_MAP (COLORWRITEENABLE_A           ,           GL_TRUE         ,       1);
00101 
00102 #undef UL_MAP
00103 #undef UL_MAP_FLOAT
00104     };
00105 
00106     RenderStateMap default_render_state[GFXRS_MAX_RENDERSTATES];
00107     RenderStateMap sampler_state_map[GFXSS_MAX_SAMPLERSTATES];
00108 
00109   } s_StateLUT;
00110 
00111 
00112   GpuRenderStates::GpuRenderStates (GpuBrand board, GpuInfo* info)
00113   {
00114     _gpu_brand = board;
00115     _gpu_info = info;
00116     Memcpy (&m_RenderStateChanges, &s_StateLUT.default_render_state, sizeof (m_RenderStateChanges) );
00117   }
00118 
00119   GpuRenderStates::~GpuRenderStates()
00120   {
00121 
00122   }
00123 
00124   void GpuRenderStates::ResetDefault()
00125   {
00126     HW__EnableCulling ( s_StateLUT.default_render_state[GFXRS_CULLFACEENABLE].iValue );
00127     HW__SetFrontFace ( s_StateLUT.default_render_state[GFXRS_FRONTFACE].iValue );
00128     HW__SetCullFace ( s_StateLUT.default_render_state[GFXRS_CULLFACE].iValue );
00129 
00130     HW__SetDepthMask ( s_StateLUT.default_render_state[GFXRS_ZWRITEENABLE].iValue );
00131     HW__SetDepthFunc ( s_StateLUT.default_render_state[GFXRS_ZFUNC].iValue );
00132     HW__SetEnableDepthTest ( s_StateLUT.default_render_state[GFXRS_ZTESTENABLE].iValue );
00133     HW__SetDepthRange ( s_StateLUT.default_render_state[GFXRS_ZNEAR].fValue, s_StateLUT.default_render_state[GFXRS_ZFAR].fValue );
00134 
00135     HW__EnableAlphaBlend ( s_StateLUT.default_render_state[GFXRS_ALPHABLENDENABLE].iValue );
00136     HW__SetAlphaBlendOp ( s_StateLUT.default_render_state[GFXRS_BLENDOP].iValue, s_StateLUT.default_render_state[GFXRS_BLENDOPALPHA].iValue );
00137     HW__SetSeparateAlphaBlendFactors (
00138       s_StateLUT.default_render_state[GFXRS_SRCBLEND].iValue, s_StateLUT.default_render_state[GFXRS_DESTBLEND].iValue,
00139       s_StateLUT.default_render_state[GFXRS_SRCBLENDALPHA].iValue, s_StateLUT.default_render_state[GFXRS_DESTBLENDALPHA ].iValue );
00140 
00141 
00142     HW__EnableAlphaTest ( s_StateLUT.default_render_state[GFXRS_ALPHATESTENABLE].iValue );
00143     HW__SetAlphaTestFunc ( s_StateLUT.default_render_state[GFXRS_ALPHATESTFUNC].iValue, s_StateLUT.default_render_state[GFXRS_ALPHATESTREF].iValue );
00144 
00145 
00146     HW__EnableStencil ( s_StateLUT.default_render_state[GFXRS_STENCILENABLE].iValue );
00147     HW__SetStencilFunc (
00148       s_StateLUT.default_render_state[GFXRS_FRONT_STENCILFUNC].iValue,
00149       s_StateLUT.default_render_state[GFXRS_FRONT_STENCILREF].iValue,
00150       s_StateLUT.default_render_state[GFXRS_FRONT_STENCILMASK].iValue);
00151     HW__SetStencilOp (
00152       s_StateLUT.default_render_state[GFXRS_FRONT_STENCILFAIL].iValue,
00153       s_StateLUT.default_render_state[GFXRS_FRONT_STENCILZFAIL].iValue,
00154       s_StateLUT.default_render_state[GFXRS_FRONT_STENCILZPASS].iValue);
00155 
00156 #if 0
00157     HW__EnableTwoSidedStencil ( s_StateLUT.default_render_state[GFXRS_TWOSIDEDSTENCILENABLE].iValue );
00158 
00159     HW__SetFrontFaceStencilFunc (
00160       s_StateLUT.default_render_state[GFXRS_FRONT_STENCILFUNC].iValue,
00161       s_StateLUT.default_render_state[GFXRS_FRONT_STENCILREF].iValue,
00162       s_StateLUT.default_render_state[GFXRS_FRONT_STENCILMASK].iValue );
00163     HW__SetFrontFaceStencilOp (
00164       s_StateLUT.default_render_state[GFXRS_FRONT_STENCILFAIL].iValue,
00165       s_StateLUT.default_render_state[GFXRS_FRONT_STENCILZFAIL].iValue,
00166       s_StateLUT.default_render_state[GFXRS_FRONT_STENCILZPASS].iValue );
00167 
00168     HW__SetBackFaceStencilFunc (
00169       s_StateLUT.default_render_state[GFXRS_BACK_STENCILFUNC].iValue,
00170       s_StateLUT.default_render_state[GFXRS_BACK_STENCILREF].iValue,
00171       s_StateLUT.default_render_state[GFXRS_BACK_STENCILMASK].iValue );
00172     HW__SetBackFaceStencilOp (
00173       s_StateLUT.default_render_state[GFXRS_BACK_STENCILFAIL].iValue,
00174       s_StateLUT.default_render_state[GFXRS_BACK_STENCILZFAIL].iValue,
00175       s_StateLUT.default_render_state[GFXRS_BACK_STENCILZPASS].iValue );
00176 #endif
00177 
00178     HW__EnableScissor ( s_StateLUT.default_render_state[GFXRS_SCISSORTESTENABLE].iValue );
00179 
00180     HW__EnableFog ( s_StateLUT.default_render_state[GFXRS_FOGENABLE].iValue );
00181   }
00182 
00183   void GpuRenderStates::SubmitChangeStates()
00184   {
00185     HW__EnableCulling ( m_RenderStateChanges[GFXRS_CULLFACEENABLE].iValue );
00186     HW__SetFrontFace ( m_RenderStateChanges[GFXRS_FRONTFACE].iValue );
00187     HW__SetCullFace ( m_RenderStateChanges[GFXRS_CULLFACE].iValue );
00188 
00189     HW__SetDepthMask ( m_RenderStateChanges[GFXRS_ZWRITEENABLE].iValue );
00190     HW__SetDepthFunc ( m_RenderStateChanges[GFXRS_ZFUNC].iValue );
00191     HW__SetEnableDepthTest ( m_RenderStateChanges[GFXRS_ZTESTENABLE].iValue );
00192     HW__SetDepthRange ( m_RenderStateChanges[GFXRS_ZNEAR].fValue, m_RenderStateChanges[GFXRS_ZFAR].fValue );
00193 
00194     HW__EnableAlphaBlend ( m_RenderStateChanges[GFXRS_ALPHABLENDENABLE].iValue );
00195     HW__SetAlphaBlendOp ( m_RenderStateChanges[GFXRS_BLENDOP].iValue, m_RenderStateChanges[GFXRS_BLENDOPALPHA].iValue );
00196     HW__SetSeparateAlphaBlendFactors (
00197       m_RenderStateChanges[GFXRS_SRCBLEND].iValue, m_RenderStateChanges[GFXRS_DESTBLEND].iValue,
00198       m_RenderStateChanges[GFXRS_SRCBLENDALPHA].iValue, m_RenderStateChanges[GFXRS_DESTBLENDALPHA ].iValue );
00199 
00200 
00201     HW__EnableAlphaTest ( m_RenderStateChanges[GFXRS_ALPHATESTENABLE].iValue );
00202     HW__SetAlphaTestFunc ( m_RenderStateChanges[GFXRS_ALPHATESTFUNC].iValue, m_RenderStateChanges[GFXRS_ALPHATESTREF].iValue );
00203 
00204 
00205     HW__EnableStencil ( m_RenderStateChanges[GFXRS_STENCILENABLE].iValue );
00206 
00207     HW__SetStencilFunc (
00208       s_StateLUT.default_render_state[GFXRS_FRONT_STENCILFUNC].iValue,
00209       s_StateLUT.default_render_state[GFXRS_FRONT_STENCILREF].iValue,
00210       s_StateLUT.default_render_state[GFXRS_FRONT_STENCILMASK].iValue);
00211     HW__SetStencilOp (
00212       s_StateLUT.default_render_state[GFXRS_FRONT_STENCILFAIL].iValue,
00213       s_StateLUT.default_render_state[GFXRS_FRONT_STENCILZFAIL].iValue,
00214       s_StateLUT.default_render_state[GFXRS_FRONT_STENCILZPASS].iValue);
00215 
00216 #if 0
00217     HW__EnableTwoSidedStencil ( s_StateLUT.default_render_state[GFXRS_TWOSIDEDSTENCILENABLE].iValue );
00218 
00219     HW__SetFrontFaceStencilFunc (
00220       m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC].iValue,
00221       m_RenderStateChanges[GFXRS_FRONT_STENCILREF].iValue,
00222       m_RenderStateChanges[GFXRS_FRONT_STENCILMASK].iValue );
00223     HW__SetFrontFaceStencilOp (
00224       m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL].iValue,
00225       m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL].iValue,
00226       m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS].iValue );
00227 
00228     HW__SetBackFaceStencilFunc (
00229       m_RenderStateChanges[GFXRS_BACK_STENCILFUNC].iValue,
00230       m_RenderStateChanges[GFXRS_BACK_STENCILREF].iValue,
00231       m_RenderStateChanges[GFXRS_BACK_STENCILMASK].iValue );
00232     HW__SetBackFaceStencilOp (
00233       m_RenderStateChanges[GFXRS_BACK_STENCILFAIL].iValue,
00234       m_RenderStateChanges[GFXRS_BACK_STENCILZFAIL].iValue,
00235       m_RenderStateChanges[GFXRS_BACK_STENCILZPASS].iValue );
00236 #endif
00237 
00238     HW__EnableScissor ( m_RenderStateChanges[GFXRS_SCISSORTESTENABLE].iValue );
00239 
00240     HW__EnableFog ( m_RenderStateChanges[GFXRS_FOGENABLE].iValue );
00241 
00242   }
00243 
00244   void GpuRenderStates::ResetStateChangeToDefault()
00245   {
00246     for (t_u32 i = 0; i < GFXRS_MAX_RENDERSTATES; i++)
00247     {
00248       if (m_RenderStateChanges[i].Checked &&
00249           ( (m_RenderStateChanges[i].iValue != s_StateLUT.default_render_state[i].iValue) ||
00250             (m_RenderStateChanges[i].fValue != s_StateLUT.default_render_state[i].fValue) ) )
00251       {
00252         m_RenderStateChanges[i].iValue = s_StateLUT.default_render_state[i].iValue;
00253         m_RenderStateChanges[i].fValue = s_StateLUT.default_render_state[i].fValue;
00254       }
00255     }
00256   }
00257 
00258   void GpuRenderStates::CheckStateChange()
00259   {
00260     for (t_u32 i = 0; i < GFXRS_MAX_RENDERSTATES; i++)
00261     {
00262       if (m_RenderStateChanges[i].Checked &&
00263           ( (m_RenderStateChanges[i].iValue != s_StateLUT.default_render_state[i].iValue) ||
00264             (m_RenderStateChanges[i].fValue != s_StateLUT.default_render_state[i].fValue) ) )
00265       {
00266         m_RenderStateChanges[i].iValue = s_StateLUT.default_render_state[i].iValue;
00267         m_RenderStateChanges[i].fValue = s_StateLUT.default_render_state[i].fValue;
00268         nuxError (TEXT ("[GpuRenderStates::Check] Render state doesn't have default value") );
00269       }
00270     }
00271   }
00272 
00273   void GpuRenderStates::SetRenderStates (t_u32 rs, t_u32 value)
00274   {
00275 #define RS_VALUE(a)      (a).iValue
00276 
00277     if (value != m_RenderStateChanges[rs].iValue)
00278     {
00279       m_RenderStateChanges[rs].iValue = static_cast<t_u32> (value);
00280 
00281       if (rs == GFXRS_ALPHATESTENABLE ||
00282           rs == GFXRS_ALPHATESTREF ||
00283           rs == GFXRS_ALPHATESTFUNC)
00284       {
00285         HW__EnableAlphaTest (RS_VALUE (m_RenderStateChanges[GFXRS_ALPHATESTENABLE]) );
00286         HW__SetAlphaTestFunc (
00287           RS_VALUE (m_RenderStateChanges[GFXRS_ALPHATESTFUNC]),
00288           RS_VALUE (m_RenderStateChanges[GFXRS_ALPHATESTREF]) );
00289       }
00290 
00291       if (rs == GFXRS_STENCILENABLE          ||
00292           rs == GFXRS_TWOSIDEDSTENCILENABLE ||
00293           rs == GFXRS_FRONT_STENCILFAIL           ||
00294           rs == GFXRS_FRONT_STENCILZFAIL          ||
00295           rs == GFXRS_FRONT_STENCILZPASS           ||
00296           rs == GFXRS_FRONT_STENCILFUNC           ||
00297           rs == GFXRS_FRONT_STENCILREF            ||
00298           rs == GFXRS_FRONT_STENCILMASK           ||
00299           rs == GFXRS_FRONT_STENCILWRITEMASK      ||
00300           rs == GFXRS_BACK_STENCILFAIL           ||
00301           rs == GFXRS_BACK_STENCILZFAIL          ||
00302           rs == GFXRS_BACK_STENCILZPASS           ||
00303           rs == GFXRS_BACK_STENCILFUNC           ||
00304           rs == GFXRS_BACK_STENCILREF            ||
00305           rs == GFXRS_BACK_STENCILMASK           ||
00306           rs == GFXRS_BACK_STENCILWRITEMASK)
00307       {
00308         HW__EnableStencil (RS_VALUE (m_RenderStateChanges[GFXRS_STENCILENABLE]) );
00309 
00310         HW__SetStencilFunc (
00311           s_StateLUT.default_render_state[GFXRS_FRONT_STENCILFUNC].iValue,
00312           s_StateLUT.default_render_state[GFXRS_FRONT_STENCILREF].iValue,
00313           s_StateLUT.default_render_state[GFXRS_FRONT_STENCILMASK].iValue);
00314         HW__SetStencilOp (
00315           s_StateLUT.default_render_state[GFXRS_FRONT_STENCILFAIL].iValue,
00316           s_StateLUT.default_render_state[GFXRS_FRONT_STENCILZFAIL].iValue,
00317           s_StateLUT.default_render_state[GFXRS_FRONT_STENCILZPASS].iValue);
00318 
00319 #if 0
00320         HW__EnableTwoSidedStencil (RS_VALUE (m_RenderStateChanges[GFXRS_TWOSIDEDSTENCILENABLE]) );
00321 
00322         HW__SetFrontFaceStencilFunc (
00323           RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILFUNC]),
00324           RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILREF]),
00325           RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILMASK]) );
00326         HW__SetFrontFaceStencilOp (
00327           RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILFAIL]),
00328           RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILZFAIL]),
00329           RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILZPASS]) );
00330         HW__SetStencilFrontFaceWriteMask (
00331           RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_STENCILWRITEMASK]) );
00332 
00333         HW__SetBackFaceStencilFunc (
00334           RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILFUNC]),
00335           RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILREF]),
00336           RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILMASK]) );
00337         HW__SetBackFaceStencilOp (
00338           RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILFAIL]),
00339           RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILZFAIL]),
00340           RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILZPASS]) );
00341         HW__SetStencilBackFaceWriteMask (
00342           RS_VALUE (m_RenderStateChanges[GFXRS_BACK_STENCILWRITEMASK]) );
00343 #endif
00344       }
00345 
00346       if (rs == GFXRS_ALPHABLENDENABLE   ||
00347           rs == GFXRS_BLENDOP           ||
00348           rs == GFXRS_BLENDOPALPHA      ||
00349           rs == GFXRS_SRCBLEND          ||
00350           rs == GFXRS_DESTBLEND         ||
00351           rs == GFXRS_SRCBLENDALPHA     ||
00352           rs == GFXRS_DESTBLENDALPHA)
00353       {
00354         HW__EnableAlphaBlend (
00355           RS_VALUE (m_RenderStateChanges[GFXRS_ALPHABLENDENABLE]) );
00356 
00357         HW__SetSeparateAlphaBlendFactors (
00358           RS_VALUE (m_RenderStateChanges[GFXRS_SRCBLEND]),
00359           RS_VALUE (m_RenderStateChanges[GFXRS_DESTBLEND]),
00360           RS_VALUE (m_RenderStateChanges[GFXRS_SRCBLENDALPHA]),
00361           RS_VALUE (m_RenderStateChanges[GFXRS_DESTBLENDALPHA]) );
00362         HW__SetAlphaBlendOp (
00363           RS_VALUE (m_RenderStateChanges[GFXRS_BLENDOP]),
00364           RS_VALUE (m_RenderStateChanges[GFXRS_BLENDOPALPHA]) );
00365       }
00366 
00367       if (rs == GFXRS_COLORWRITEENABLE_R    ||
00368           rs == GFXRS_COLORWRITEENABLE_G   ||
00369           rs == GFXRS_COLORWRITEENABLE_B   ||
00370           rs == GFXRS_COLORWRITEENABLE_A)
00371       {
00372         HW__SetColorMask (
00373           RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_R]),
00374           RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_G]),
00375           RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_B]),
00376           RS_VALUE (m_RenderStateChanges[GFXRS_COLORWRITEENABLE_A]) );
00377       }
00378 
00379       if (rs == GFXRS_ZTESTENABLE    ||
00380           rs == GFXRS_ZWRITEENABLE   ||
00381           rs == GFXRS_ZFUNC   ||
00382           rs == GFXRS_ZNEAR   ||
00383           rs == GFXRS_ZFAR)
00384       {
00385         HW__SetEnableDepthTest (RS_VALUE (m_RenderStateChanges[GFXRS_ZTESTENABLE]) );
00386         HW__SetDepthMask (RS_VALUE (m_RenderStateChanges[GFXRS_ZWRITEENABLE]) );
00387         HW__SetDepthFunc (RS_VALUE (m_RenderStateChanges[GFXRS_ZFUNC]) );
00388         HW__SetDepthRange (
00389           RS_VALUE (m_RenderStateChanges[GFXRS_ZNEAR]),
00390           RS_VALUE (m_RenderStateChanges[GFXRS_ZFAR]) );
00391       }
00392 
00393       if (rs == GFXRS_POLYGONOFFSETENABLE    ||
00394           rs == GFXRS_POLYGONOFFSETFACTOR   ||
00395           rs == GFXRS_POLYGONOFFSETUNITS)
00396       {
00397         HW__EnablePolygonOffset (RS_VALUE (m_RenderStateChanges[GFXRS_POLYGONOFFSETENABLE]) );
00398         HW__SetPolygonOffset (
00399           RS_VALUE (m_RenderStateChanges[GFXRS_POLYGONOFFSETFACTOR]),
00400           RS_VALUE (m_RenderStateChanges[GFXRS_POLYGONOFFSETUNITS]) );
00401       }
00402 
00403       if (rs == GFXRS_FRONT_POLYGONMODE    ||
00404           rs == GFXRS_BACK_POLYGONMODE)
00405       {
00406         HW__SetPolygonMode (
00407           RS_VALUE (m_RenderStateChanges[GFXRS_FRONT_POLYGONMODE]),
00408           RS_VALUE (m_RenderStateChanges[GFXRS_BACK_POLYGONMODE]) );
00409       }
00410 
00411       if (rs == GFXRS_CULLFACEENABLE     ||
00412           rs == GFXRS_CULLFACE          ||
00413           rs == GFXRS_FRONTFACE)
00414       {
00415         HW__EnableCulling (RS_VALUE (m_RenderStateChanges[GFXRS_CULLFACEENABLE]) );
00416         HW__SetFrontFace (RS_VALUE (m_RenderStateChanges[GFXRS_FRONTFACE]) );
00417         HW__SetCullFace (RS_VALUE (m_RenderStateChanges[GFXRS_CULLFACE]) );
00418       }
00419     }
00420 
00421 #undef RS_VALUE
00422   }
00423 
00424 }
00425 
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends