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