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