nux-0.9.48
|
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