source/Irrlicht/COpenGLMaterialRenderer.h

   1 // Copyright (C) 2002-2012 Nikolaus Gebhardt\r
   2 // This file is part of the "Irrlicht Engine".\r
   3 // For conditions of distribution and use, see copyright notice in irrlicht.h\r
   4 \r
   5 #ifndef __C_OPENGL_MATERIAL_RENDERER_H_INCLUDED__\r
   6 #define __C_OPENGL_MATERIAL_RENDERER_H_INCLUDED__\r
   7 \r
   8 #ifdef _IRR_COMPILE_WITH_OPENGL_\r
   9 \r
  10 #include "IMaterialRenderer.h"\r
  11 \r
  12 #include "COpenGLDriver.h"\r
  13 #include "COpenGLCacheHandler.h"\r
  14 \r
  15 namespace irr\r
  16 {\r
  17 namespace video\r
  18 {\r
  19 \r
  20 //! Solid material renderer\r
  21 class COpenGLMaterialRenderer_SOLID : public IMaterialRenderer\r
  22 {\r
  23 public:\r
  24 \r
  25         COpenGLMaterialRenderer_SOLID(video::COpenGLDriver* d) : Driver(d) {}\r
  26 \r
  27         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
  28                 bool resetAllRenderstates, IMaterialRendererServices* services) override\r
  29         {\r
  30                 if (Driver->getFixedPipelineState() == COpenGLDriver::EOFPS_DISABLE)\r
  31                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_DISABLE_TO_ENABLE);\r
  32                 else\r
  33                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_ENABLE);\r
  34 \r
  35                 Driver->disableTextures(1);\r
  36                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
  37         }\r
  38 \r
  39 protected:\r
  40 \r
  41         video::COpenGLDriver* Driver;\r
  42 };\r
  43 \r
  44 \r
  45 //! Generic Texture Blend\r
  46 class COpenGLMaterialRenderer_ONETEXTURE_BLEND : public IMaterialRenderer\r
  47 {\r
  48 public:\r
  49 \r
  50         COpenGLMaterialRenderer_ONETEXTURE_BLEND(video::COpenGLDriver* d) : Driver(d) {}\r
  51 \r
  52         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
  53                 bool resetAllRenderstates, IMaterialRendererServices* services) override\r
  54         {\r
  55                 if (Driver->getFixedPipelineState() == COpenGLDriver::EOFPS_DISABLE)\r
  56                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_DISABLE_TO_ENABLE);\r
  57                 else\r
  58                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_ENABLE);\r
  59 \r
  60                 Driver->disableTextures(1);\r
  61                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
  62 \r
  63 //              if (material.MaterialType != lastMaterial.MaterialType ||\r
  64 //                      material.MaterialTypeParam != lastMaterial.MaterialTypeParam ||\r
  65 //                      resetAllRenderstates)\r
  66                 {\r
  67             E_BLEND_FACTOR srcRGBFact,dstRGBFact,srcAlphaFact,dstAlphaFact;\r
  68                         E_MODULATE_FUNC modulate;\r
  69                         u32 alphaSource;\r
  70                         unpack_textureBlendFuncSeparate(srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact, modulate, alphaSource, material.MaterialTypeParam);\r
  71 \r
  72             Driver->getCacheHandler()->setBlend(true);\r
  73 \r
  74             if (Driver->queryFeature(EVDF_BLEND_SEPARATE))\r
  75             {\r
  76                 Driver->getCacheHandler()->setBlendFuncSeparate(Driver->getGLBlend(srcRGBFact), Driver->getGLBlend(dstRGBFact),\r
  77                     Driver->getGLBlend(srcAlphaFact), Driver->getGLBlend(dstAlphaFact));\r
  78             }\r
  79             else\r
  80             {\r
  81                 Driver->getCacheHandler()->setBlendFunc(Driver->getGLBlend(srcRGBFact), Driver->getGLBlend(dstRGBFact));\r
  82             }\r
  83 \r
  84                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE0_ARB);\r
  85 \r
  86 #ifdef GL_ARB_texture_env_combine\r
  87                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);\r
  88                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);\r
  89                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);\r
  90                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);\r
  91                         glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, (f32) modulate );\r
  92 #else\r
  93                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);\r
  94                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);\r
  95                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);\r
  96                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT);\r
  97                         glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, (f32) modulate );\r
  98 #endif\r
  99 \r
 100                         if (textureBlendFunc_hasAlpha(srcRGBFact) || textureBlendFunc_hasAlpha(dstRGBFact) ||\r
 101                 textureBlendFunc_hasAlpha(srcAlphaFact) || textureBlendFunc_hasAlpha(dstAlphaFact))\r
 102                         {\r
 103                                 if (alphaSource==EAS_VERTEX_COLOR)\r
 104                                 {\r
 105 #ifdef GL_ARB_texture_env_combine\r
 106                                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);\r
 107                                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PRIMARY_COLOR_ARB);\r
 108 #else\r
 109                                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_REPLACE);\r
 110                                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_PRIMARY_COLOR_EXT);\r
 111 #endif\r
 112                                 }\r
 113                                 else if (alphaSource==EAS_TEXTURE)\r
 114                                 {\r
 115 #ifdef GL_ARB_texture_env_combine\r
 116                                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);\r
 117                                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);\r
 118 #else\r
 119                                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_REPLACE);\r
 120                                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE);\r
 121 #endif\r
 122                                 }\r
 123                                 else\r
 124                                 {\r
 125 #ifdef GL_ARB_texture_env_combine\r
 126                                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE);\r
 127                                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PRIMARY_COLOR_ARB);\r
 128                                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_TEXTURE);\r
 129 #else\r
 130                                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_MODULATE);\r
 131                                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_PRIMARY_COLOR_EXT);\r
 132                                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, GL_TEXTURE);\r
 133 #endif\r
 134                                 }\r
 135                         }\r
 136                 }\r
 137         }\r
 138 \r
 139         void OnUnsetMaterial() override\r
 140         {\r
 141                 Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE0_ARB);\r
 142 \r
 143                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 144 \r
 145 #ifdef GL_ARB_texture_env_combine\r
 146                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE);\r
 147                 glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1.f );\r
 148                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);\r
 149 #else\r
 150                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_MODULATE);\r
 151                 glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, 1.f );\r
 152                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT);\r
 153 #endif\r
 154 \r
 155                 Driver->getCacheHandler()->setBlend(false);\r
 156         }\r
 157 \r
 158         //! Returns if the material is transparent.\r
 159         /** Is not always transparent, but mostly. */\r
 160         bool isTransparent() const override\r
 161         {\r
 162                 return true;\r
 163         }\r
 164 \r
 165 protected:\r
 166 \r
 167         video::COpenGLDriver* Driver;\r
 168 };\r
 169 \r
 170 \r
 171 //! Solid 2 layer material renderer\r
 172 class COpenGLMaterialRenderer_SOLID_2_LAYER : public IMaterialRenderer\r
 173 {\r
 174 public:\r
 175 \r
 176         COpenGLMaterialRenderer_SOLID_2_LAYER(video::COpenGLDriver* d) : Driver(d) {}\r
 177 \r
 178         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 179                 bool resetAllRenderstates, IMaterialRendererServices* services) override\r
 180         {\r
 181                 if (Driver->getFixedPipelineState() == COpenGLDriver::EOFPS_DISABLE)\r
 182                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_DISABLE_TO_ENABLE);\r
 183                 else\r
 184                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_ENABLE);\r
 185 \r
 186                 Driver->disableTextures(2);\r
 187                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 188 \r
 189                 if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates)\r
 190                 {\r
 191                         if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 192                         {\r
 193                                 Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1_ARB);\r
 194 #ifdef GL_ARB_texture_env_combine\r
 195                                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);\r
 196                                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);\r
 197                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PRIMARY_COLOR_ARB);\r
 198                                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_INTERPOLATE);\r
 199                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);\r
 200                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);\r
 201                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, GL_PRIMARY_COLOR);\r
 202                                 glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_ALPHA);\r
 203 #else\r
 204                                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);\r
 205                                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_REPLACE);\r
 206                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_PRIMARY_COLOR_EXT);\r
 207                                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_INTERPOLATE);\r
 208                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);\r
 209                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT);\r
 210                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_EXT, GL_PRIMARY_COLOR);\r
 211                                 glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, GL_SRC_ALPHA);\r
 212 #endif\r
 213                         }\r
 214                 }\r
 215         }\r
 216 \r
 217         void OnUnsetMaterial() override\r
 218         {\r
 219                 if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 220                 {\r
 221                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1_ARB);\r
 222 \r
 223                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 224 \r
 225 #ifdef GL_ARB_texture_env_combine\r
 226                         glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, GL_SRC_COLOR);\r
 227 #else\r
 228                         glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_EXT, GL_SRC_COLOR);\r
 229 #endif\r
 230                 }\r
 231         }\r
 232 \r
 233 protected:\r
 234 \r
 235         video::COpenGLDriver* Driver;\r
 236 };\r
 237 \r
 238 \r
 239 //! Transparent add color material renderer\r
 240 class COpenGLMaterialRenderer_TRANSPARENT_ADD_COLOR : public IMaterialRenderer\r
 241 {\r
 242 public:\r
 243 \r
 244         COpenGLMaterialRenderer_TRANSPARENT_ADD_COLOR(video::COpenGLDriver* d) : Driver(d) {}\r
 245 \r
 246         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 247                 bool resetAllRenderstates, IMaterialRendererServices* services) override\r
 248         {\r
 249                 if (Driver->getFixedPipelineState() == COpenGLDriver::EOFPS_DISABLE)\r
 250                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_DISABLE_TO_ENABLE);\r
 251                 else\r
 252                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_ENABLE);\r
 253 \r
 254                 Driver->disableTextures(1);\r
 255                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 256 \r
 257                 Driver->getCacheHandler()->setBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_COLOR);\r
 258                 Driver->getCacheHandler()->setBlend(true);\r
 259         }\r
 260 \r
 261         void OnUnsetMaterial() override\r
 262         {\r
 263                 Driver->getCacheHandler()->setBlend(false);\r
 264         }\r
 265 \r
 266         //! Returns if the material is transparent.\r
 267         bool isTransparent() const override\r
 268         {\r
 269                 return true;\r
 270         }\r
 271 \r
 272 protected:\r
 273 \r
 274         video::COpenGLDriver* Driver;\r
 275 };\r
 276 \r
 277 \r
 278 //! Transparent vertex alpha material renderer\r
 279 class COpenGLMaterialRenderer_TRANSPARENT_VERTEX_ALPHA : public IMaterialRenderer\r
 280 {\r
 281 public:\r
 282 \r
 283         COpenGLMaterialRenderer_TRANSPARENT_VERTEX_ALPHA(video::COpenGLDriver* d) : Driver(d) {}\r
 284 \r
 285         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 286                 bool resetAllRenderstates, IMaterialRendererServices* services) override\r
 287         {\r
 288                 if (Driver->getFixedPipelineState() == COpenGLDriver::EOFPS_DISABLE)\r
 289                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_DISABLE_TO_ENABLE);\r
 290                 else\r
 291                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_ENABLE);\r
 292 \r
 293                 Driver->disableTextures(1);\r
 294                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 295 \r
 296                 Driver->getCacheHandler()->setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);\r
 297         Driver->getCacheHandler()->setBlend(true);\r
 298 \r
 299                 if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates)\r
 300                 {\r
 301                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE0_ARB);\r
 302 \r
 303 #ifdef GL_ARB_texture_env_combine\r
 304                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);\r
 305                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);\r
 306                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PRIMARY_COLOR_ARB);\r
 307                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);\r
 308                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);\r
 309                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);\r
 310 #else\r
 311                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);\r
 312                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_REPLACE);\r
 313                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_PRIMARY_COLOR_EXT );\r
 314                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);\r
 315                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);\r
 316                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT);\r
 317 #endif\r
 318                 }\r
 319         }\r
 320 \r
 321         void OnUnsetMaterial() override\r
 322         {\r
 323                 Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE0_ARB);\r
 324 \r
 325                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 326 #ifdef GL_ARB_texture_env_combine\r
 327                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE );\r
 328                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE );\r
 329 #else\r
 330                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_MODULATE );\r
 331                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE );\r
 332 #endif\r
 333 \r
 334                 Driver->getCacheHandler()->setBlend(false);\r
 335         }\r
 336 \r
 337         //! Returns if the material is transparent.\r
 338         bool isTransparent() const override\r
 339         {\r
 340                 return true;\r
 341         }\r
 342 \r
 343 protected:\r
 344 \r
 345         video::COpenGLDriver* Driver;\r
 346 };\r
 347 \r
 348 \r
 349 //! Transparent alpha channel material renderer\r
 350 class COpenGLMaterialRenderer_TRANSPARENT_ALPHA_CHANNEL : public IMaterialRenderer\r
 351 {\r
 352 public:\r
 353 \r
 354         COpenGLMaterialRenderer_TRANSPARENT_ALPHA_CHANNEL(video::COpenGLDriver* d) : Driver(d) {}\r
 355 \r
 356         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 357                 bool resetAllRenderstates, IMaterialRendererServices* services) override\r
 358         {\r
 359                 if (Driver->getFixedPipelineState() == COpenGLDriver::EOFPS_DISABLE)\r
 360                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_DISABLE_TO_ENABLE);\r
 361                 else\r
 362                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_ENABLE);\r
 363 \r
 364                 Driver->disableTextures(1);\r
 365                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 366 \r
 367         Driver->getCacheHandler()->setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);\r
 368         Driver->getCacheHandler()->setBlend(true);\r
 369         Driver->getCacheHandler()->setAlphaTest(true);\r
 370         Driver->getCacheHandler()->setAlphaFunc(GL_GREATER, material.MaterialTypeParam);\r
 371 \r
 372                 if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates || material.MaterialTypeParam != lastMaterial.MaterialTypeParam )\r
 373                 {\r
 374                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE0_ARB);\r
 375 \r
 376 #ifdef GL_ARB_texture_env_combine\r
 377                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);\r
 378                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);\r
 379                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);\r
 380                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);\r
 381                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);\r
 382                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);\r
 383 #else\r
 384                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);\r
 385                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);\r
 386                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);\r
 387                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT);\r
 388                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_REPLACE);\r
 389                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE);\r
 390 #endif\r
 391                 }\r
 392         }\r
 393 \r
 394         void OnUnsetMaterial() override\r
 395         {\r
 396                 Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE0_ARB);\r
 397 \r
 398                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 399 #ifdef GL_ARB_texture_env_combine\r
 400                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE );\r
 401 #else\r
 402                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_MODULATE );\r
 403 #endif\r
 404                 Driver->getCacheHandler()->setAlphaTest(false);\r
 405                 Driver->getCacheHandler()->setBlend(false);\r
 406         }\r
 407 \r
 408         //! Returns if the material is transparent.\r
 409         bool isTransparent() const override\r
 410         {\r
 411                 return true;\r
 412         }\r
 413 \r
 414 protected:\r
 415 \r
 416         video::COpenGLDriver* Driver;\r
 417 };\r
 418 \r
 419 \r
 420 //! Transparent alpha channel material renderer\r
 421 class COpenGLMaterialRenderer_TRANSPARENT_ALPHA_CHANNEL_REF : public IMaterialRenderer\r
 422 {\r
 423 public:\r
 424 \r
 425         COpenGLMaterialRenderer_TRANSPARENT_ALPHA_CHANNEL_REF(video::COpenGLDriver* d) : Driver(d) {}\r
 426 \r
 427         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 428                 bool resetAllRenderstates, IMaterialRendererServices* services) override\r
 429         {\r
 430                 if (Driver->getFixedPipelineState() == COpenGLDriver::EOFPS_DISABLE)\r
 431                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_DISABLE_TO_ENABLE);\r
 432                 else\r
 433                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_ENABLE);\r
 434 \r
 435                 Driver->disableTextures(1);\r
 436                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 437 \r
 438                 if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates)\r
 439                 {\r
 440                         Driver->getCacheHandler()->setAlphaTest(true);\r
 441                         Driver->getCacheHandler()->setAlphaFunc(GL_GREATER, 0.5f);\r
 442                 }\r
 443         }\r
 444 \r
 445         void OnUnsetMaterial() override\r
 446         {\r
 447                 Driver->getCacheHandler()->setAlphaTest(false);\r
 448         }\r
 449 \r
 450         //! Returns if the material is transparent.\r
 451         bool isTransparent() const override\r
 452         {\r
 453                 return false;  // this material is not really transparent because it does no blending.\r
 454         }\r
 455 \r
 456 protected:\r
 457 \r
 458         video::COpenGLDriver* Driver;\r
 459 };\r
 460 \r
 461 \r
 462 //! material renderer for all kinds of lightmaps\r
 463 class COpenGLMaterialRenderer_LIGHTMAP : public IMaterialRenderer\r
 464 {\r
 465 public:\r
 466 \r
 467         COpenGLMaterialRenderer_LIGHTMAP(video::COpenGLDriver* d) : Driver(d) {}\r
 468 \r
 469         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 470                 bool resetAllRenderstates, IMaterialRendererServices* services) override\r
 471         {\r
 472                 if (Driver->getFixedPipelineState() == COpenGLDriver::EOFPS_DISABLE)\r
 473                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_DISABLE_TO_ENABLE);\r
 474                 else\r
 475                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_ENABLE);\r
 476 \r
 477                 Driver->disableTextures(2);\r
 478                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 479 \r
 480                 if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates)\r
 481                 {\r
 482                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE0_ARB);\r
 483 \r
 484                         // diffuse map\r
 485 \r
 486                         switch (material.MaterialType)\r
 487                         {\r
 488                                 case EMT_LIGHTMAP_LIGHTING:\r
 489                                 case EMT_LIGHTMAP_LIGHTING_M2:\r
 490                                 case EMT_LIGHTMAP_LIGHTING_M4:\r
 491                                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 492                                         break;\r
 493                                 case EMT_LIGHTMAP_ADD:\r
 494                                 case EMT_LIGHTMAP:\r
 495                                 case EMT_LIGHTMAP_M2:\r
 496                                 case EMT_LIGHTMAP_M4:\r
 497                                 default:\r
 498                                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);\r
 499                                         break;\r
 500                         }\r
 501 \r
 502                         if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 503                         {\r
 504                                 // lightmap\r
 505 \r
 506                                 Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1_ARB);\r
 507 #ifdef GL_ARB_texture_env_combine\r
 508                                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);\r
 509 \r
 510                                 if (material.MaterialType == EMT_LIGHTMAP_ADD)\r
 511                                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_ADD);\r
 512                                 else\r
 513                                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);\r
 514 \r
 515                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);\r
 516                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);\r
 517                                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_MODULATE);\r
 518                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_TEXTURE);\r
 519                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, GL_PREVIOUS_ARB);\r
 520 #else\r
 521                                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);\r
 522 \r
 523                                 if (material.MaterialType == EMT_LIGHTMAP_ADD)\r
 524                                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_ADD);\r
 525                                 else\r
 526                                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);\r
 527 \r
 528                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);\r
 529                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT);\r
 530                                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_MODULATE);\r
 531                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_TEXTURE);\r
 532                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, GL_PREVIOUS_EXT);\r
 533 #endif\r
 534 \r
 535                                 switch (material.MaterialType)\r
 536                                 {\r
 537                                         case EMT_LIGHTMAP_M4:\r
 538                                         case EMT_LIGHTMAP_LIGHTING_M4:\r
 539 #ifdef GL_ARB_texture_env_combine\r
 540                                                 glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 4.0f);\r
 541 #else\r
 542                                                 glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, 4.0f);\r
 543 #endif\r
 544                                                 break;\r
 545                                         case EMT_LIGHTMAP_M2:\r
 546                                         case EMT_LIGHTMAP_LIGHTING_M2:\r
 547 #ifdef GL_ARB_texture_env_combine\r
 548                                                 glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 2.0f);\r
 549 #else\r
 550                                                 glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, 2.0f);\r
 551 #endif\r
 552                                                 break;\r
 553                                         default:\r
 554 #ifdef GL_ARB_texture_env_combine\r
 555                                                 glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1.0f);\r
 556 #else\r
 557                                                 glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, 1.0f);\r
 558 #endif\r
 559                                 }\r
 560                         }\r
 561                 }\r
 562         }\r
 563 \r
 564         void OnUnsetMaterial() override\r
 565         {\r
 566                 if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 567                 {\r
 568                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1_ARB);\r
 569 \r
 570                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 571 #ifdef GL_ARB_texture_env_combine\r
 572                         glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_ARB, 1.f );\r
 573 #else\r
 574                         glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE_EXT, 1.f );\r
 575 #endif\r
 576                 }\r
 577 \r
 578                 Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE0_ARB);\r
 579                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 580         }\r
 581 \r
 582 protected:\r
 583 \r
 584         video::COpenGLDriver* Driver;\r
 585 };\r
 586 \r
 587 \r
 588 \r
 589 //! detail map  material renderer\r
 590 class COpenGLMaterialRenderer_DETAIL_MAP : public IMaterialRenderer\r
 591 {\r
 592 public:\r
 593 \r
 594         COpenGLMaterialRenderer_DETAIL_MAP(video::COpenGLDriver* d) : Driver(d) {}\r
 595 \r
 596         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 597                 bool resetAllRenderstates, IMaterialRendererServices* services) override\r
 598         {\r
 599                 if (Driver->getFixedPipelineState() == COpenGLDriver::EOFPS_DISABLE)\r
 600                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_DISABLE_TO_ENABLE);\r
 601                 else\r
 602                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_ENABLE);\r
 603 \r
 604                 Driver->disableTextures(2);\r
 605                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 606 \r
 607                 if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates)\r
 608                 {\r
 609                         // detail map on second layer\r
 610                         if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 611                         {\r
 612                                 Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1_ARB);\r
 613 \r
 614 #ifdef GL_ARB_texture_env_combine\r
 615                                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);\r
 616                                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_ADD_SIGNED_ARB);\r
 617                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);\r
 618                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);\r
 619 #else\r
 620                                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);\r
 621                                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_ADD_SIGNED_EXT);\r
 622                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);\r
 623                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT);\r
 624 #endif\r
 625                         }\r
 626                 }\r
 627         }\r
 628 \r
 629         void OnUnsetMaterial() override\r
 630         {\r
 631                 if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 632                 {\r
 633                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1_ARB);\r
 634 \r
 635                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 636                 }\r
 637         }\r
 638 \r
 639 protected:\r
 640 \r
 641         video::COpenGLDriver* Driver;\r
 642 };\r
 643 \r
 644 \r
 645 //! sphere map material renderer\r
 646 class COpenGLMaterialRenderer_SPHERE_MAP : public IMaterialRenderer\r
 647 {\r
 648 public:\r
 649 \r
 650         COpenGLMaterialRenderer_SPHERE_MAP(video::COpenGLDriver* d) : Driver(d) {}\r
 651 \r
 652         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 653                 bool resetAllRenderstates, IMaterialRendererServices* services) override\r
 654         {\r
 655                 if (Driver->getFixedPipelineState() == COpenGLDriver::EOFPS_DISABLE)\r
 656                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_DISABLE_TO_ENABLE);\r
 657                 else\r
 658                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_ENABLE);\r
 659 \r
 660                 Driver->disableTextures(1);\r
 661                 // texture needs to be flipped for OpenGL\r
 662                 core::matrix4 tmp = Driver->getTransform(ETS_TEXTURE_0);\r
 663                 tmp[5]*=-1;\r
 664                 Driver->setTransform(ETS_TEXTURE_0, tmp);\r
 665                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 666 \r
 667                 if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates)\r
 668                 {\r
 669                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE0_ARB);\r
 670 \r
 671                         glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);\r
 672                         glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);\r
 673 \r
 674                         glEnable(GL_TEXTURE_GEN_S);\r
 675                         glEnable(GL_TEXTURE_GEN_T);\r
 676                 }\r
 677         }\r
 678 \r
 679         void OnUnsetMaterial() override\r
 680         {\r
 681                 Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE0_ARB);\r
 682 \r
 683                 glDisable(GL_TEXTURE_GEN_S);\r
 684                 glDisable(GL_TEXTURE_GEN_T);\r
 685         }\r
 686 \r
 687 protected:\r
 688 \r
 689         video::COpenGLDriver* Driver;\r
 690 };\r
 691 \r
 692 \r
 693 //! reflection 2 layer material renderer\r
 694 class COpenGLMaterialRenderer_REFLECTION_2_LAYER : public IMaterialRenderer\r
 695 {\r
 696 public:\r
 697 \r
 698         COpenGLMaterialRenderer_REFLECTION_2_LAYER(video::COpenGLDriver* d) : Driver(d) {}\r
 699 \r
 700         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 701                 bool resetAllRenderstates, IMaterialRendererServices* services) override\r
 702         {\r
 703                 if (Driver->getFixedPipelineState() == COpenGLDriver::EOFPS_DISABLE)\r
 704                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_DISABLE_TO_ENABLE);\r
 705                 else\r
 706                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_ENABLE);\r
 707 \r
 708                 Driver->disableTextures(2);\r
 709                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 710 \r
 711                 if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates)\r
 712                 {\r
 713                         if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 714                         {\r
 715                                 Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1_ARB);\r
 716 \r
 717 #ifdef GL_ARB_texture_env_combine\r
 718                                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);\r
 719                                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);\r
 720                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);\r
 721                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);\r
 722 #else\r
 723                                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);\r
 724                                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);\r
 725                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);\r
 726                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT);\r
 727 #endif\r
 728 \r
 729                                 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);\r
 730                                 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);\r
 731                                 glEnable(GL_TEXTURE_GEN_S);\r
 732                                 glEnable(GL_TEXTURE_GEN_T);\r
 733                         }\r
 734                 }\r
 735         }\r
 736 \r
 737         void OnUnsetMaterial() override\r
 738         {\r
 739                 if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 740                 {\r
 741                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1_ARB);\r
 742 \r
 743                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 744                         glDisable(GL_TEXTURE_GEN_S);\r
 745                         glDisable(GL_TEXTURE_GEN_T);\r
 746                 }\r
 747         }\r
 748 \r
 749 protected:\r
 750 \r
 751         video::COpenGLDriver* Driver;\r
 752 };\r
 753 \r
 754 \r
 755 //! reflection 2 layer material renderer\r
 756 class COpenGLMaterialRenderer_TRANSPARENT_REFLECTION_2_LAYER : public IMaterialRenderer\r
 757 {\r
 758 public:\r
 759 \r
 760         COpenGLMaterialRenderer_TRANSPARENT_REFLECTION_2_LAYER(video::COpenGLDriver* d) : Driver(d) {}\r
 761 \r
 762         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 763                 bool resetAllRenderstates, IMaterialRendererServices* services) override\r
 764         {\r
 765                 if (Driver->getFixedPipelineState() == COpenGLDriver::EOFPS_DISABLE)\r
 766                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_DISABLE_TO_ENABLE);\r
 767                 else\r
 768                         Driver->setFixedPipelineState(COpenGLDriver::EOFPS_ENABLE);\r
 769 \r
 770                 Driver->disableTextures(2);\r
 771                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 772 \r
 773                 Driver->getCacheHandler()->setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);\r
 774         Driver->getCacheHandler()->setBlend(true);\r
 775 \r
 776                 if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates)\r
 777                 {\r
 778                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE0_ARB);\r
 779 \r
 780 #ifdef GL_ARB_texture_env_combine\r
 781                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);\r
 782                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);\r
 783                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);\r
 784                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);\r
 785                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);\r
 786                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS_ARB);\r
 787 #else\r
 788                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);\r
 789                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);\r
 790                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);\r
 791                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT);\r
 792                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_REPLACE);\r
 793                         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_PREVIOUS_ARB);\r
 794 #endif\r
 795                         if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 796                         {\r
 797                                 Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1_ARB);\r
 798 #ifdef GL_ARB_texture_env_combine\r
 799                                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);\r
 800                                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);\r
 801                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);\r
 802                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);\r
 803                                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);\r
 804                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_PREVIOUS_ARB);\r
 805 #else\r
 806                                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);\r
 807                                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);\r
 808                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);\r
 809                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PREVIOUS_EXT);\r
 810                                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_EXT, GL_REPLACE);\r
 811                                 glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, GL_PREVIOUS_ARB);\r
 812 #endif\r
 813 \r
 814                                 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);\r
 815                                 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);\r
 816                                 glEnable(GL_TEXTURE_GEN_S);\r
 817                                 glEnable(GL_TEXTURE_GEN_T);\r
 818                         }\r
 819                 }\r
 820         }\r
 821 \r
 822         void OnUnsetMaterial() override\r
 823         {\r
 824                 if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 825                 {\r
 826                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1_ARB);\r
 827 \r
 828                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 829 \r
 830                         glDisable(GL_TEXTURE_GEN_S);\r
 831                         glDisable(GL_TEXTURE_GEN_T);\r
 832                 }\r
 833 \r
 834                 Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE0_ARB);\r
 835 \r
 836                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 837 \r
 838                 Driver->getCacheHandler()->setBlend(false);\r
 839         }\r
 840 \r
 841         //! Returns if the material is transparent.\r
 842         bool isTransparent() const override\r
 843         {\r
 844                 return true;\r
 845         }\r
 846 \r
 847 protected:\r
 848 \r
 849         video::COpenGLDriver* Driver;\r
 850 };\r
 851 \r
 852 } // end namespace video\r
 853 } // end namespace irr\r
 854 \r
 855 #endif\r
 856 #endif\r
 857 \r