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