source/Irrlicht/COGLESMaterialRenderer.h

   1 // Copyright (C) 2002-2008 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_OGLES1_MATERIAL_RENDERER_H_INCLUDED__\r
   6 #define __C_OGLES1_MATERIAL_RENDERER_H_INCLUDED__\r
   7 \r
   8 #ifdef _IRR_COMPILE_WITH_OGLES1_\r
   9 \r
  10 #include "COGLESDriver.h"\r
  11 #include "IMaterialRenderer.h"\r
  12 \r
  13 namespace irr\r
  14 {\r
  15 namespace video\r
  16 {\r
  17 \r
  18 //! Base class for all internal OGLES1 material renderers\r
  19 class COGLES1MaterialRenderer : public IMaterialRenderer\r
  20 {\r
  21 public:\r
  22 \r
  23         //! Constructor\r
  24         COGLES1MaterialRenderer(video::COGLES1Driver* driver) : Driver(driver)\r
  25         {\r
  26         }\r
  27 \r
  28 protected:\r
  29 \r
  30         video::COGLES1Driver* Driver;\r
  31 };\r
  32 \r
  33 \r
  34 //! Solid material renderer\r
  35 class COGLES1MaterialRenderer_SOLID : public COGLES1MaterialRenderer\r
  36 {\r
  37 public:\r
  38 \r
  39         COGLES1MaterialRenderer_SOLID(video::COGLES1Driver* d)\r
  40                 : COGLES1MaterialRenderer(d) {}\r
  41 \r
  42         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
  43                 bool resetAllRenderstates, IMaterialRendererServices* services)\r
  44         {\r
  45                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
  46 \r
  47                 if (resetAllRenderstates || (material.MaterialType != lastMaterial.MaterialType))\r
  48                 {\r
  49                         // thanks to Murphy, the following line removed some\r
  50                         // bugs with several OGLES1 implementations.\r
  51                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
  52                 }\r
  53         }\r
  54 };\r
  55 \r
  56 \r
  57 //! Generic Texture Blend\r
  58 class COGLES1MaterialRenderer_ONETEXTURE_BLEND : public COGLES1MaterialRenderer\r
  59 {\r
  60 public:\r
  61 \r
  62         COGLES1MaterialRenderer_ONETEXTURE_BLEND(video::COGLES1Driver* d)\r
  63                 : COGLES1MaterialRenderer(d) {}\r
  64 \r
  65         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
  66                 bool resetAllRenderstates, IMaterialRendererServices* services)\r
  67         {\r
  68                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
  69 \r
  70 //              if (material.MaterialType != lastMaterial.MaterialType ||\r
  71 //                      material.MaterialTypeParam != lastMaterial.MaterialTypeParam ||\r
  72 //                      resetAllRenderstates)\r
  73                 {\r
  74                         E_BLEND_FACTOR srcRGBFact,dstRGBFact,srcAlphaFact,dstAlphaFact;\r
  75                         E_MODULATE_FUNC modulate;\r
  76                         u32 alphaSource;\r
  77                         unpack_textureBlendFuncSeparate(srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact, modulate, alphaSource, material.MaterialTypeParam);\r
  78 \r
  79             Driver->getCacheHandler()->setBlend(true);\r
  80 \r
  81             if (Driver->queryFeature(EVDF_BLEND_SEPARATE))\r
  82             {\r
  83                 Driver->getCacheHandler()->setBlendFuncSeparate(Driver->getGLBlend(srcRGBFact), Driver->getGLBlend(dstRGBFact),\r
  84                     Driver->getGLBlend(srcAlphaFact), Driver->getGLBlend(dstAlphaFact));\r
  85             }\r
  86             else\r
  87             {\r
  88                 Driver->getCacheHandler()->setBlendFunc(Driver->getGLBlend(srcRGBFact), Driver->getGLBlend(dstRGBFact));\r
  89             }\r
  90 \r
  91                         glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);\r
  92                         glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);\r
  93                         glTexEnvf(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_TEXTURE);\r
  94                         glTexEnvf(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_PREVIOUS);\r
  95 \r
  96                         glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE, (f32) modulate );\r
  97 \r
  98                         glEnable(GL_ALPHA_TEST);\r
  99                         glAlphaFunc(GL_GREATER, 0.f);\r
 100 \r
 101                         if (textureBlendFunc_hasAlpha(srcRGBFact) || textureBlendFunc_hasAlpha(dstRGBFact) ||\r
 102                 textureBlendFunc_hasAlpha(srcAlphaFact) || textureBlendFunc_hasAlpha(dstAlphaFact))\r
 103                         {\r
 104                                 glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);\r
 105                                 glTexEnvf(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_TEXTURE);\r
 106 \r
 107                                 glTexEnvf(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_PRIMARY_COLOR);\r
 108                         }\r
 109                 }\r
 110         }\r
 111 \r
 112         virtual void OnUnsetMaterial()\r
 113         {\r
 114                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 115                 glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE, 1.f );\r
 116                 glTexEnvf(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_PREVIOUS);\r
 117 \r
 118                 Driver->getCacheHandler()->setBlend(false);\r
 119                 glDisable(GL_ALPHA_TEST);\r
 120         }\r
 121 \r
 122         //! Returns if the material is transparent.\r
 123         /** Is not always transparent, but mostly. */\r
 124         virtual bool isTransparent() const\r
 125         {\r
 126                 return true;\r
 127         }\r
 128 \r
 129         private:\r
 130 \r
 131                 u32 getGLBlend ( E_BLEND_FACTOR factor ) const\r
 132                 {\r
 133                         u32 r = 0;\r
 134                         switch ( factor )\r
 135                         {\r
 136                                 case EBF_ZERO:                  r = GL_ZERO; break;\r
 137                                 case EBF_ONE:                   r = GL_ONE; break;\r
 138                                 case EBF_DST_COLOR:             r = GL_DST_COLOR; break;\r
 139                                 case EBF_ONE_MINUS_DST_COLOR:   r = GL_ONE_MINUS_DST_COLOR; break;\r
 140                                 case EBF_SRC_COLOR:             r = GL_SRC_COLOR; break;\r
 141                                 case EBF_ONE_MINUS_SRC_COLOR:   r = GL_ONE_MINUS_SRC_COLOR; break;\r
 142                                 case EBF_SRC_ALPHA:             r = GL_SRC_ALPHA; break;\r
 143                                 case EBF_ONE_MINUS_SRC_ALPHA:   r = GL_ONE_MINUS_SRC_ALPHA; break;\r
 144                                 case EBF_DST_ALPHA:             r = GL_DST_ALPHA; break;\r
 145                                 case EBF_ONE_MINUS_DST_ALPHA:   r = GL_ONE_MINUS_DST_ALPHA; break;\r
 146                                 case EBF_SRC_ALPHA_SATURATE:    r = GL_SRC_ALPHA_SATURATE; break;\r
 147                         }\r
 148                         return r;\r
 149                 }\r
 150 };\r
 151 \r
 152 \r
 153 //! Solid 2 layer material renderer\r
 154 class COGLES1MaterialRenderer_SOLID_2_LAYER : public COGLES1MaterialRenderer\r
 155 {\r
 156 public:\r
 157 \r
 158         COGLES1MaterialRenderer_SOLID_2_LAYER(video::COGLES1Driver* d)\r
 159                 : COGLES1MaterialRenderer(d) {}\r
 160 \r
 161         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 162                 bool resetAllRenderstates, IMaterialRendererServices* services)\r
 163         {\r
 164                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 165 \r
 166                 if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates)\r
 167                 {\r
 168                         if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 169                         {\r
 170                                 Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1);\r
 171                                 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);\r
 172                                 glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);\r
 173                                 glTexEnvf(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_PRIMARY_COLOR);\r
 174                                 glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);\r
 175                                 glTexEnvf(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS);\r
 176                                 glTexEnvf(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_TEXTURE);\r
 177                                 glTexEnvf(GL_TEXTURE_ENV, GL_SRC2_RGB, GL_PRIMARY_COLOR);\r
 178                                 glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_ALPHA);\r
 179                         }\r
 180                 }\r
 181         }\r
 182 \r
 183         virtual void OnUnsetMaterial()\r
 184         {\r
 185                 if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 186                 {\r
 187                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1);\r
 188                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 189                         glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_COLOR);\r
 190                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE0);\r
 191                 }\r
 192         }\r
 193 };\r
 194 \r
 195 \r
 196 //! Transparent add color material renderer\r
 197 class COGLES1MaterialRenderer_TRANSPARENT_ADD_COLOR : public COGLES1MaterialRenderer\r
 198 {\r
 199 public:\r
 200 \r
 201         COGLES1MaterialRenderer_TRANSPARENT_ADD_COLOR(video::COGLES1Driver* d)\r
 202                 : COGLES1MaterialRenderer(d) {}\r
 203 \r
 204         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 205                 bool resetAllRenderstates, IMaterialRendererServices* services)\r
 206         {\r
 207                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 208 \r
 209                 Driver->getCacheHandler()->setBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_COLOR);\r
 210                 Driver->getCacheHandler()->setBlend(true);\r
 211 \r
 212                 if ((material.MaterialType != lastMaterial.MaterialType) || resetAllRenderstates)\r
 213                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 214         }\r
 215 \r
 216         virtual void OnUnsetMaterial()\r
 217         {\r
 218                 Driver->getCacheHandler()->setBlend(false);\r
 219         }\r
 220 \r
 221         //! Returns if the material is transparent.\r
 222         virtual bool isTransparent() const\r
 223         {\r
 224                 return true;\r
 225         }\r
 226 };\r
 227 \r
 228 \r
 229 //! Transparent vertex alpha material renderer\r
 230 class COGLES1MaterialRenderer_TRANSPARENT_VERTEX_ALPHA : public COGLES1MaterialRenderer\r
 231 {\r
 232 public:\r
 233 \r
 234         COGLES1MaterialRenderer_TRANSPARENT_VERTEX_ALPHA(video::COGLES1Driver* d)\r
 235                 : COGLES1MaterialRenderer(d) {}\r
 236 \r
 237         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 238                 bool resetAllRenderstates, IMaterialRendererServices* services)\r
 239         {\r
 240                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 241 \r
 242                 Driver->getCacheHandler()->setBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);\r
 243                 Driver->getCacheHandler()->setBlend(true);\r
 244 \r
 245                 if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates)\r
 246                 {\r
 247                         glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);\r
 248 \r
 249                         glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);\r
 250                         glTexEnvf(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_PRIMARY_COLOR );\r
 251 \r
 252                         glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);\r
 253                         glTexEnvf(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PRIMARY_COLOR );\r
 254                         glTexEnvf(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_TEXTURE);\r
 255                 }\r
 256         }\r
 257 \r
 258         virtual void OnUnsetMaterial()\r
 259         {\r
 260                 // default values\r
 261                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 262                 glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE );\r
 263                 glTexEnvf(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_TEXTURE );\r
 264                 glTexEnvf(GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_PREVIOUS );\r
 265                 glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);\r
 266                 glTexEnvf(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_TEXTURE );\r
 267                 glTexEnvf(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_PREVIOUS);\r
 268 \r
 269                 Driver->getCacheHandler()->setBlend(false);\r
 270         }\r
 271 \r
 272         //! Returns if the material is transparent.\r
 273         virtual bool isTransparent() const\r
 274         {\r
 275                 return true;\r
 276         }\r
 277 };\r
 278 \r
 279 \r
 280 //! Transparent alpha channel material renderer\r
 281 class COGLES1MaterialRenderer_TRANSPARENT_ALPHA_CHANNEL : public COGLES1MaterialRenderer\r
 282 {\r
 283 public:\r
 284 \r
 285         COGLES1MaterialRenderer_TRANSPARENT_ALPHA_CHANNEL(video::COGLES1Driver* d)\r
 286                 : COGLES1MaterialRenderer(d) {}\r
 287 \r
 288         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 289                 bool resetAllRenderstates, IMaterialRendererServices* services)\r
 290         {\r
 291                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 292 \r
 293                 Driver->getCacheHandler()->setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);\r
 294                 Driver->getCacheHandler()->setBlend(true);\r
 295 \r
 296                 if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates\r
 297                         || material.MaterialTypeParam != lastMaterial.MaterialTypeParam )\r
 298                 {\r
 299                         glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);\r
 300                         glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);\r
 301                         glTexEnvf(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_TEXTURE);\r
 302                         glTexEnvf(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_PREVIOUS);\r
 303 \r
 304                         glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);\r
 305                         glTexEnvf(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_TEXTURE);\r
 306 \r
 307                         glEnable(GL_ALPHA_TEST);\r
 308 \r
 309                         glAlphaFunc(GL_GREATER, material.MaterialTypeParam);\r
 310                 }\r
 311         }\r
 312 \r
 313         virtual void OnUnsetMaterial()\r
 314         {\r
 315                 glDisable(GL_ALPHA_TEST);\r
 316                 Driver->getCacheHandler()->setBlend(false);\r
 317         }\r
 318 \r
 319         //! Returns if the material is transparent.\r
 320         virtual bool isTransparent() const\r
 321         {\r
 322                 return true;\r
 323         }\r
 324 };\r
 325 \r
 326 \r
 327 \r
 328 //! Transparent alpha channel material renderer\r
 329 class COGLES1MaterialRenderer_TRANSPARENT_ALPHA_CHANNEL_REF : public COGLES1MaterialRenderer\r
 330 {\r
 331 public:\r
 332 \r
 333         COGLES1MaterialRenderer_TRANSPARENT_ALPHA_CHANNEL_REF(video::COGLES1Driver* d)\r
 334                 : COGLES1MaterialRenderer(d) {}\r
 335 \r
 336         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 337                 bool resetAllRenderstates, IMaterialRendererServices* services)\r
 338         {\r
 339                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 340 \r
 341                 if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates)\r
 342                 {\r
 343                         glEnable(GL_ALPHA_TEST);\r
 344                         glAlphaFunc(GL_GREATER, 0.5f);\r
 345                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 346                 }\r
 347         }\r
 348 \r
 349         virtual void OnUnsetMaterial()\r
 350         {\r
 351                 glDisable(GL_ALPHA_TEST);\r
 352         }\r
 353 \r
 354         //! Returns if the material is transparent.\r
 355         virtual bool isTransparent() const\r
 356         {\r
 357                 return false;  // this material is not really transparent because it does no blending.\r
 358         }\r
 359 };\r
 360 \r
 361 \r
 362 //! material renderer for all kinds of lightmaps\r
 363 class COGLES1MaterialRenderer_LIGHTMAP : public COGLES1MaterialRenderer\r
 364 {\r
 365 public:\r
 366 \r
 367         COGLES1MaterialRenderer_LIGHTMAP(video::COGLES1Driver* d)\r
 368                 : COGLES1MaterialRenderer(d) {}\r
 369 \r
 370         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 371                 bool resetAllRenderstates, IMaterialRendererServices* services)\r
 372         {\r
 373                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 374 \r
 375                 if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates)\r
 376                 {\r
 377                         // diffuse map\r
 378 \r
 379                         switch (material.MaterialType)\r
 380                         {\r
 381                                 case EMT_LIGHTMAP_LIGHTING:\r
 382                                 case EMT_LIGHTMAP_LIGHTING_M2:\r
 383                                 case EMT_LIGHTMAP_LIGHTING_M4:\r
 384                                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 385                                         break;\r
 386                                 case EMT_LIGHTMAP_ADD:\r
 387                                 case EMT_LIGHTMAP:\r
 388                                 case EMT_LIGHTMAP_M2:\r
 389                                 case EMT_LIGHTMAP_M4:\r
 390                                 default:\r
 391                                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);\r
 392                                         break;\r
 393                         }\r
 394 \r
 395                         if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 396                         {\r
 397                                 // lightmap\r
 398 \r
 399                                 Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1);\r
 400                                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);\r
 401 \r
 402                                 if (material.MaterialType == EMT_LIGHTMAP_ADD)\r
 403                                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_ADD);\r
 404                                 else\r
 405                                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);\r
 406 \r
 407                                 glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS);\r
 408                                 glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_TEXTURE);\r
 409 \r
 410                                 glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_MODULATE);\r
 411                                 glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, GL_PREVIOUS);\r
 412                                 glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_PREVIOUS);\r
 413 \r
 414                                 switch (material.MaterialType)\r
 415                                 {\r
 416                                         case EMT_LIGHTMAP_M4:\r
 417                                         case EMT_LIGHTMAP_LIGHTING_M4:\r
 418                                                 glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE, 4.0f);\r
 419                                                 break;\r
 420                                         case EMT_LIGHTMAP_M2:\r
 421                                         case EMT_LIGHTMAP_LIGHTING_M2:\r
 422                                                 glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE, 2.0f);\r
 423                                                 break;\r
 424                                         default:\r
 425                                                 glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE, 1.0f);\r
 426                                 }\r
 427                         }\r
 428                 }\r
 429         }\r
 430 \r
 431         virtual void OnUnsetMaterial()\r
 432         {\r
 433                 if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 434                 {\r
 435                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1);\r
 436                         glTexEnvf(GL_TEXTURE_ENV, GL_RGB_SCALE, 1.f );\r
 437                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 438                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE0);\r
 439                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 440                 }\r
 441         }\r
 442 };\r
 443 \r
 444 class COGLES1MaterialRenderer_DETAIL_MAP : public COGLES1MaterialRenderer\r
 445 {\r
 446 public:\r
 447         COGLES1MaterialRenderer_DETAIL_MAP(video::COGLES1Driver* d) : COGLES1MaterialRenderer(d)\r
 448         {\r
 449         }\r
 450 \r
 451         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 452                 bool resetAllRenderstates, IMaterialRendererServices* services) override\r
 453         {\r
 454                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 455 \r
 456                 if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates)\r
 457                 {\r
 458                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1);\r
 459                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);\r
 460                         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_ADD_SIGNED);\r
 461                         glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS);\r
 462                         glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_TEXTURE);\r
 463                 }\r
 464         }\r
 465 \r
 466         void OnUnsetMaterial() override\r
 467         {\r
 468                 Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1);\r
 469                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 470                 Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE0);\r
 471         }\r
 472 };\r
 473 \r
 474 \r
 475 //! sphere map material renderer\r
 476 class COGLES1MaterialRenderer_SPHERE_MAP : public COGLES1MaterialRenderer\r
 477 {\r
 478 public:\r
 479 \r
 480         COGLES1MaterialRenderer_SPHERE_MAP(video::COGLES1Driver* d)\r
 481                 : COGLES1MaterialRenderer(d) {}\r
 482 \r
 483         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 484                 bool resetAllRenderstates, IMaterialRendererServices* services)\r
 485         {\r
 486                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 487 \r
 488                 if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates)\r
 489                 {\r
 490 //                      glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);\r
 491 //                      glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);\r
 492 \r
 493 //                      glEnable(GL_TEXTURE_GEN_S);\r
 494 //                      glEnable(GL_TEXTURE_GEN_T);\r
 495                 }\r
 496         }\r
 497 \r
 498         virtual void OnUnsetMaterial()\r
 499         {\r
 500 //              glDisable(GL_TEXTURE_GEN_S);\r
 501 //              glDisable(GL_TEXTURE_GEN_T);\r
 502         }\r
 503 };\r
 504 \r
 505 \r
 506 //! reflection 2 layer material renderer\r
 507 class COGLES1MaterialRenderer_REFLECTION_2_LAYER : public COGLES1MaterialRenderer\r
 508 {\r
 509 public:\r
 510 \r
 511         COGLES1MaterialRenderer_REFLECTION_2_LAYER(video::COGLES1Driver* d)\r
 512                 : COGLES1MaterialRenderer(d) {}\r
 513 \r
 514         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 515                 bool resetAllRenderstates, IMaterialRendererServices* services)\r
 516         {\r
 517                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 518 \r
 519                 if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates)\r
 520                 {\r
 521                         if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 522                         {\r
 523                                 Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1);\r
 524                                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);\r
 525                                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);\r
 526                                 glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS);\r
 527                                 glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_TEXTURE);\r
 528 \r
 529                         }\r
 530 //                      glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);\r
 531 //                      glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);\r
 532 //                      glEnable(GL_TEXTURE_GEN_S);\r
 533 //                      glEnable(GL_TEXTURE_GEN_T);\r
 534                 }\r
 535         }\r
 536 \r
 537         virtual void OnUnsetMaterial()\r
 538         {\r
 539                 if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 540                 {\r
 541                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1);\r
 542                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 543                 }\r
 544 //              glDisable(GL_TEXTURE_GEN_S);\r
 545 //              glDisable(GL_TEXTURE_GEN_T);\r
 546                 if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 547                 {\r
 548                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE0);\r
 549                 }\r
 550         }\r
 551 };\r
 552 \r
 553 \r
 554 //! reflection 2 layer material renderer\r
 555 class COGLES1MaterialRenderer_TRANSPARENT_REFLECTION_2_LAYER : public COGLES1MaterialRenderer\r
 556 {\r
 557 public:\r
 558 \r
 559         COGLES1MaterialRenderer_TRANSPARENT_REFLECTION_2_LAYER(video::COGLES1Driver* d)\r
 560                 : COGLES1MaterialRenderer(d) {}\r
 561 \r
 562         virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r
 563                 bool resetAllRenderstates, IMaterialRendererServices* services)\r
 564         {\r
 565                 Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);\r
 566 \r
 567                 Driver->getCacheHandler()->setBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_COLOR);\r
 568                 Driver->getCacheHandler()->setBlend(true);\r
 569 \r
 570                 if (material.MaterialType != lastMaterial.MaterialType || resetAllRenderstates)\r
 571                 {\r
 572                         if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 573                         {\r
 574                                 Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1);\r
 575                                 glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);\r
 576                                 glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);\r
 577                                 glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS);\r
 578                                 glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_TEXTURE);\r
 579                         }\r
 580 //                      glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);\r
 581 //                      glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);\r
 582 //                      glEnable(GL_TEXTURE_GEN_S);\r
 583 //                      glEnable(GL_TEXTURE_GEN_T);\r
 584                 }\r
 585         }\r
 586 \r
 587         virtual void OnUnsetMaterial()\r
 588         {\r
 589                 if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 590                 {\r
 591                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE1);\r
 592                         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);\r
 593                 }\r
 594 //              glDisable(GL_TEXTURE_GEN_S);\r
 595 //              glDisable(GL_TEXTURE_GEN_T);\r
 596                 if (Driver->queryFeature(EVDF_MULTITEXTURE))\r
 597                 {\r
 598                         Driver->getCacheHandler()->setActiveTexture(GL_TEXTURE0);\r
 599                 }\r
 600                 Driver->getCacheHandler()->setBlend(false);\r
 601         }\r
 602 \r
 603         //! Returns if the material is transparent.\r
 604         virtual bool isTransparent() const\r
 605         {\r
 606                 return true;\r
 607         }\r
 608 };\r
 609 \r
 610 } // end namespace video\r
 611 } // end namespace irr\r
 612 \r
 613 #endif\r
 614 #endif\r