source/Irrlicht/OpenGL/Driver.cpp

   1 // Copyright (C) 2023 Vitaliy Lobachevskiy\r
   2 // Copyright (C) 2014 Patryk Nadrowski\r
   3 // Copyright (C) 2009-2010 Amundis\r
   4 // This file is part of the "Irrlicht Engine".\r
   5 // For conditions of distribution and use, see copyright notice in Irrlicht.h\r
   6 \r
   7 #include "Driver.h"\r
   8 #include "CNullDriver.h"\r
   9 #include "IContextManager.h"\r
  10 \r
  11 #include "COpenGLCoreTexture.h"\r
  12 #include "COpenGLCoreRenderTarget.h"\r
  13 #include "COpenGLCoreCacheHandler.h"\r
  14 \r
  15 #include "MaterialRenderer.h"\r
  16 #include "FixedPipelineRenderer.h"\r
  17 #include "Renderer2D.h"\r
  18 \r
  19 #include "EVertexAttributes.h"\r
  20 #include "CImage.h"\r
  21 #include "os.h"\r
  22 \r
  23 #ifdef _IRR_COMPILE_WITH_ANDROID_DEVICE_\r
  24 #include "android_native_app_glue.h"\r
  25 #endif\r
  26 \r
  27 #include "mt_opengl.h"\r
  28 \r
  29 namespace irr\r
  30 {\r
  31 namespace video\r
  32 {\r
  33 \r
  34 void APIENTRY COpenGL3Driver::debugCb(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam)\r
  35 {\r
  36         ((COpenGL3Driver *)userParam)->debugCb(source, type, id, severity, length, message);\r
  37 }\r
  38 \r
  39 void COpenGL3Driver::debugCb(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message)\r
  40 {\r
  41         printf("%04x %04x %x %x %.*s\n", source, type, id, severity, length, message);\r
  42 }\r
  43 \r
  44 COpenGL3Driver::COpenGL3Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager) :\r
  45         CNullDriver(io, params.WindowSize), COpenGL3ExtensionHandler(), CacheHandler(0),\r
  46         Params(params), ResetRenderStates(true), LockRenderStateMode(false), AntiAlias(params.AntiAlias),\r
  47         MaterialRenderer2DActive(0), MaterialRenderer2DTexture(0), MaterialRenderer2DNoTexture(0),\r
  48         CurrentRenderMode(ERM_NONE), Transformation3DChanged(true),\r
  49         OGLES2ShaderPath(params.OGLES2ShaderPath),\r
  50         ColorFormat(ECF_R8G8B8), ContextManager(contextManager)\r
  51 {\r
  52 #ifdef _DEBUG\r
  53         setDebugName("Driver");\r
  54 #endif\r
  55 \r
  56         if (!ContextManager)\r
  57                 return;\r
  58 \r
  59         ContextManager->grab();\r
  60         ContextManager->generateSurface();\r
  61         ContextManager->generateContext();\r
  62         ExposedData = ContextManager->getContext();\r
  63         ContextManager->activateContext(ExposedData, false);\r
  64         GL.LoadAllProcedures(ContextManager);\r
  65         GL.DebugMessageCallback(debugCb, this);\r
  66 }\r
  67 \r
  68 COpenGL3Driver::~COpenGL3Driver()\r
  69 {\r
  70         deleteMaterialRenders();\r
  71 \r
  72         CacheHandler->getTextureCache().clear();\r
  73 \r
  74         removeAllRenderTargets();\r
  75         deleteAllTextures();\r
  76         removeAllOcclusionQueries();\r
  77         removeAllHardwareBuffers();\r
  78 \r
  79         delete MaterialRenderer2DTexture;\r
  80         delete MaterialRenderer2DNoTexture;\r
  81         delete CacheHandler;\r
  82 \r
  83         if (ContextManager)\r
  84         {\r
  85                 ContextManager->destroyContext();\r
  86                 ContextManager->destroySurface();\r
  87                 ContextManager->terminate();\r
  88                 ContextManager->drop();\r
  89         }\r
  90 }\r
  91 \r
  92         bool COpenGL3Driver::genericDriverInit(const core::dimension2d<u32>& screenSize, bool stencilBuffer)\r
  93         {\r
  94                 Name = glGetString(GL_VERSION);\r
  95                 printVersion();\r
  96 \r
  97                 // print renderer information\r
  98                 VendorName = glGetString(GL_VENDOR);\r
  99                 os::Printer::log(VendorName.c_str(), ELL_INFORMATION);\r
 100 \r
 101                 // load extensions\r
 102                 initExtensions();\r
 103 \r
 104                 // reset cache handler\r
 105                 delete CacheHandler;\r
 106                 CacheHandler = new COpenGL3CacheHandler(this);\r
 107 \r
 108                 StencilBuffer = stencilBuffer;\r
 109 \r
 110                 DriverAttributes->setAttribute("MaxTextures", (s32)Feature.MaxTextureUnits);\r
 111                 DriverAttributes->setAttribute("MaxSupportedTextures", (s32)Feature.MaxTextureUnits);\r
 112 //              DriverAttributes->setAttribute("MaxLights", MaxLights);\r
 113                 DriverAttributes->setAttribute("MaxAnisotropy", MaxAnisotropy);\r
 114 //              DriverAttributes->setAttribute("MaxUserClipPlanes", MaxUserClipPlanes);\r
 115 //              DriverAttributes->setAttribute("MaxAuxBuffers", MaxAuxBuffers);\r
 116 //              DriverAttributes->setAttribute("MaxMultipleRenderTargets", MaxMultipleRenderTargets);\r
 117                 DriverAttributes->setAttribute("MaxIndices", (s32)MaxIndices);\r
 118                 DriverAttributes->setAttribute("MaxTextureSize", (s32)MaxTextureSize);\r
 119                 DriverAttributes->setAttribute("MaxTextureLODBias", MaxTextureLODBias);\r
 120                 DriverAttributes->setAttribute("Version", Version);\r
 121                 DriverAttributes->setAttribute("AntiAlias", AntiAlias);\r
 122 \r
 123                 glPixelStorei(GL_PACK_ALIGNMENT, 1);\r
 124 \r
 125                 UserClipPlane.reallocate(0);\r
 126 \r
 127                 for (s32 i = 0; i < ETS_COUNT; ++i)\r
 128                         setTransform(static_cast<E_TRANSFORMATION_STATE>(i), core::IdentityMatrix);\r
 129 \r
 130                 setAmbientLight(SColorf(0.0f, 0.0f, 0.0f, 0.0f));\r
 131                 glClearDepthf(1.0f);\r
 132 \r
 133                 glHint(GL_GENERATE_MIPMAP_HINT, GL_NICEST);\r
 134                 glFrontFace(GL_CW);\r
 135 \r
 136                 // create material renderers\r
 137                 createMaterialRenderers();\r
 138 \r
 139                 // set the renderstates\r
 140                 setRenderStates3DMode();\r
 141 \r
 142                 // set fog mode\r
 143                 setFog(FogColor, FogType, FogStart, FogEnd, FogDensity, PixelFog, RangeFog);\r
 144 \r
 145                 // create matrix for flipping textures\r
 146                 TextureFlipMatrix.buildTextureTransform(0.0f, core::vector2df(0, 0), core::vector2df(0, 1.0f), core::vector2df(1.0f, -1.0f));\r
 147 \r
 148                 // We need to reset once more at the beginning of the first rendering.\r
 149                 // This fixes problems with intermediate changes to the material during texture load.\r
 150                 ResetRenderStates = true;\r
 151 \r
 152                 testGLError(__LINE__);\r
 153 \r
 154                 return true;\r
 155         }\r
 156 \r
 157         void COpenGL3Driver::loadShaderData(const io::path& vertexShaderName, const io::path& fragmentShaderName, c8** vertexShaderData, c8** fragmentShaderData)\r
 158         {\r
 159                 io::path vsPath(OGLES2ShaderPath);\r
 160                 vsPath += vertexShaderName;\r
 161 \r
 162                 io::path fsPath(OGLES2ShaderPath);\r
 163                 fsPath += fragmentShaderName;\r
 164 \r
 165                 *vertexShaderData = 0;\r
 166                 *fragmentShaderData = 0;\r
 167 \r
 168                 io::IReadFile* vsFile = FileSystem->createAndOpenFile(vsPath);\r
 169                 if ( !vsFile )\r
 170                 {\r
 171                         core::stringw warning(L"Warning: Missing shader files needed to simulate fixed function materials:\n");\r
 172                         warning += core::stringw(vsPath) + L"\n";\r
 173                         warning += L"Shaderpath can be changed in SIrrCreationParamters::OGLES2ShaderPath";\r
 174                         os::Printer::log(warning.c_str(), ELL_WARNING);\r
 175                         return;\r
 176                 }\r
 177 \r
 178                 io::IReadFile* fsFile = FileSystem->createAndOpenFile(fsPath);\r
 179                 if ( !fsFile )\r
 180                 {\r
 181                         core::stringw warning(L"Warning: Missing shader files needed to simulate fixed function materials:\n");\r
 182                         warning += core::stringw(fsPath) + L"\n";\r
 183                         warning += L"Shaderpath can be changed in SIrrCreationParamters::OGLES2ShaderPath";\r
 184                         os::Printer::log(warning.c_str(), ELL_WARNING);\r
 185                         return;\r
 186                 }\r
 187 \r
 188                 long size = vsFile->getSize();\r
 189                 if (size)\r
 190                 {\r
 191                         *vertexShaderData = new c8[size+1];\r
 192                         vsFile->read(*vertexShaderData, size);\r
 193                         (*vertexShaderData)[size] = 0;\r
 194                 }\r
 195 \r
 196                 size = fsFile->getSize();\r
 197                 if (size)\r
 198                 {\r
 199                         // if both handles are the same we must reset the file\r
 200                         if (fsFile == vsFile)\r
 201                                 fsFile->seek(0);\r
 202 \r
 203                         *fragmentShaderData = new c8[size+1];\r
 204                         fsFile->read(*fragmentShaderData, size);\r
 205                         (*fragmentShaderData)[size] = 0;\r
 206                 }\r
 207 \r
 208                 vsFile->drop();\r
 209                 fsFile->drop();\r
 210         }\r
 211 \r
 212         void COpenGL3Driver::createMaterialRenderers()\r
 213         {\r
 214                 // Create callbacks.\r
 215 \r
 216                 COpenGL3MaterialSolidCB* SolidCB = new COpenGL3MaterialSolidCB();\r
 217                 COpenGL3MaterialSolid2CB* Solid2LayerCB = new COpenGL3MaterialSolid2CB();\r
 218                 COpenGL3MaterialLightmapCB* LightmapCB = new COpenGL3MaterialLightmapCB(1.f);\r
 219                 COpenGL3MaterialLightmapCB* LightmapAddCB = new COpenGL3MaterialLightmapCB(1.f);\r
 220                 COpenGL3MaterialLightmapCB* LightmapM2CB = new COpenGL3MaterialLightmapCB(2.f);\r
 221                 COpenGL3MaterialLightmapCB* LightmapM4CB = new COpenGL3MaterialLightmapCB(4.f);\r
 222                 COpenGL3MaterialLightmapCB* LightmapLightingCB = new COpenGL3MaterialLightmapCB(1.f);\r
 223                 COpenGL3MaterialLightmapCB* LightmapLightingM2CB = new COpenGL3MaterialLightmapCB(2.f);\r
 224                 COpenGL3MaterialLightmapCB* LightmapLightingM4CB = new COpenGL3MaterialLightmapCB(4.f);\r
 225                 COpenGL3MaterialSolid2CB* DetailMapCB = new COpenGL3MaterialSolid2CB();\r
 226                 COpenGL3MaterialReflectionCB* SphereMapCB = new COpenGL3MaterialReflectionCB();\r
 227                 COpenGL3MaterialReflectionCB* Reflection2LayerCB = new COpenGL3MaterialReflectionCB();\r
 228                 COpenGL3MaterialSolidCB* TransparentAddColorCB = new COpenGL3MaterialSolidCB();\r
 229                 COpenGL3MaterialSolidCB* TransparentAlphaChannelCB = new COpenGL3MaterialSolidCB();\r
 230                 COpenGL3MaterialSolidCB* TransparentAlphaChannelRefCB = new COpenGL3MaterialSolidCB();\r
 231                 COpenGL3MaterialSolidCB* TransparentVertexAlphaCB = new COpenGL3MaterialSolidCB();\r
 232                 COpenGL3MaterialReflectionCB* TransparentReflection2LayerCB = new COpenGL3MaterialReflectionCB();\r
 233                 COpenGL3MaterialOneTextureBlendCB* OneTextureBlendCB = new COpenGL3MaterialOneTextureBlendCB();\r
 234 \r
 235                 // Create built-in materials.\r
 236 \r
 237                 core::stringc VertexShader = OGLES2ShaderPath + "Solid.vsh";\r
 238                 core::stringc FragmentShader = OGLES2ShaderPath + "Solid.fsh";\r
 239 \r
 240                 addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",\r
 241                         EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, SolidCB, EMT_SOLID, 0);\r
 242 \r
 243                 VertexShader = OGLES2ShaderPath + "Solid2.vsh";\r
 244                 FragmentShader = OGLES2ShaderPath + "Solid2Layer.fsh";\r
 245 \r
 246                 addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",\r
 247                         EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, Solid2LayerCB, EMT_SOLID, 0);\r
 248 \r
 249                 VertexShader = OGLES2ShaderPath + "Solid2.vsh";\r
 250                 FragmentShader = OGLES2ShaderPath + "LightmapModulate.fsh";\r
 251 \r
 252                 addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",\r
 253                         EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, LightmapCB, EMT_SOLID, 0);\r
 254 \r
 255                 FragmentShader = OGLES2ShaderPath + "LightmapAdd.fsh";\r
 256 \r
 257                 addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",\r
 258                         EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, LightmapAddCB, EMT_SOLID, 0);\r
 259 \r
 260                 FragmentShader = OGLES2ShaderPath + "LightmapModulate.fsh";\r
 261 \r
 262                 addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",\r
 263                         EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, LightmapM2CB, EMT_SOLID, 0);\r
 264 \r
 265                 addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",\r
 266                         EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, LightmapM4CB, EMT_SOLID, 0);\r
 267 \r
 268                 addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",\r
 269                         EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, LightmapLightingCB, EMT_SOLID, 0);\r
 270 \r
 271                 addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",\r
 272                         EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, LightmapLightingM2CB, EMT_SOLID, 0);\r
 273 \r
 274                 addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",\r
 275                         EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, LightmapLightingM4CB, EMT_SOLID, 0);\r
 276 \r
 277                 VertexShader = OGLES2ShaderPath + "Solid2.vsh";\r
 278                 FragmentShader = OGLES2ShaderPath + "DetailMap.fsh";\r
 279 \r
 280                 addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",\r
 281                         EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, DetailMapCB, EMT_SOLID, 0);\r
 282 \r
 283                 VertexShader = OGLES2ShaderPath + "SphereMap.vsh";\r
 284                 FragmentShader = OGLES2ShaderPath + "SphereMap.fsh";\r
 285 \r
 286                 addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",\r
 287                         EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, SphereMapCB, EMT_SOLID, 0);\r
 288 \r
 289                 VertexShader = OGLES2ShaderPath + "Reflection2Layer.vsh";\r
 290                 FragmentShader = OGLES2ShaderPath + "Reflection2Layer.fsh";\r
 291 \r
 292                 addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",\r
 293                         EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, Reflection2LayerCB, EMT_SOLID, 0);\r
 294 \r
 295                 VertexShader = OGLES2ShaderPath + "Solid.vsh";\r
 296                 FragmentShader = OGLES2ShaderPath + "Solid.fsh";\r
 297 \r
 298                 addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",\r
 299                         EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, TransparentAddColorCB, EMT_TRANSPARENT_ADD_COLOR, 0);\r
 300 \r
 301                 FragmentShader = OGLES2ShaderPath + "TransparentAlphaChannel.fsh";\r
 302                 addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",\r
 303                         EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, TransparentAlphaChannelCB, EMT_TRANSPARENT_ALPHA_CHANNEL, 0);\r
 304 \r
 305                 FragmentShader = OGLES2ShaderPath + "TransparentAlphaChannelRef.fsh";\r
 306 \r
 307                 addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",\r
 308                         EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, TransparentAlphaChannelRefCB, EMT_SOLID, 0);\r
 309 \r
 310                 FragmentShader = OGLES2ShaderPath + "TransparentVertexAlpha.fsh";\r
 311 \r
 312                 addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",\r
 313                         EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, TransparentVertexAlphaCB, EMT_TRANSPARENT_ALPHA_CHANNEL, 0);\r
 314 \r
 315                 VertexShader = OGLES2ShaderPath + "Reflection2Layer.vsh";\r
 316                 FragmentShader = OGLES2ShaderPath + "Reflection2Layer.fsh";\r
 317 \r
 318                 addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",\r
 319                         EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, TransparentReflection2LayerCB, EMT_TRANSPARENT_ALPHA_CHANNEL, 0);\r
 320 \r
 321                 VertexShader = OGLES2ShaderPath + "Solid.vsh";\r
 322                 FragmentShader = OGLES2ShaderPath + "OneTextureBlend.fsh";\r
 323 \r
 324                 addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",\r
 325                         EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, OneTextureBlendCB, EMT_ONETEXTURE_BLEND, 0);\r
 326 \r
 327                 // Drop callbacks.\r
 328 \r
 329                 SolidCB->drop();\r
 330                 Solid2LayerCB->drop();\r
 331                 LightmapCB->drop();\r
 332                 LightmapAddCB->drop();\r
 333                 LightmapM2CB->drop();\r
 334                 LightmapM4CB->drop();\r
 335                 LightmapLightingCB->drop();\r
 336                 LightmapLightingM2CB->drop();\r
 337                 LightmapLightingM4CB->drop();\r
 338                 DetailMapCB->drop();\r
 339                 SphereMapCB->drop();\r
 340                 Reflection2LayerCB->drop();\r
 341                 TransparentAddColorCB->drop();\r
 342                 TransparentAlphaChannelCB->drop();\r
 343                 TransparentAlphaChannelRefCB->drop();\r
 344                 TransparentVertexAlphaCB->drop();\r
 345                 TransparentReflection2LayerCB->drop();\r
 346                 OneTextureBlendCB->drop();\r
 347 \r
 348                 // Create 2D material renderers\r
 349 \r
 350                 c8* vs2DData = 0;\r
 351                 c8* fs2DData = 0;\r
 352                 loadShaderData(io::path("Renderer2D.vsh"), io::path("Renderer2D.fsh"), &vs2DData, &fs2DData);\r
 353                 MaterialRenderer2DTexture = new COpenGL3Renderer2D(vs2DData, fs2DData, this, true);\r
 354                 delete[] vs2DData;\r
 355                 delete[] fs2DData;\r
 356                 vs2DData = 0;\r
 357                 fs2DData = 0;\r
 358 \r
 359                 loadShaderData(io::path("Renderer2D.vsh"), io::path("Renderer2D_noTex.fsh"), &vs2DData, &fs2DData);\r
 360                 MaterialRenderer2DNoTexture = new COpenGL3Renderer2D(vs2DData, fs2DData, this, false);\r
 361                 delete[] vs2DData;\r
 362                 delete[] fs2DData;\r
 363         }\r
 364 \r
 365         bool COpenGL3Driver::setMaterialTexture(irr::u32 layerIdx, const irr::video::ITexture* texture)\r
 366         {\r
 367                 Material.TextureLayer[layerIdx].Texture = const_cast<ITexture*>(texture); // function uses const-pointer for texture because all draw functions use const-pointers already\r
 368                 return CacheHandler->getTextureCache().set(0, texture);\r
 369         }\r
 370 \r
 371         bool COpenGL3Driver::beginScene(u16 clearFlag, SColor clearColor, f32 clearDepth, u8 clearStencil, const SExposedVideoData& videoData, core::rect<s32>* sourceRect)\r
 372         {\r
 373                 CNullDriver::beginScene(clearFlag, clearColor, clearDepth, clearStencil, videoData, sourceRect);\r
 374 \r
 375                 if (ContextManager)\r
 376                         ContextManager->activateContext(videoData, true);\r
 377 \r
 378                 clearBuffers(clearFlag, clearColor, clearDepth, clearStencil);\r
 379 \r
 380                 return true;\r
 381         }\r
 382 \r
 383         bool COpenGL3Driver::endScene()\r
 384         {\r
 385                 CNullDriver::endScene();\r
 386 \r
 387                 glFlush();\r
 388 \r
 389                 if (ContextManager)\r
 390                         return ContextManager->swapBuffers();\r
 391 \r
 392                 return false;\r
 393         }\r
 394 \r
 395 \r
 396         //! Returns the transformation set by setTransform\r
 397         const core::matrix4& COpenGL3Driver::getTransform(E_TRANSFORMATION_STATE state) const\r
 398         {\r
 399                 return Matrices[state];\r
 400         }\r
 401 \r
 402 \r
 403         //! sets transformation\r
 404         void COpenGL3Driver::setTransform(E_TRANSFORMATION_STATE state, const core::matrix4& mat)\r
 405         {\r
 406                 Matrices[state] = mat;\r
 407                 Transformation3DChanged = true;\r
 408         }\r
 409 \r
 410 \r
 411         bool COpenGL3Driver::updateVertexHardwareBuffer(SHWBufferLink_opengl *HWBuffer)\r
 412         {\r
 413                 if (!HWBuffer)\r
 414                         return false;\r
 415 \r
 416                 const scene::IMeshBuffer* mb = HWBuffer->MeshBuffer;\r
 417                 const void* vertices = mb->getVertices();\r
 418                 const u32 vertexCount = mb->getVertexCount();\r
 419                 const E_VERTEX_TYPE vType = mb->getVertexType();\r
 420                 const u32 vertexSize = getVertexPitchFromType(vType);\r
 421 \r
 422                 const void *buffer = vertices;\r
 423                 size_t bufferSize = vertexSize * vertexCount;\r
 424 \r
 425                 //get or create buffer\r
 426                 bool newBuffer = false;\r
 427                 if (!HWBuffer->vbo_verticesID)\r
 428                 {\r
 429                         glGenBuffers(1, &HWBuffer->vbo_verticesID);\r
 430                         if (!HWBuffer->vbo_verticesID) return false;\r
 431                         newBuffer = true;\r
 432                 }\r
 433                 else if (HWBuffer->vbo_verticesSize < bufferSize)\r
 434                 {\r
 435                         newBuffer = true;\r
 436                 }\r
 437 \r
 438                 glBindBuffer(GL_ARRAY_BUFFER, HWBuffer->vbo_verticesID);\r
 439 \r
 440                 // copy data to graphics card\r
 441                 if (!newBuffer)\r
 442                         glBufferSubData(GL_ARRAY_BUFFER, 0, bufferSize, buffer);\r
 443                 else\r
 444                 {\r
 445                         HWBuffer->vbo_verticesSize = bufferSize;\r
 446 \r
 447                         if (HWBuffer->Mapped_Vertex == scene::EHM_STATIC)\r
 448                                 glBufferData(GL_ARRAY_BUFFER, bufferSize, buffer, GL_STATIC_DRAW);\r
 449                         else\r
 450                                 glBufferData(GL_ARRAY_BUFFER, bufferSize, buffer, GL_DYNAMIC_DRAW);\r
 451                 }\r
 452 \r
 453                 glBindBuffer(GL_ARRAY_BUFFER, 0);\r
 454 \r
 455                 return (!testGLError(__LINE__));\r
 456         }\r
 457 \r
 458 \r
 459         bool COpenGL3Driver::updateIndexHardwareBuffer(SHWBufferLink_opengl *HWBuffer)\r
 460         {\r
 461                 if (!HWBuffer)\r
 462                         return false;\r
 463 \r
 464                 const scene::IMeshBuffer* mb = HWBuffer->MeshBuffer;\r
 465 \r
 466                 const void* indices = mb->getIndices();\r
 467                 u32 indexCount = mb->getIndexCount();\r
 468 \r
 469                 GLenum indexSize;\r
 470                 switch (mb->getIndexType())\r
 471                 {\r
 472                         case(EIT_16BIT):\r
 473                         {\r
 474                                 indexSize = sizeof(u16);\r
 475                                 break;\r
 476                         }\r
 477                         case(EIT_32BIT):\r
 478                         {\r
 479                                 indexSize = sizeof(u32);\r
 480                                 break;\r
 481                         }\r
 482                         default:\r
 483                         {\r
 484                                 return false;\r
 485                         }\r
 486                 }\r
 487 \r
 488                 //get or create buffer\r
 489                 bool newBuffer = false;\r
 490                 if (!HWBuffer->vbo_indicesID)\r
 491                 {\r
 492                         glGenBuffers(1, &HWBuffer->vbo_indicesID);\r
 493                         if (!HWBuffer->vbo_indicesID) return false;\r
 494                         newBuffer = true;\r
 495                 }\r
 496                 else if (HWBuffer->vbo_indicesSize < indexCount*indexSize)\r
 497                 {\r
 498                         newBuffer = true;\r
 499                 }\r
 500 \r
 501                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, HWBuffer->vbo_indicesID);\r
 502 \r
 503                 // copy data to graphics card\r
 504                 if (!newBuffer)\r
 505                         glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, indexCount * indexSize, indices);\r
 506                 else\r
 507                 {\r
 508                         HWBuffer->vbo_indicesSize = indexCount * indexSize;\r
 509 \r
 510                         if (HWBuffer->Mapped_Index == scene::EHM_STATIC)\r
 511                                 glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexCount * indexSize, indices, GL_STATIC_DRAW);\r
 512                         else\r
 513                                 glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexCount * indexSize, indices, GL_DYNAMIC_DRAW);\r
 514                 }\r
 515 \r
 516                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);\r
 517 \r
 518                 return (!testGLError(__LINE__));\r
 519         }\r
 520 \r
 521 \r
 522         //! updates hardware buffer if needed\r
 523         bool COpenGL3Driver::updateHardwareBuffer(SHWBufferLink *HWBuffer)\r
 524         {\r
 525                 if (!HWBuffer)\r
 526                         return false;\r
 527 \r
 528                 if (HWBuffer->Mapped_Vertex != scene::EHM_NEVER)\r
 529                 {\r
 530                         if (HWBuffer->ChangedID_Vertex != HWBuffer->MeshBuffer->getChangedID_Vertex()\r
 531                                 || !static_cast<SHWBufferLink_opengl*>(HWBuffer)->vbo_verticesID)\r
 532                         {\r
 533 \r
 534                                 HWBuffer->ChangedID_Vertex = HWBuffer->MeshBuffer->getChangedID_Vertex();\r
 535 \r
 536                                 if (!updateVertexHardwareBuffer(static_cast<SHWBufferLink_opengl*>(HWBuffer)))\r
 537                                         return false;\r
 538                         }\r
 539                 }\r
 540 \r
 541                 if (HWBuffer->Mapped_Index != scene::EHM_NEVER)\r
 542                 {\r
 543                         if (HWBuffer->ChangedID_Index != HWBuffer->MeshBuffer->getChangedID_Index()\r
 544                                 || !static_cast<SHWBufferLink_opengl*>(HWBuffer)->vbo_indicesID)\r
 545                         {\r
 546 \r
 547                                 HWBuffer->ChangedID_Index = HWBuffer->MeshBuffer->getChangedID_Index();\r
 548 \r
 549                                 if (!updateIndexHardwareBuffer((SHWBufferLink_opengl*)HWBuffer))\r
 550                                         return false;\r
 551                         }\r
 552                 }\r
 553 \r
 554                 return true;\r
 555         }\r
 556 \r
 557 \r
 558         //! Create hardware buffer from meshbuffer\r
 559         COpenGL3Driver::SHWBufferLink *COpenGL3Driver::createHardwareBuffer(const scene::IMeshBuffer* mb)\r
 560         {\r
 561                 if (!mb || (mb->getHardwareMappingHint_Index() == scene::EHM_NEVER && mb->getHardwareMappingHint_Vertex() == scene::EHM_NEVER))\r
 562                         return 0;\r
 563 \r
 564                 SHWBufferLink_opengl *HWBuffer = new SHWBufferLink_opengl(mb);\r
 565 \r
 566                 //add to map\r
 567                 HWBuffer->listPosition = HWBufferList.insert(HWBufferList.end(), HWBuffer);\r
 568 \r
 569                 HWBuffer->ChangedID_Vertex = HWBuffer->MeshBuffer->getChangedID_Vertex();\r
 570                 HWBuffer->ChangedID_Index = HWBuffer->MeshBuffer->getChangedID_Index();\r
 571                 HWBuffer->Mapped_Vertex = mb->getHardwareMappingHint_Vertex();\r
 572                 HWBuffer->Mapped_Index = mb->getHardwareMappingHint_Index();\r
 573                 HWBuffer->vbo_verticesID = 0;\r
 574                 HWBuffer->vbo_indicesID = 0;\r
 575                 HWBuffer->vbo_verticesSize = 0;\r
 576                 HWBuffer->vbo_indicesSize = 0;\r
 577 \r
 578                 if (!updateHardwareBuffer(HWBuffer))\r
 579                 {\r
 580                         deleteHardwareBuffer(HWBuffer);\r
 581                         return 0;\r
 582                 }\r
 583 \r
 584                 return HWBuffer;\r
 585         }\r
 586 \r
 587 \r
 588         void COpenGL3Driver::deleteHardwareBuffer(SHWBufferLink *_HWBuffer)\r
 589         {\r
 590                 if (!_HWBuffer)\r
 591                         return;\r
 592 \r
 593                 SHWBufferLink_opengl *HWBuffer = static_cast<SHWBufferLink_opengl*>(_HWBuffer);\r
 594                 if (HWBuffer->vbo_verticesID)\r
 595                 {\r
 596                         glDeleteBuffers(1, &HWBuffer->vbo_verticesID);\r
 597                         HWBuffer->vbo_verticesID = 0;\r
 598                 }\r
 599                 if (HWBuffer->vbo_indicesID)\r
 600                 {\r
 601                         glDeleteBuffers(1, &HWBuffer->vbo_indicesID);\r
 602                         HWBuffer->vbo_indicesID = 0;\r
 603                 }\r
 604 \r
 605                 CNullDriver::deleteHardwareBuffer(_HWBuffer);\r
 606         }\r
 607 \r
 608 \r
 609         //! Draw hardware buffer\r
 610         void COpenGL3Driver::drawHardwareBuffer(SHWBufferLink *_HWBuffer)\r
 611         {\r
 612                 if (!_HWBuffer)\r
 613                         return;\r
 614 \r
 615                 SHWBufferLink_opengl *HWBuffer = static_cast<SHWBufferLink_opengl*>(_HWBuffer);\r
 616 \r
 617                 updateHardwareBuffer(HWBuffer); //check if update is needed\r
 618 \r
 619                 const scene::IMeshBuffer* mb = HWBuffer->MeshBuffer;\r
 620                 const void *vertices = mb->getVertices();\r
 621                 const void *indexList = mb->getIndices();\r
 622 \r
 623                 if (HWBuffer->Mapped_Vertex != scene::EHM_NEVER)\r
 624                 {\r
 625                         glBindBuffer(GL_ARRAY_BUFFER, HWBuffer->vbo_verticesID);\r
 626                         vertices = 0;\r
 627                 }\r
 628 \r
 629                 if (HWBuffer->Mapped_Index != scene::EHM_NEVER)\r
 630                 {\r
 631                         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, HWBuffer->vbo_indicesID);\r
 632                         indexList = 0;\r
 633                 }\r
 634 \r
 635 \r
 636                 drawVertexPrimitiveList(vertices, mb->getVertexCount(),\r
 637                                 indexList, mb->getPrimitiveCount(),\r
 638                                 mb->getVertexType(), mb->getPrimitiveType(),\r
 639                                 mb->getIndexType());\r
 640 \r
 641                 if (HWBuffer->Mapped_Vertex != scene::EHM_NEVER)\r
 642                         glBindBuffer(GL_ARRAY_BUFFER, 0);\r
 643 \r
 644                 if (HWBuffer->Mapped_Index != scene::EHM_NEVER)\r
 645                         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);\r
 646         }\r
 647 \r
 648 \r
 649         IRenderTarget* COpenGL3Driver::addRenderTarget()\r
 650         {\r
 651                 COpenGL3RenderTarget* renderTarget = new COpenGL3RenderTarget(this);\r
 652                 RenderTargets.push_back(renderTarget);\r
 653 \r
 654                 return renderTarget;\r
 655         }\r
 656 \r
 657 \r
 658         // small helper function to create vertex buffer object adress offsets\r
 659         static inline u8* buffer_offset(const long offset)\r
 660         {\r
 661                 return ((u8*)0 + offset);\r
 662         }\r
 663 \r
 664 \r
 665         //! draws a vertex primitive list\r
 666         void COpenGL3Driver::drawVertexPrimitiveList(const void* vertices, u32 vertexCount,\r
 667                         const void* indexList, u32 primitiveCount,\r
 668                         E_VERTEX_TYPE vType, scene::E_PRIMITIVE_TYPE pType, E_INDEX_TYPE iType)\r
 669         {\r
 670                 if (!primitiveCount || !vertexCount)\r
 671                         return;\r
 672 \r
 673                 if (!checkPrimitiveCount(primitiveCount))\r
 674                         return;\r
 675 \r
 676                 CNullDriver::drawVertexPrimitiveList(vertices, vertexCount, indexList, primitiveCount, vType, pType, iType);\r
 677 \r
 678                 setRenderStates3DMode();\r
 679 \r
 680                 glEnableVertexAttribArray(EVA_POSITION);\r
 681                 glEnableVertexAttribArray(EVA_COLOR);\r
 682                 glEnableVertexAttribArray(EVA_NORMAL);\r
 683                 glEnableVertexAttribArray(EVA_TCOORD0);\r
 684 \r
 685                 switch (vType)\r
 686                 {\r
 687                 case EVT_STANDARD:\r
 688                         if (vertices)\r
 689                         {\r
 690                                 glVertexAttribPointer(EVA_POSITION, 3, GL_FLOAT, false, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].Pos);\r
 691                                 glVertexAttribPointer(EVA_NORMAL, 3, GL_FLOAT, false, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].Normal);\r
 692                                 glVertexAttribPointer(EVA_COLOR, 4, GL_UNSIGNED_BYTE, true, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].Color);\r
 693                                 glVertexAttribPointer(EVA_TCOORD0, 2, GL_FLOAT, false, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].TCoords);\r
 694                         }\r
 695                         else\r
 696                         {\r
 697                                 glVertexAttribPointer(EVA_POSITION, 3, GL_FLOAT, false, sizeof(S3DVertex), 0);\r
 698                                 glVertexAttribPointer(EVA_NORMAL, 3, GL_FLOAT, false, sizeof(S3DVertex), buffer_offset(12));\r
 699                                 glVertexAttribPointer(EVA_COLOR, 4, GL_UNSIGNED_BYTE, true, sizeof(S3DVertex), buffer_offset(24));\r
 700                                 glVertexAttribPointer(EVA_TCOORD0, 2, GL_FLOAT, false, sizeof(S3DVertex), buffer_offset(28));\r
 701                         }\r
 702 \r
 703                         break;\r
 704                 case EVT_2TCOORDS:\r
 705                         glEnableVertexAttribArray(EVA_TCOORD1);\r
 706 \r
 707                         if (vertices)\r
 708                         {\r
 709                                 glVertexAttribPointer(EVA_POSITION, 3, GL_FLOAT, false, sizeof(S3DVertex2TCoords), &(static_cast<const S3DVertex2TCoords*>(vertices))[0].Pos);\r
 710                                 glVertexAttribPointer(EVA_NORMAL, 3, GL_FLOAT, false, sizeof(S3DVertex2TCoords), &(static_cast<const S3DVertex2TCoords*>(vertices))[0].Normal);\r
 711                                 glVertexAttribPointer(EVA_COLOR, 4, GL_UNSIGNED_BYTE, true, sizeof(S3DVertex2TCoords), &(static_cast<const S3DVertex2TCoords*>(vertices))[0].Color);\r
 712                                 glVertexAttribPointer(EVA_TCOORD0, 2, GL_FLOAT, false, sizeof(S3DVertex2TCoords), &(static_cast<const S3DVertex2TCoords*>(vertices))[0].TCoords);\r
 713                                 glVertexAttribPointer(EVA_TCOORD1, 2, GL_FLOAT, false, sizeof(S3DVertex2TCoords), &(static_cast<const S3DVertex2TCoords*>(vertices))[0].TCoords2);\r
 714                         }\r
 715                         else\r
 716                         {\r
 717                                 glVertexAttribPointer(EVA_POSITION, 3, GL_FLOAT, false, sizeof(S3DVertex2TCoords), buffer_offset(0));\r
 718                                 glVertexAttribPointer(EVA_NORMAL, 3, GL_FLOAT, false, sizeof(S3DVertex2TCoords), buffer_offset(12));\r
 719                                 glVertexAttribPointer(EVA_COLOR, 4, GL_UNSIGNED_BYTE, true, sizeof(S3DVertex2TCoords), buffer_offset(24));\r
 720                                 glVertexAttribPointer(EVA_TCOORD0, 2, GL_FLOAT, false, sizeof(S3DVertex2TCoords), buffer_offset(28));\r
 721                                 glVertexAttribPointer(EVA_TCOORD1, 2, GL_FLOAT, false, sizeof(S3DVertex2TCoords), buffer_offset(36));\r
 722                         }\r
 723                         break;\r
 724                 case EVT_TANGENTS:\r
 725                         glEnableVertexAttribArray(EVA_TANGENT);\r
 726                         glEnableVertexAttribArray(EVA_BINORMAL);\r
 727 \r
 728                         if (vertices)\r
 729                         {\r
 730                                 glVertexAttribPointer(EVA_POSITION, 3, GL_FLOAT, false, sizeof(S3DVertexTangents), &(static_cast<const S3DVertexTangents*>(vertices))[0].Pos);\r
 731                                 glVertexAttribPointer(EVA_NORMAL, 3, GL_FLOAT, false, sizeof(S3DVertexTangents), &(static_cast<const S3DVertexTangents*>(vertices))[0].Normal);\r
 732                                 glVertexAttribPointer(EVA_COLOR, 4, GL_UNSIGNED_BYTE, true, sizeof(S3DVertexTangents), &(static_cast<const S3DVertexTangents*>(vertices))[0].Color);\r
 733                                 glVertexAttribPointer(EVA_TCOORD0, 2, GL_FLOAT, false, sizeof(S3DVertexTangents), &(static_cast<const S3DVertexTangents*>(vertices))[0].TCoords);\r
 734                                 glVertexAttribPointer(EVA_TANGENT, 3, GL_FLOAT, false, sizeof(S3DVertexTangents), &(static_cast<const S3DVertexTangents*>(vertices))[0].Tangent);\r
 735                                 glVertexAttribPointer(EVA_BINORMAL, 3, GL_FLOAT, false, sizeof(S3DVertexTangents), &(static_cast<const S3DVertexTangents*>(vertices))[0].Binormal);\r
 736                         }\r
 737                         else\r
 738                         {\r
 739                                 glVertexAttribPointer(EVA_POSITION, 3, GL_FLOAT, false, sizeof(S3DVertexTangents), buffer_offset(0));\r
 740                                 glVertexAttribPointer(EVA_NORMAL, 3, GL_FLOAT, false, sizeof(S3DVertexTangents), buffer_offset(12));\r
 741                                 glVertexAttribPointer(EVA_COLOR, 4, GL_UNSIGNED_BYTE, true, sizeof(S3DVertexTangents), buffer_offset(24));\r
 742                                 glVertexAttribPointer(EVA_TCOORD0, 2, GL_FLOAT, false, sizeof(S3DVertexTangents), buffer_offset(28));\r
 743                                 glVertexAttribPointer(EVA_TANGENT, 3, GL_FLOAT, false, sizeof(S3DVertexTangents), buffer_offset(36));\r
 744                                 glVertexAttribPointer(EVA_BINORMAL, 3, GL_FLOAT, false, sizeof(S3DVertexTangents), buffer_offset(48));\r
 745                         }\r
 746                         break;\r
 747                 }\r
 748 \r
 749                 GLenum indexSize = 0;\r
 750 \r
 751                 switch (iType)\r
 752                 {\r
 753                         case(EIT_16BIT):\r
 754                         {\r
 755                                 indexSize = GL_UNSIGNED_SHORT;\r
 756                                 break;\r
 757                         }\r
 758                         case(EIT_32BIT):\r
 759                         {\r
 760 #ifdef GL_OES_element_index_uint\r
 761 #ifndef GL_UNSIGNED_INT\r
 762 #define GL_UNSIGNED_INT 0x1405\r
 763 #endif\r
 764                                 if (FeatureAvailable[COGLESCoreExtensionHandler::IRR_GL_OES_element_index_uint])\r
 765                                         indexSize = GL_UNSIGNED_INT;\r
 766                                 else\r
 767 #endif\r
 768                                         indexSize = GL_UNSIGNED_SHORT;\r
 769                                 break;\r
 770                         }\r
 771                 }\r
 772 \r
 773                 switch (pType)\r
 774                 {\r
 775                         case scene::EPT_POINTS:\r
 776                         case scene::EPT_POINT_SPRITES:\r
 777                                 glDrawArrays(GL_POINTS, 0, primitiveCount);\r
 778                                 break;\r
 779                         case scene::EPT_LINE_STRIP:\r
 780                                 glDrawElements(GL_LINE_STRIP, primitiveCount + 1, indexSize, indexList);\r
 781                                 break;\r
 782                         case scene::EPT_LINE_LOOP:\r
 783                                 glDrawElements(GL_LINE_LOOP, primitiveCount, indexSize, indexList);\r
 784                                 break;\r
 785                         case scene::EPT_LINES:\r
 786                                 glDrawElements(GL_LINES, primitiveCount*2, indexSize, indexList);\r
 787                                 break;\r
 788                         case scene::EPT_TRIANGLE_STRIP:\r
 789                                 glDrawElements(GL_TRIANGLE_STRIP, primitiveCount + 2, indexSize, indexList);\r
 790                                 break;\r
 791                         case scene::EPT_TRIANGLE_FAN:\r
 792                                 glDrawElements(GL_TRIANGLE_FAN, primitiveCount + 2, indexSize, indexList);\r
 793                                 break;\r
 794                         case scene::EPT_TRIANGLES:\r
 795                                 glDrawElements((LastMaterial.Wireframe) ? GL_LINES : (LastMaterial.PointCloud) ? GL_POINTS : GL_TRIANGLES, primitiveCount*3, indexSize, indexList);\r
 796                                 break;\r
 797                         default:\r
 798                                 break;\r
 799                 }\r
 800 \r
 801                 switch (vType)\r
 802                 {\r
 803                 case EVT_2TCOORDS:\r
 804                         glDisableVertexAttribArray(EVA_TCOORD1);\r
 805                         break;\r
 806                 case EVT_TANGENTS:\r
 807                         glDisableVertexAttribArray(EVA_TANGENT);\r
 808                         glDisableVertexAttribArray(EVA_BINORMAL);\r
 809                         break;\r
 810                 default:\r
 811                         break;\r
 812                 }\r
 813 \r
 814                 glDisableVertexAttribArray(EVA_POSITION);\r
 815                 glDisableVertexAttribArray(EVA_NORMAL);\r
 816                 glDisableVertexAttribArray(EVA_COLOR);\r
 817                 glDisableVertexAttribArray(EVA_TCOORD0);\r
 818         }\r
 819 \r
 820 \r
 821         void COpenGL3Driver::draw2DImage(const video::ITexture* texture, const core::position2d<s32>& destPos,\r
 822                 const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect, SColor color,\r
 823                 bool useAlphaChannelOfTexture)\r
 824         {\r
 825                 if (!texture)\r
 826                         return;\r
 827 \r
 828                 if (!sourceRect.isValid())\r
 829                         return;\r
 830 \r
 831                 SColor colors[4] = {color, color, color, color};\r
 832                 draw2DImage(texture, {destPos, sourceRect.getSize()}, sourceRect, clipRect, colors, useAlphaChannelOfTexture);\r
 833         }\r
 834 \r
 835 \r
 836         void COpenGL3Driver::draw2DImage(const video::ITexture* texture, const core::rect<s32>& destRect,\r
 837                 const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect,\r
 838                 const video::SColor* const colors, bool useAlphaChannelOfTexture)\r
 839         {\r
 840                 if (!texture)\r
 841                         return;\r
 842 \r
 843                 // texcoords need to be flipped horizontally for RTTs\r
 844                 const bool isRTT = texture->isRenderTarget();\r
 845                 const core::dimension2du& ss = texture->getOriginalSize();\r
 846                 const f32 invW = 1.f / static_cast<f32>(ss.Width);\r
 847                 const f32 invH = 1.f / static_cast<f32>(ss.Height);\r
 848                 const core::rect<f32> tcoords(\r
 849                         sourceRect.UpperLeftCorner.X * invW,\r
 850                         (isRTT ? sourceRect.LowerRightCorner.Y : sourceRect.UpperLeftCorner.Y) * invH,\r
 851                         sourceRect.LowerRightCorner.X * invW,\r
 852                         (isRTT ? sourceRect.UpperLeftCorner.Y : sourceRect.LowerRightCorner.Y) *invH);\r
 853 \r
 854                 const video::SColor temp[4] =\r
 855                 {\r
 856                         0xFFFFFFFF,\r
 857                         0xFFFFFFFF,\r
 858                         0xFFFFFFFF,\r
 859                         0xFFFFFFFF\r
 860                 };\r
 861 \r
 862                 const video::SColor* const useColor = colors ? colors : temp;\r
 863 \r
 864                 chooseMaterial2D();\r
 865                 if (!setMaterialTexture(0, texture ))\r
 866                         return;\r
 867 \r
 868                 setRenderStates2DMode(useColor[0].getAlpha() < 255 || useColor[1].getAlpha() < 255 ||\r
 869                         useColor[2].getAlpha() < 255 || useColor[3].getAlpha() < 255,\r
 870                         true, useAlphaChannelOfTexture);\r
 871 \r
 872                 const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();\r
 873 \r
 874                 if (clipRect)\r
 875                 {\r
 876                         if (!clipRect->isValid())\r
 877                                 return;\r
 878 \r
 879                         glEnable(GL_SCISSOR_TEST);\r
 880                         glScissor(clipRect->UpperLeftCorner.X, renderTargetSize.Height - clipRect->LowerRightCorner.Y,\r
 881                                 clipRect->getWidth(), clipRect->getHeight());\r
 882                 }\r
 883 \r
 884                 f32 left = (f32)destRect.UpperLeftCorner.X / (f32)renderTargetSize.Width * 2.f - 1.f;\r
 885                 f32 right = (f32)destRect.LowerRightCorner.X / (f32)renderTargetSize.Width * 2.f - 1.f;\r
 886                 f32 down = 2.f - (f32)destRect.LowerRightCorner.Y / (f32)renderTargetSize.Height * 2.f - 1.f;\r
 887                 f32 top = 2.f - (f32)destRect.UpperLeftCorner.Y / (f32)renderTargetSize.Height * 2.f - 1.f;\r
 888 \r
 889                 u16 indices[] = { 0, 1, 2, 3 };\r
 890                 S3DVertex vertices[4];\r
 891                 vertices[0] = S3DVertex(left, top, 0, 0, 0, 1, useColor[0], tcoords.UpperLeftCorner.X, tcoords.UpperLeftCorner.Y);\r
 892                 vertices[1] = S3DVertex(right, top, 0, 0, 0, 1, useColor[3], tcoords.LowerRightCorner.X, tcoords.UpperLeftCorner.Y);\r
 893                 vertices[2] = S3DVertex(right, down, 0, 0, 0, 1, useColor[2], tcoords.LowerRightCorner.X, tcoords.LowerRightCorner.Y);\r
 894                 vertices[3] = S3DVertex(left, down, 0, 0, 0, 1, useColor[1], tcoords.UpperLeftCorner.X, tcoords.LowerRightCorner.Y);\r
 895 \r
 896                 glEnableVertexAttribArray(EVA_POSITION);\r
 897                 glEnableVertexAttribArray(EVA_COLOR);\r
 898                 glEnableVertexAttribArray(EVA_TCOORD0);\r
 899                 glVertexAttribPointer(EVA_POSITION, 3, GL_FLOAT, false, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].Pos);\r
 900                 glVertexAttribPointer(EVA_COLOR, 4, GL_UNSIGNED_BYTE, true, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].Color);\r
 901                 glVertexAttribPointer(EVA_TCOORD0, 2, GL_FLOAT, false, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].TCoords);\r
 902                 glDrawElements(GL_TRIANGLE_FAN, 4, GL_UNSIGNED_SHORT, indices);\r
 903                 glDisableVertexAttribArray(EVA_TCOORD0);\r
 904                 glDisableVertexAttribArray(EVA_COLOR);\r
 905                 glDisableVertexAttribArray(EVA_POSITION);\r
 906 \r
 907                 if (clipRect)\r
 908                         glDisable(GL_SCISSOR_TEST);\r
 909 \r
 910                 testGLError(__LINE__);\r
 911         }\r
 912 \r
 913         void COpenGL3Driver::draw2DImage(const video::ITexture* texture, u32 layer, bool flip)\r
 914         {\r
 915                 if (!texture)\r
 916                         return;\r
 917 \r
 918                 chooseMaterial2D();\r
 919                 if (!setMaterialTexture(0, texture ))\r
 920                         return;\r
 921 \r
 922                 setRenderStates2DMode(false, true, true);\r
 923 \r
 924                 u16 quad2DIndices[] = { 0, 1, 2, 3 };\r
 925                 S3DVertex quad2DVertices[4];\r
 926 \r
 927                 quad2DVertices[0].Pos = core::vector3df(-1.f, 1.f, 0.f);\r
 928                 quad2DVertices[1].Pos = core::vector3df(1.f, 1.f, 0.f);\r
 929                 quad2DVertices[2].Pos = core::vector3df(1.f, -1.f, 0.f);\r
 930                 quad2DVertices[3].Pos = core::vector3df(-1.f, -1.f, 0.f);\r
 931 \r
 932                 f32 modificator = (flip) ? 1.f : 0.f;\r
 933 \r
 934                 quad2DVertices[0].TCoords = core::vector2df(0.f, 0.f + modificator);\r
 935                 quad2DVertices[1].TCoords = core::vector2df(1.f, 0.f + modificator);\r
 936                 quad2DVertices[2].TCoords = core::vector2df(1.f, 1.f - modificator);\r
 937                 quad2DVertices[3].TCoords = core::vector2df(0.f, 1.f - modificator);\r
 938 \r
 939                 quad2DVertices[0].Color = SColor(0xFFFFFFFF);\r
 940                 quad2DVertices[1].Color = SColor(0xFFFFFFFF);\r
 941                 quad2DVertices[2].Color = SColor(0xFFFFFFFF);\r
 942                 quad2DVertices[3].Color = SColor(0xFFFFFFFF);\r
 943 \r
 944                 glEnableVertexAttribArray(EVA_POSITION);\r
 945                 glEnableVertexAttribArray(EVA_COLOR);\r
 946                 glEnableVertexAttribArray(EVA_TCOORD0);\r
 947                 glVertexAttribPointer(EVA_POSITION, 3, GL_FLOAT, false, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(quad2DVertices))[0].Pos);\r
 948                 glVertexAttribPointer(EVA_COLOR, 4, GL_UNSIGNED_BYTE, true, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(quad2DVertices))[0].Color);\r
 949                 glVertexAttribPointer(EVA_TCOORD0, 2, GL_FLOAT, false, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(quad2DVertices))[0].TCoords);\r
 950                 glDrawElements(GL_TRIANGLE_FAN, 4, GL_UNSIGNED_SHORT, quad2DIndices);\r
 951                 glDisableVertexAttribArray(EVA_TCOORD0);\r
 952                 glDisableVertexAttribArray(EVA_COLOR);\r
 953                 glDisableVertexAttribArray(EVA_POSITION);\r
 954         }\r
 955 \r
 956 \r
 957         void COpenGL3Driver::draw2DImageBatch(const video::ITexture* texture,\r
 958                         const core::array<core::position2d<s32> >& positions,\r
 959                         const core::array<core::rect<s32> >& sourceRects,\r
 960                         const core::rect<s32>* clipRect,\r
 961                         SColor color, bool useAlphaChannelOfTexture)\r
 962         {\r
 963                 if (!texture)\r
 964                         return;\r
 965 \r
 966                 chooseMaterial2D();\r
 967                 if (!setMaterialTexture(0, texture))\r
 968                         return;\r
 969 \r
 970                 setRenderStates2DMode(color.getAlpha() < 255, true, useAlphaChannelOfTexture);\r
 971 \r
 972                 const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();\r
 973 \r
 974                 if (clipRect)\r
 975                 {\r
 976                         if (!clipRect->isValid())\r
 977                                 return;\r
 978 \r
 979                         glEnable(GL_SCISSOR_TEST);\r
 980                         glScissor(clipRect->UpperLeftCorner.X, renderTargetSize.Height - clipRect->LowerRightCorner.Y,\r
 981                                         clipRect->getWidth(), clipRect->getHeight());\r
 982                 }\r
 983 \r
 984                 const irr::u32 drawCount = core::min_<u32>(positions.size(), sourceRects.size());\r
 985 \r
 986                 core::array<S3DVertex> vtx(drawCount * 4);\r
 987                 core::array<u16> indices(drawCount * 6);\r
 988 \r
 989                 for (u32 i = 0; i < drawCount; i++)\r
 990                 {\r
 991                         core::position2d<s32> targetPos = positions[i];\r
 992                         core::position2d<s32> sourcePos = sourceRects[i].UpperLeftCorner;\r
 993                         // This needs to be signed as it may go negative.\r
 994                         core::dimension2d<s32> sourceSize(sourceRects[i].getSize());\r
 995 \r
 996                         // now draw it.\r
 997 \r
 998                         core::rect<f32> tcoords;\r
 999                         tcoords.UpperLeftCorner.X = (((f32)sourcePos.X)) / texture->getOriginalSize().Width ;\r
1000                         tcoords.UpperLeftCorner.Y = (((f32)sourcePos.Y)) / texture->getOriginalSize().Height;\r
1001                         tcoords.LowerRightCorner.X = tcoords.UpperLeftCorner.X + ((f32)(sourceSize.Width) / texture->getOriginalSize().Width);\r
1002                         tcoords.LowerRightCorner.Y = tcoords.UpperLeftCorner.Y + ((f32)(sourceSize.Height) / texture->getOriginalSize().Height);\r
1003 \r
1004                         const core::rect<s32> poss(targetPos, sourceSize);\r
1005 \r
1006                         f32 left = (f32)poss.UpperLeftCorner.X / (f32)renderTargetSize.Width * 2.f - 1.f;\r
1007                         f32 right = (f32)poss.LowerRightCorner.X / (f32)renderTargetSize.Width * 2.f - 1.f;\r
1008                         f32 down = 2.f - (f32)poss.LowerRightCorner.Y / (f32)renderTargetSize.Height * 2.f - 1.f;\r
1009                         f32 top = 2.f - (f32)poss.UpperLeftCorner.Y / (f32)renderTargetSize.Height * 2.f - 1.f;\r
1010 \r
1011                         vtx.push_back(S3DVertex(left, top, 0.0f,\r
1012                                         0.0f, 0.0f, 0.0f, color,\r
1013                                         tcoords.UpperLeftCorner.X, tcoords.UpperLeftCorner.Y));\r
1014                         vtx.push_back(S3DVertex(right, top, 0.0f,\r
1015                                         0.0f, 0.0f, 0.0f, color,\r
1016                                         tcoords.LowerRightCorner.X, tcoords.UpperLeftCorner.Y));\r
1017                         vtx.push_back(S3DVertex(right, down, 0.0f,\r
1018                                         0.0f, 0.0f, 0.0f, color,\r
1019                                         tcoords.LowerRightCorner.X, tcoords.LowerRightCorner.Y));\r
1020                         vtx.push_back(S3DVertex(left, down, 0.0f,\r
1021                                         0.0f, 0.0f, 0.0f, color,\r
1022                                         tcoords.UpperLeftCorner.X, tcoords.LowerRightCorner.Y));\r
1023 \r
1024                         const u32 curPos = vtx.size() - 4;\r
1025                         indices.push_back(0 + curPos);\r
1026                         indices.push_back(1 + curPos);\r
1027                         indices.push_back(2 + curPos);\r
1028 \r
1029                         indices.push_back(0 + curPos);\r
1030                         indices.push_back(2 + curPos);\r
1031                         indices.push_back(3 + curPos);\r
1032                 }\r
1033 \r
1034                 if (vtx.size())\r
1035                 {\r
1036                         glEnableVertexAttribArray(EVA_POSITION);\r
1037                         glEnableVertexAttribArray(EVA_COLOR);\r
1038                         glEnableVertexAttribArray(EVA_TCOORD0);\r
1039                         glVertexAttribPointer(EVA_POSITION, 3, GL_FLOAT, false, sizeof(S3DVertex), &vtx[0].Pos);\r
1040                         glVertexAttribPointer(EVA_COLOR, 4, GL_UNSIGNED_BYTE, true, sizeof(S3DVertex), &vtx[0].Color);\r
1041                         glVertexAttribPointer(EVA_TCOORD0, 2, GL_FLOAT, false, sizeof(S3DVertex), &vtx[0].TCoords);\r
1042                         glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_SHORT, indices.pointer());\r
1043                         glDisableVertexAttribArray(EVA_TCOORD0);\r
1044                         glDisableVertexAttribArray(EVA_COLOR);\r
1045                         glDisableVertexAttribArray(EVA_POSITION);\r
1046                 }\r
1047         }\r
1048 \r
1049 \r
1050         //! draw a 2d rectangle\r
1051         void COpenGL3Driver::draw2DRectangle(SColor color,\r
1052                         const core::rect<s32>& position,\r
1053                         const core::rect<s32>* clip)\r
1054         {\r
1055                 chooseMaterial2D();\r
1056                 setMaterialTexture(0, 0);\r
1057 \r
1058                 setRenderStates2DMode(color.getAlpha() < 255, false, false);\r
1059 \r
1060                 core::rect<s32> pos = position;\r
1061 \r
1062                 if (clip)\r
1063                         pos.clipAgainst(*clip);\r
1064 \r
1065                 if (!pos.isValid())\r
1066                         return;\r
1067 \r
1068                 const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();\r
1069 \r
1070                 f32 left = (f32)pos.UpperLeftCorner.X / (f32)renderTargetSize.Width * 2.f - 1.f;\r
1071                 f32 right = (f32)pos.LowerRightCorner.X / (f32)renderTargetSize.Width * 2.f - 1.f;\r
1072                 f32 down = 2.f - (f32)pos.LowerRightCorner.Y / (f32)renderTargetSize.Height * 2.f - 1.f;\r
1073                 f32 top = 2.f - (f32)pos.UpperLeftCorner.Y / (f32)renderTargetSize.Height * 2.f - 1.f;\r
1074 \r
1075                 u16 indices[] = {0, 1, 2, 3};\r
1076                 S3DVertex vertices[4];\r
1077                 vertices[0] = S3DVertex(left, top, 0, 0, 0, 1, color, 0, 0);\r
1078                 vertices[1] = S3DVertex(right, top, 0, 0, 0, 1, color, 0, 0);\r
1079                 vertices[2] = S3DVertex(right, down, 0, 0, 0, 1, color, 0, 0);\r
1080                 vertices[3] = S3DVertex(left, down, 0, 0, 0, 1, color, 0, 0);\r
1081 \r
1082                 glEnableVertexAttribArray(EVA_POSITION);\r
1083                 glEnableVertexAttribArray(EVA_COLOR);\r
1084                 glVertexAttribPointer(EVA_POSITION, 3, GL_FLOAT, false, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].Pos);\r
1085                 glVertexAttribPointer(EVA_COLOR, 4, GL_UNSIGNED_BYTE, true, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].Color);\r
1086                 glDrawElements(GL_TRIANGLE_FAN, 4, GL_UNSIGNED_SHORT, indices);\r
1087                 glDisableVertexAttribArray(EVA_COLOR);\r
1088                 glDisableVertexAttribArray(EVA_POSITION);\r
1089         }\r
1090 \r
1091 \r
1092         //! draw an 2d rectangle\r
1093         void COpenGL3Driver::draw2DRectangle(const core::rect<s32>& position,\r
1094                         SColor colorLeftUp, SColor colorRightUp,\r
1095                         SColor colorLeftDown, SColor colorRightDown,\r
1096                         const core::rect<s32>* clip)\r
1097         {\r
1098                 core::rect<s32> pos = position;\r
1099 \r
1100                 if (clip)\r
1101                         pos.clipAgainst(*clip);\r
1102 \r
1103                 if (!pos.isValid())\r
1104                         return;\r
1105 \r
1106                 chooseMaterial2D();\r
1107                 setMaterialTexture(0, 0);\r
1108 \r
1109                 setRenderStates2DMode(colorLeftUp.getAlpha() < 255 ||\r
1110                                 colorRightUp.getAlpha() < 255 ||\r
1111                                 colorLeftDown.getAlpha() < 255 ||\r
1112                                 colorRightDown.getAlpha() < 255, false, false);\r
1113 \r
1114                 const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();\r
1115 \r
1116                 f32 left = (f32)pos.UpperLeftCorner.X / (f32)renderTargetSize.Width * 2.f - 1.f;\r
1117                 f32 right = (f32)pos.LowerRightCorner.X / (f32)renderTargetSize.Width * 2.f - 1.f;\r
1118                 f32 down = 2.f - (f32)pos.LowerRightCorner.Y / (f32)renderTargetSize.Height * 2.f - 1.f;\r
1119                 f32 top = 2.f - (f32)pos.UpperLeftCorner.Y / (f32)renderTargetSize.Height * 2.f - 1.f;\r
1120 \r
1121                 u16 indices[] = {0, 1, 2, 3};\r
1122                 S3DVertex vertices[4];\r
1123                 vertices[0] = S3DVertex(left, top, 0, 0, 0, 1, colorLeftUp, 0, 0);\r
1124                 vertices[1] = S3DVertex(right, top, 0, 0, 0, 1, colorRightUp, 0, 0);\r
1125                 vertices[2] = S3DVertex(right, down, 0, 0, 0, 1, colorRightDown, 0, 0);\r
1126                 vertices[3] = S3DVertex(left, down, 0, 0, 0, 1, colorLeftDown, 0, 0);\r
1127 \r
1128                 glEnableVertexAttribArray(EVA_POSITION);\r
1129                 glEnableVertexAttribArray(EVA_COLOR);\r
1130                 glVertexAttribPointer(EVA_POSITION, 3, GL_FLOAT, false, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].Pos);\r
1131                 glVertexAttribPointer(EVA_COLOR, 4, GL_UNSIGNED_BYTE, true, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].Color);\r
1132                 glDrawElements(GL_TRIANGLE_FAN, 4, GL_UNSIGNED_SHORT, indices);\r
1133                 glDisableVertexAttribArray(EVA_COLOR);\r
1134                 glDisableVertexAttribArray(EVA_POSITION);\r
1135         }\r
1136 \r
1137 \r
1138         //! Draws a 2d line.\r
1139         void COpenGL3Driver::draw2DLine(const core::position2d<s32>& start,\r
1140                         const core::position2d<s32>& end, SColor color)\r
1141         {\r
1142                 if (start==end)\r
1143                         drawPixel(start.X, start.Y, color);\r
1144                 else\r
1145                 {\r
1146                         chooseMaterial2D();\r
1147                         setMaterialTexture(0, 0);\r
1148 \r
1149                         setRenderStates2DMode(color.getAlpha() < 255, false, false);\r
1150 \r
1151                         const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();\r
1152 \r
1153                         f32 startX = (f32)start.X / (f32)renderTargetSize.Width * 2.f - 1.f;\r
1154                         f32 endX = (f32)end.X / (f32)renderTargetSize.Width * 2.f - 1.f;\r
1155                         f32 startY = 2.f - (f32)start.Y / (f32)renderTargetSize.Height * 2.f - 1.f;\r
1156                         f32 endY = 2.f - (f32)end.Y / (f32)renderTargetSize.Height * 2.f - 1.f;\r
1157 \r
1158                         u16 indices[] = {0, 1};\r
1159                         S3DVertex vertices[2];\r
1160                         vertices[0] = S3DVertex(startX, startY, 0, 0, 0, 1, color, 0, 0);\r
1161                         vertices[1] = S3DVertex(endX, endY, 0, 0, 0, 1, color, 1, 1);\r
1162 \r
1163                         glEnableVertexAttribArray(EVA_POSITION);\r
1164                         glEnableVertexAttribArray(EVA_COLOR);\r
1165                         glVertexAttribPointer(EVA_POSITION, 3, GL_FLOAT, false, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].Pos);\r
1166                         glVertexAttribPointer(EVA_COLOR, 4, GL_UNSIGNED_BYTE, true, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].Color);\r
1167                         glDrawElements(GL_LINES, 2, GL_UNSIGNED_SHORT, indices);\r
1168                         glDisableVertexAttribArray(EVA_COLOR);\r
1169                         glDisableVertexAttribArray(EVA_POSITION);\r
1170                 }\r
1171         }\r
1172 \r
1173 \r
1174         //! Draws a pixel\r
1175         void COpenGL3Driver::drawPixel(u32 x, u32 y, const SColor &color)\r
1176         {\r
1177                 const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();\r
1178                 if (x > (u32)renderTargetSize.Width || y > (u32)renderTargetSize.Height)\r
1179                         return;\r
1180 \r
1181                 chooseMaterial2D();\r
1182                 setMaterialTexture(0, 0);\r
1183 \r
1184                 setRenderStates2DMode(color.getAlpha() < 255, false, false);\r
1185 \r
1186                 f32 X = (f32)x / (f32)renderTargetSize.Width * 2.f - 1.f;\r
1187                 f32 Y = 2.f - (f32)y / (f32)renderTargetSize.Height * 2.f - 1.f;\r
1188 \r
1189                 S3DVertex vertices[1];\r
1190                 vertices[0] = S3DVertex(X, Y, 0, 0, 0, 1, color, 0, 0);\r
1191 \r
1192                 glEnableVertexAttribArray(EVA_POSITION);\r
1193                 glEnableVertexAttribArray(EVA_COLOR);\r
1194                 glVertexAttribPointer(EVA_POSITION, 3, GL_FLOAT, false, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].Pos);\r
1195                 glVertexAttribPointer(EVA_COLOR, 4, GL_UNSIGNED_BYTE, true, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].Color);\r
1196                 glDrawArrays(GL_POINTS, 0, 1);\r
1197                 glDisableVertexAttribArray(EVA_COLOR);\r
1198                 glDisableVertexAttribArray(EVA_POSITION);\r
1199         }\r
1200 \r
1201         ITexture* COpenGL3Driver::createDeviceDependentTexture(const io::path& name, IImage* image)\r
1202         {\r
1203                 core::array<IImage*> imageArray(1);\r
1204                 imageArray.push_back(image);\r
1205 \r
1206                 COpenGL3Texture* texture = new COpenGL3Texture(name, imageArray, ETT_2D, this);\r
1207 \r
1208                 return texture;\r
1209         }\r
1210 \r
1211         ITexture* COpenGL3Driver::createDeviceDependentTextureCubemap(const io::path& name, const core::array<IImage*>& image)\r
1212         {\r
1213                 COpenGL3Texture* texture = new COpenGL3Texture(name, image, ETT_CUBEMAP, this);\r
1214 \r
1215                 return texture;\r
1216         }\r
1217 \r
1218         //! Sets a material.\r
1219         void COpenGL3Driver::setMaterial(const SMaterial& material)\r
1220         {\r
1221                 Material = material;\r
1222                 OverrideMaterial.apply(Material);\r
1223 \r
1224                 for (u32 i = 0; i < Feature.MaxTextureUnits; ++i)\r
1225                 {\r
1226                         CacheHandler->getTextureCache().set(i, material.getTexture(i));\r
1227                         setTransform((E_TRANSFORMATION_STATE)(ETS_TEXTURE_0 + i), material.getTextureMatrix(i));\r
1228                 }\r
1229         }\r
1230 \r
1231         //! prints error if an error happened.\r
1232         bool COpenGL3Driver::testGLError(int code)\r
1233         {\r
1234 #ifdef _DEBUG\r
1235                 GLenum g = glGetError();\r
1236                 switch (g)\r
1237                 {\r
1238                         case GL_NO_ERROR:\r
1239                                 return false;\r
1240                         case GL_INVALID_ENUM:\r
1241                                 os::Printer::log("GL_INVALID_ENUM", core::stringc(code).c_str(), ELL_ERROR);\r
1242                                 break;\r
1243                         case GL_INVALID_VALUE:\r
1244                                 os::Printer::log("GL_INVALID_VALUE", core::stringc(code).c_str(), ELL_ERROR);\r
1245                                 break;\r
1246                         case GL_INVALID_OPERATION:\r
1247                                 os::Printer::log("GL_INVALID_OPERATION", core::stringc(code).c_str(), ELL_ERROR);\r
1248                                 break;\r
1249                         case GL_OUT_OF_MEMORY:\r
1250                                 os::Printer::log("GL_OUT_OF_MEMORY", core::stringc(code).c_str(), ELL_ERROR);\r
1251                                 break;\r
1252                 };\r
1253                 return true;\r
1254 #else\r
1255                 return false;\r
1256 #endif\r
1257         }\r
1258 \r
1259         //! prints error if an error happened.\r
1260         bool COpenGL3Driver::testEGLError()\r
1261         {\r
1262 #if defined(EGL_VERSION_1_0) && defined(_DEBUG)\r
1263                 EGLint g = eglGetError();\r
1264                 switch (g)\r
1265                 {\r
1266                         case EGL_SUCCESS:\r
1267                                 return false;\r
1268                         case EGL_NOT_INITIALIZED :\r
1269                                 os::Printer::log("Not Initialized", ELL_ERROR);\r
1270                                 break;\r
1271                         case EGL_BAD_ACCESS:\r
1272                                 os::Printer::log("Bad Access", ELL_ERROR);\r
1273                                 break;\r
1274                         case EGL_BAD_ALLOC:\r
1275                                 os::Printer::log("Bad Alloc", ELL_ERROR);\r
1276                                 break;\r
1277                         case EGL_BAD_ATTRIBUTE:\r
1278                                 os::Printer::log("Bad Attribute", ELL_ERROR);\r
1279                                 break;\r
1280                         case EGL_BAD_CONTEXT:\r
1281                                 os::Printer::log("Bad Context", ELL_ERROR);\r
1282                                 break;\r
1283                         case EGL_BAD_CONFIG:\r
1284                                 os::Printer::log("Bad Config", ELL_ERROR);\r
1285                                 break;\r
1286                         case EGL_BAD_CURRENT_SURFACE:\r
1287                                 os::Printer::log("Bad Current Surface", ELL_ERROR);\r
1288                                 break;\r
1289                         case EGL_BAD_DISPLAY:\r
1290                                 os::Printer::log("Bad Display", ELL_ERROR);\r
1291                                 break;\r
1292                         case EGL_BAD_SURFACE:\r
1293                                 os::Printer::log("Bad Surface", ELL_ERROR);\r
1294                                 break;\r
1295                         case EGL_BAD_MATCH:\r
1296                                 os::Printer::log("Bad Match", ELL_ERROR);\r
1297                                 break;\r
1298                         case EGL_BAD_PARAMETER:\r
1299                                 os::Printer::log("Bad Parameter", ELL_ERROR);\r
1300                                 break;\r
1301                         case EGL_BAD_NATIVE_PIXMAP:\r
1302                                 os::Printer::log("Bad Native Pixmap", ELL_ERROR);\r
1303                                 break;\r
1304                         case EGL_BAD_NATIVE_WINDOW:\r
1305                                 os::Printer::log("Bad Native Window", ELL_ERROR);\r
1306                                 break;\r
1307                         case EGL_CONTEXT_LOST:\r
1308                                 os::Printer::log("Context Lost", ELL_ERROR);\r
1309                                 break;\r
1310                 };\r
1311                 return true;\r
1312 #else\r
1313                 return false;\r
1314 #endif\r
1315         }\r
1316 \r
1317 \r
1318         void COpenGL3Driver::setRenderStates3DMode()\r
1319         {\r
1320                 if ( LockRenderStateMode )\r
1321                         return;\r
1322 \r
1323                 if (CurrentRenderMode != ERM_3D)\r
1324                 {\r
1325                         // Reset Texture Stages\r
1326                         CacheHandler->setBlend(false);\r
1327                         CacheHandler->setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);\r
1328 \r
1329                         ResetRenderStates = true;\r
1330                 }\r
1331 \r
1332                 if (ResetRenderStates || LastMaterial != Material)\r
1333                 {\r
1334                         // unset old material\r
1335 \r
1336                         // unset last 3d material\r
1337                         if (CurrentRenderMode == ERM_2D && MaterialRenderer2DActive)\r
1338                         {\r
1339                                 MaterialRenderer2DActive->OnUnsetMaterial();\r
1340                                 MaterialRenderer2DActive = 0;\r
1341                         }\r
1342                         else if (LastMaterial.MaterialType != Material.MaterialType &&\r
1343                                         static_cast<u32>(LastMaterial.MaterialType) < MaterialRenderers.size())\r
1344                                 MaterialRenderers[LastMaterial.MaterialType].Renderer->OnUnsetMaterial();\r
1345 \r
1346                         // set new material.\r
1347                         if (static_cast<u32>(Material.MaterialType) < MaterialRenderers.size())\r
1348                                 MaterialRenderers[Material.MaterialType].Renderer->OnSetMaterial(\r
1349                                         Material, LastMaterial, ResetRenderStates, this);\r
1350 \r
1351                         LastMaterial = Material;\r
1352                         CacheHandler->correctCacheMaterial(LastMaterial);\r
1353                         ResetRenderStates = false;\r
1354                 }\r
1355 \r
1356                 if (static_cast<u32>(Material.MaterialType) < MaterialRenderers.size())\r
1357                         MaterialRenderers[Material.MaterialType].Renderer->OnRender(this, video::EVT_STANDARD);\r
1358 \r
1359                 CurrentRenderMode = ERM_3D;\r
1360         }\r
1361 \r
1362         //! Can be called by an IMaterialRenderer to make its work easier.\r
1363         void COpenGL3Driver::setBasicRenderStates(const SMaterial& material, const SMaterial& lastmaterial, bool resetAllRenderStates)\r
1364         {\r
1365                 // ZBuffer\r
1366                 switch (material.ZBuffer)\r
1367                 {\r
1368                         case ECFN_DISABLED:\r
1369                                 CacheHandler->setDepthTest(false);\r
1370                                 break;\r
1371                         case ECFN_LESSEQUAL:\r
1372                                 CacheHandler->setDepthTest(true);\r
1373                                 CacheHandler->setDepthFunc(GL_LEQUAL);\r
1374                                 break;\r
1375                         case ECFN_EQUAL:\r
1376                                 CacheHandler->setDepthTest(true);\r
1377                                 CacheHandler->setDepthFunc(GL_EQUAL);\r
1378                                 break;\r
1379                         case ECFN_LESS:\r
1380                                 CacheHandler->setDepthTest(true);\r
1381                                 CacheHandler->setDepthFunc(GL_LESS);\r
1382                                 break;\r
1383                         case ECFN_NOTEQUAL:\r
1384                                 CacheHandler->setDepthTest(true);\r
1385                                 CacheHandler->setDepthFunc(GL_NOTEQUAL);\r
1386                                 break;\r
1387                         case ECFN_GREATEREQUAL:\r
1388                                 CacheHandler->setDepthTest(true);\r
1389                                 CacheHandler->setDepthFunc(GL_GEQUAL);\r
1390                                 break;\r
1391                         case ECFN_GREATER:\r
1392                                 CacheHandler->setDepthTest(true);\r
1393                                 CacheHandler->setDepthFunc(GL_GREATER);\r
1394                                 break;\r
1395                         case ECFN_ALWAYS:\r
1396                                 CacheHandler->setDepthTest(true);\r
1397                                 CacheHandler->setDepthFunc(GL_ALWAYS);\r
1398                                 break;\r
1399                         case ECFN_NEVER:\r
1400                                 CacheHandler->setDepthTest(true);\r
1401                                 CacheHandler->setDepthFunc(GL_NEVER);\r
1402                                 break;\r
1403                         default:\r
1404                                 break;\r
1405                 }\r
1406 \r
1407                 // ZWrite\r
1408                 if (getWriteZBuffer(material))\r
1409                 {\r
1410                         CacheHandler->setDepthMask(true);\r
1411                 }\r
1412                 else\r
1413                 {\r
1414                         CacheHandler->setDepthMask(false);\r
1415                 }\r
1416 \r
1417                 // Back face culling\r
1418                 if ((material.FrontfaceCulling) && (material.BackfaceCulling))\r
1419                 {\r
1420                         CacheHandler->setCullFaceFunc(GL_FRONT_AND_BACK);\r
1421                         CacheHandler->setCullFace(true);\r
1422                 }\r
1423                 else if (material.BackfaceCulling)\r
1424                 {\r
1425                         CacheHandler->setCullFaceFunc(GL_BACK);\r
1426                         CacheHandler->setCullFace(true);\r
1427                 }\r
1428                 else if (material.FrontfaceCulling)\r
1429                 {\r
1430                         CacheHandler->setCullFaceFunc(GL_FRONT);\r
1431                         CacheHandler->setCullFace(true);\r
1432                 }\r
1433                 else\r
1434                 {\r
1435                         CacheHandler->setCullFace(false);\r
1436                 }\r
1437 \r
1438                 // Color Mask\r
1439                 CacheHandler->setColorMask(material.ColorMask);\r
1440 \r
1441                 // Blend Equation\r
1442                 if (material.BlendOperation == EBO_NONE)\r
1443                         CacheHandler->setBlend(false);\r
1444                 else\r
1445                 {\r
1446                         CacheHandler->setBlend(true);\r
1447 \r
1448                         switch (material.BlendOperation)\r
1449                         {\r
1450                         case EBO_ADD:\r
1451                                 CacheHandler->setBlendEquation(GL_FUNC_ADD);\r
1452                                 break;\r
1453                         case EBO_SUBTRACT:\r
1454                                 CacheHandler->setBlendEquation(GL_FUNC_SUBTRACT);\r
1455                                 break;\r
1456                         case EBO_REVSUBTRACT:\r
1457                                 CacheHandler->setBlendEquation(GL_FUNC_REVERSE_SUBTRACT);\r
1458                                 break;\r
1459                         default:\r
1460                                 break;\r
1461                         }\r
1462                 }\r
1463 \r
1464                 // Blend Factor\r
1465                 if (IR(material.BlendFactor) & 0xFFFFFFFF       // TODO: why the & 0xFFFFFFFF?\r
1466                         && material.MaterialType != EMT_ONETEXTURE_BLEND\r
1467                 )\r
1468                 {\r
1469                     E_BLEND_FACTOR srcRGBFact = EBF_ZERO;\r
1470                     E_BLEND_FACTOR dstRGBFact = EBF_ZERO;\r
1471                     E_BLEND_FACTOR srcAlphaFact = EBF_ZERO;\r
1472                     E_BLEND_FACTOR dstAlphaFact = EBF_ZERO;\r
1473                     E_MODULATE_FUNC modulo = EMFN_MODULATE_1X;\r
1474                     u32 alphaSource = 0;\r
1475 \r
1476                     unpack_textureBlendFuncSeparate(srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact, modulo, alphaSource, material.BlendFactor);\r
1477 \r
1478                         CacheHandler->setBlendFuncSeparate(getGLBlend(srcRGBFact), getGLBlend(dstRGBFact),\r
1479                                 getGLBlend(srcAlphaFact), getGLBlend(dstAlphaFact));\r
1480                 }\r
1481 \r
1482                 // TODO: Polygon Offset. Not sure if it was left out deliberately or if it won't work with this driver.\r
1483 \r
1484                 if (resetAllRenderStates || lastmaterial.Thickness != material.Thickness)\r
1485                         glLineWidth(core::clamp(static_cast<GLfloat>(material.Thickness), DimAliasedLine[0], DimAliasedLine[1]));\r
1486 \r
1487                 // Anti aliasing\r
1488                 if (resetAllRenderStates || lastmaterial.AntiAliasing != material.AntiAliasing)\r
1489                 {\r
1490                         if (material.AntiAliasing & EAAM_ALPHA_TO_COVERAGE)\r
1491                                 glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE);\r
1492                         else if (lastmaterial.AntiAliasing & EAAM_ALPHA_TO_COVERAGE)\r
1493                                 glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);\r
1494                 }\r
1495 \r
1496                 // Texture parameters\r
1497                 setTextureRenderStates(material, resetAllRenderStates);\r
1498         }\r
1499 \r
1500         //! Compare in SMaterial doesn't check texture parameters, so we should call this on each OnRender call.\r
1501         void COpenGL3Driver::setTextureRenderStates(const SMaterial& material, bool resetAllRenderstates)\r
1502         {\r
1503                 // Set textures to TU/TIU and apply filters to them\r
1504 \r
1505                 for (s32 i = Feature.MaxTextureUnits - 1; i >= 0; --i)\r
1506                 {\r
1507                         const COpenGL3Texture* tmpTexture = CacheHandler->getTextureCache()[i];\r
1508 \r
1509                         if (!tmpTexture)\r
1510                                 continue;\r
1511 \r
1512                         GLenum tmpTextureType = tmpTexture->getOpenGLTextureType();\r
1513 \r
1514                         CacheHandler->setActiveTexture(GL_TEXTURE0 + i);\r
1515 \r
1516                         if (resetAllRenderstates)\r
1517                                 tmpTexture->getStatesCache().IsCached = false;\r
1518 \r
1519                         if (!tmpTexture->getStatesCache().IsCached || material.TextureLayer[i].BilinearFilter != tmpTexture->getStatesCache().BilinearFilter ||\r
1520                                 material.TextureLayer[i].TrilinearFilter != tmpTexture->getStatesCache().TrilinearFilter)\r
1521                         {\r
1522                                 glTexParameteri(tmpTextureType, GL_TEXTURE_MAG_FILTER,\r
1523                                         (material.TextureLayer[i].BilinearFilter || material.TextureLayer[i].TrilinearFilter) ? GL_LINEAR : GL_NEAREST);\r
1524 \r
1525                                 tmpTexture->getStatesCache().BilinearFilter = material.TextureLayer[i].BilinearFilter;\r
1526                                 tmpTexture->getStatesCache().TrilinearFilter = material.TextureLayer[i].TrilinearFilter;\r
1527                         }\r
1528 \r
1529                         if (material.UseMipMaps && tmpTexture->hasMipMaps())\r
1530                         {\r
1531                                 if (!tmpTexture->getStatesCache().IsCached || material.TextureLayer[i].BilinearFilter != tmpTexture->getStatesCache().BilinearFilter ||\r
1532                                         material.TextureLayer[i].TrilinearFilter != tmpTexture->getStatesCache().TrilinearFilter || !tmpTexture->getStatesCache().MipMapStatus)\r
1533                                 {\r
1534                                         glTexParameteri(tmpTextureType, GL_TEXTURE_MIN_FILTER,\r
1535                                                 material.TextureLayer[i].TrilinearFilter ? GL_LINEAR_MIPMAP_LINEAR :\r
1536                                                 material.TextureLayer[i].BilinearFilter ? GL_LINEAR_MIPMAP_NEAREST :\r
1537                                                 GL_NEAREST_MIPMAP_NEAREST);\r
1538 \r
1539                                         tmpTexture->getStatesCache().BilinearFilter = material.TextureLayer[i].BilinearFilter;\r
1540                                         tmpTexture->getStatesCache().TrilinearFilter = material.TextureLayer[i].TrilinearFilter;\r
1541                                         tmpTexture->getStatesCache().MipMapStatus = true;\r
1542                                 }\r
1543                         }\r
1544                         else\r
1545                         {\r
1546                                 if (!tmpTexture->getStatesCache().IsCached || material.TextureLayer[i].BilinearFilter != tmpTexture->getStatesCache().BilinearFilter ||\r
1547                                         material.TextureLayer[i].TrilinearFilter != tmpTexture->getStatesCache().TrilinearFilter || tmpTexture->getStatesCache().MipMapStatus)\r
1548                                 {\r
1549                                         glTexParameteri(tmpTextureType, GL_TEXTURE_MIN_FILTER,\r
1550                                                 (material.TextureLayer[i].BilinearFilter || material.TextureLayer[i].TrilinearFilter) ? GL_LINEAR : GL_NEAREST);\r
1551 \r
1552                                         tmpTexture->getStatesCache().BilinearFilter = material.TextureLayer[i].BilinearFilter;\r
1553                                         tmpTexture->getStatesCache().TrilinearFilter = material.TextureLayer[i].TrilinearFilter;\r
1554                                         tmpTexture->getStatesCache().MipMapStatus = false;\r
1555                                 }\r
1556                         }\r
1557 \r
1558         #ifdef GL_EXT_texture_filter_anisotropic\r
1559                         if (FeatureAvailable[COGLESCoreExtensionHandler::IRR_GL_EXT_texture_filter_anisotropic] &&\r
1560                                 (!tmpTexture->getStatesCache().IsCached || material.TextureLayer[i].AnisotropicFilter != tmpTexture->getStatesCache().AnisotropicFilter))\r
1561                         {\r
1562                                 glTexParameteri(tmpTextureType, GL_TEXTURE_MAX_ANISOTROPY_EXT,\r
1563                                         material.TextureLayer[i].AnisotropicFilter>1 ? core::min_(MaxAnisotropy, material.TextureLayer[i].AnisotropicFilter) : 1);\r
1564 \r
1565                                 tmpTexture->getStatesCache().AnisotropicFilter = material.TextureLayer[i].AnisotropicFilter;\r
1566                         }\r
1567         #endif\r
1568 \r
1569                         if (!tmpTexture->getStatesCache().IsCached || material.TextureLayer[i].TextureWrapU != tmpTexture->getStatesCache().WrapU)\r
1570                         {\r
1571                                 glTexParameteri(tmpTextureType, GL_TEXTURE_WRAP_S, getTextureWrapMode(material.TextureLayer[i].TextureWrapU));\r
1572                                 tmpTexture->getStatesCache().WrapU = material.TextureLayer[i].TextureWrapU;\r
1573                         }\r
1574 \r
1575                         if (!tmpTexture->getStatesCache().IsCached || material.TextureLayer[i].TextureWrapV != tmpTexture->getStatesCache().WrapV)\r
1576                         {\r
1577                                 glTexParameteri(tmpTextureType, GL_TEXTURE_WRAP_T, getTextureWrapMode(material.TextureLayer[i].TextureWrapV));\r
1578                                 tmpTexture->getStatesCache().WrapV = material.TextureLayer[i].TextureWrapV;\r
1579                         }\r
1580 \r
1581                         tmpTexture->getStatesCache().IsCached = true;\r
1582                 }\r
1583         }\r
1584 \r
1585 \r
1586         // Get OpenGL ES2.0 texture wrap mode from Irrlicht wrap mode.\r
1587         GLint COpenGL3Driver::getTextureWrapMode(u8 clamp) const\r
1588         {\r
1589                 switch (clamp)\r
1590                 {\r
1591                         case ETC_CLAMP:\r
1592                         case ETC_CLAMP_TO_EDGE:\r
1593                         case ETC_CLAMP_TO_BORDER:\r
1594                                 return GL_CLAMP_TO_EDGE;\r
1595                         case ETC_MIRROR:\r
1596                                 return GL_REPEAT;\r
1597                         default:\r
1598                                 return GL_REPEAT;\r
1599                 }\r
1600         }\r
1601 \r
1602 \r
1603         //! sets the needed renderstates\r
1604         void COpenGL3Driver::setRenderStates2DMode(bool alpha, bool texture, bool alphaChannel)\r
1605         {\r
1606                 if ( LockRenderStateMode )\r
1607                         return;\r
1608 \r
1609                 COpenGL3Renderer2D* nextActiveRenderer = texture ? MaterialRenderer2DTexture : MaterialRenderer2DNoTexture;\r
1610 \r
1611                 if (CurrentRenderMode != ERM_2D)\r
1612                 {\r
1613                         // unset last 3d material\r
1614                         if (CurrentRenderMode == ERM_3D)\r
1615                         {\r
1616                                 if (static_cast<u32>(LastMaterial.MaterialType) < MaterialRenderers.size())\r
1617                                         MaterialRenderers[LastMaterial.MaterialType].Renderer->OnUnsetMaterial();\r
1618                         }\r
1619 \r
1620                         CurrentRenderMode = ERM_2D;\r
1621                 }\r
1622                 else if ( MaterialRenderer2DActive && MaterialRenderer2DActive != nextActiveRenderer)\r
1623                 {\r
1624                         MaterialRenderer2DActive->OnUnsetMaterial();\r
1625                 }\r
1626 \r
1627                 MaterialRenderer2DActive = nextActiveRenderer;\r
1628 \r
1629                 MaterialRenderer2DActive->OnSetMaterial(Material, LastMaterial, true, 0);\r
1630                 LastMaterial = Material;\r
1631                 CacheHandler->correctCacheMaterial(LastMaterial);\r
1632 \r
1633                 // no alphaChannel without texture\r
1634                 alphaChannel &= texture;\r
1635 \r
1636                 if (alphaChannel || alpha)\r
1637                 {\r
1638                         CacheHandler->setBlend(true);\r
1639                         CacheHandler->setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);\r
1640                         CacheHandler->setBlendEquation(GL_FUNC_ADD);\r
1641                 }\r
1642                 else\r
1643                         CacheHandler->setBlend(false);\r
1644 \r
1645                 Material.setTexture(0, const_cast<COpenGL3Texture*>(CacheHandler->getTextureCache().get(0)));\r
1646                 setTransform(ETS_TEXTURE_0, core::IdentityMatrix);\r
1647 \r
1648                 if (texture)\r
1649                 {\r
1650                         if (OverrideMaterial2DEnabled)\r
1651                                 setTextureRenderStates(OverrideMaterial2D, false);\r
1652                         else\r
1653                                 setTextureRenderStates(InitMaterial2D, false);\r
1654                 }\r
1655 \r
1656                 MaterialRenderer2DActive->OnRender(this, video::EVT_STANDARD);\r
1657         }\r
1658 \r
1659 \r
1660         void COpenGL3Driver::chooseMaterial2D()\r
1661         {\r
1662                 if (!OverrideMaterial2DEnabled)\r
1663                         Material = InitMaterial2D;\r
1664 \r
1665                 if (OverrideMaterial2DEnabled)\r
1666                 {\r
1667                         OverrideMaterial2D.Lighting=false;\r
1668                         OverrideMaterial2D.ZWriteEnable=EZW_OFF;\r
1669                         OverrideMaterial2D.ZBuffer=ECFN_DISABLED; // it will be ECFN_DISABLED after merge\r
1670                         OverrideMaterial2D.Lighting=false;\r
1671 \r
1672                         Material = OverrideMaterial2D;\r
1673                 }\r
1674         }\r
1675 \r
1676 \r
1677         //! \return Returns the name of the video driver.\r
1678         const wchar_t* COpenGL3Driver::getName() const\r
1679         {\r
1680                 return Name.c_str();\r
1681         }\r
1682 \r
1683         void COpenGL3Driver::setViewPort(const core::rect<s32>& area)\r
1684         {\r
1685                 core::rect<s32> vp = area;\r
1686                 core::rect<s32> rendert(0, 0, getCurrentRenderTargetSize().Width, getCurrentRenderTargetSize().Height);\r
1687                 vp.clipAgainst(rendert);\r
1688 \r
1689                 if (vp.getHeight() > 0 && vp.getWidth() > 0)\r
1690                         CacheHandler->setViewport(vp.UpperLeftCorner.X, getCurrentRenderTargetSize().Height - vp.UpperLeftCorner.Y - vp.getHeight(), vp.getWidth(), vp.getHeight());\r
1691 \r
1692                 ViewPort = vp;\r
1693         }\r
1694 \r
1695 \r
1696         void COpenGL3Driver::setViewPortRaw(u32 width, u32 height)\r
1697         {\r
1698                 CacheHandler->setViewport(0, 0, width, height);\r
1699                 ViewPort = core::recti(0, 0, width, height);\r
1700         }\r
1701 \r
1702 \r
1703         //! Draws a 3d line.\r
1704         void COpenGL3Driver::draw3DLine(const core::vector3df& start,\r
1705                         const core::vector3df& end, SColor color)\r
1706         {\r
1707                 setRenderStates3DMode();\r
1708 \r
1709                 u16 indices[] = {0, 1};\r
1710                 S3DVertex vertices[2];\r
1711                 vertices[0] = S3DVertex(start.X, start.Y, start.Z, 0, 0, 1, color, 0, 0);\r
1712                 vertices[1] = S3DVertex(end.X, end.Y, end.Z, 0, 0, 1, color, 0, 0);\r
1713 \r
1714                 glEnableVertexAttribArray(EVA_POSITION);\r
1715                 glEnableVertexAttribArray(EVA_COLOR);\r
1716                 glVertexAttribPointer(EVA_POSITION, 3, GL_FLOAT, false, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].Pos);\r
1717                 glVertexAttribPointer(EVA_COLOR, 4, GL_UNSIGNED_BYTE, true, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].Color);\r
1718                 glDrawElements(GL_LINES, 2, GL_UNSIGNED_SHORT, indices);\r
1719                 glDisableVertexAttribArray(EVA_COLOR);\r
1720                 glDisableVertexAttribArray(EVA_POSITION);\r
1721         }\r
1722 \r
1723 \r
1724         //! Only used by the internal engine. Used to notify the driver that\r
1725         //! the window was resized.\r
1726         void COpenGL3Driver::OnResize(const core::dimension2d<u32>& size)\r
1727         {\r
1728                 CNullDriver::OnResize(size);\r
1729                 CacheHandler->setViewport(0, 0, size.Width, size.Height);\r
1730                 Transformation3DChanged = true;\r
1731         }\r
1732 \r
1733 \r
1734         //! Returns type of video driver\r
1735         E_DRIVER_TYPE COpenGL3Driver::getDriverType() const\r
1736         {\r
1737                 return EDT_OGLES2;\r
1738         }\r
1739 \r
1740 \r
1741         //! returns color format\r
1742         ECOLOR_FORMAT COpenGL3Driver::getColorFormat() const\r
1743         {\r
1744                 return ColorFormat;\r
1745         }\r
1746 \r
1747 \r
1748         //! Get a vertex shader constant index.\r
1749         s32 COpenGL3Driver::getVertexShaderConstantID(const c8* name)\r
1750         {\r
1751                 return getPixelShaderConstantID(name);\r
1752         }\r
1753 \r
1754         //! Get a pixel shader constant index.\r
1755         s32 COpenGL3Driver::getPixelShaderConstantID(const c8* name)\r
1756         {\r
1757                 os::Printer::log("Error: Please call services->getPixelShaderConstantID(), not VideoDriver->getPixelShaderConstantID().");\r
1758                 return -1;\r
1759         }\r
1760 \r
1761         //! Sets a vertex shader constant.\r
1762         void COpenGL3Driver::setVertexShaderConstant(const f32* data, s32 startRegister, s32 constantAmount)\r
1763         {\r
1764                 os::Printer::log("Error: Please call services->setVertexShaderConstant(), not VideoDriver->setPixelShaderConstant().");\r
1765         }\r
1766 \r
1767         //! Sets a pixel shader constant.\r
1768         void COpenGL3Driver::setPixelShaderConstant(const f32* data, s32 startRegister, s32 constantAmount)\r
1769         {\r
1770                 os::Printer::log("Error: Please call services->setPixelShaderConstant(), not VideoDriver->setPixelShaderConstant().");\r
1771         }\r
1772 \r
1773         //! Sets a constant for the vertex shader based on an index.\r
1774         bool COpenGL3Driver::setVertexShaderConstant(s32 index, const f32* floats, int count)\r
1775         {\r
1776                 os::Printer::log("Error: Please call services->setVertexShaderConstant(), not VideoDriver->setVertexShaderConstant().");\r
1777                 return false;\r
1778         }\r
1779 \r
1780         //! Int interface for the above.\r
1781         bool COpenGL3Driver::setVertexShaderConstant(s32 index, const s32* ints, int count)\r
1782         {\r
1783                 os::Printer::log("Error: Please call services->setVertexShaderConstant(), not VideoDriver->setVertexShaderConstant().");\r
1784                 return false;\r
1785         }\r
1786 \r
1787         bool COpenGL3Driver::setVertexShaderConstant(s32 index, const u32* ints, int count)\r
1788         {\r
1789                 os::Printer::log("Error: Please call services->setVertexShaderConstant(), not VideoDriver->setVertexShaderConstant().");\r
1790                 return false;\r
1791         }\r
1792 \r
1793         //! Sets a constant for the pixel shader based on an index.\r
1794         bool COpenGL3Driver::setPixelShaderConstant(s32 index, const f32* floats, int count)\r
1795         {\r
1796                 os::Printer::log("Error: Please call services->setPixelShaderConstant(), not VideoDriver->setPixelShaderConstant().");\r
1797                 return false;\r
1798         }\r
1799 \r
1800         //! Int interface for the above.\r
1801         bool COpenGL3Driver::setPixelShaderConstant(s32 index, const s32* ints, int count)\r
1802         {\r
1803                 os::Printer::log("Error: Please call services->setPixelShaderConstant(), not VideoDriver->setPixelShaderConstant().");\r
1804                 return false;\r
1805         }\r
1806 \r
1807         bool COpenGL3Driver::setPixelShaderConstant(s32 index, const u32* ints, int count)\r
1808         {\r
1809                 os::Printer::log("Error: Please call services->setPixelShaderConstant(), not VideoDriver->setPixelShaderConstant().");\r
1810                 return false;\r
1811         }\r
1812 \r
1813         //! Adds a new material renderer to the VideoDriver, using pixel and/or\r
1814         //! vertex shaders to render geometry.\r
1815         s32 COpenGL3Driver::addShaderMaterial(const c8* vertexShaderProgram,\r
1816                         const c8* pixelShaderProgram,\r
1817                         IShaderConstantSetCallBack* callback,\r
1818                         E_MATERIAL_TYPE baseMaterial, s32 userData)\r
1819         {\r
1820                 os::Printer::log("No shader support.");\r
1821                 return -1;\r
1822         }\r
1823 \r
1824 \r
1825         //! Adds a new material renderer to the VideoDriver, using GLSL to render geometry.\r
1826         s32 COpenGL3Driver::addHighLevelShaderMaterial(\r
1827                         const c8* vertexShaderProgram,\r
1828                         const c8* vertexShaderEntryPointName,\r
1829                         E_VERTEX_SHADER_TYPE vsCompileTarget,\r
1830                         const c8* pixelShaderProgram,\r
1831                         const c8* pixelShaderEntryPointName,\r
1832                         E_PIXEL_SHADER_TYPE psCompileTarget,\r
1833                         const c8* geometryShaderProgram,\r
1834                         const c8* geometryShaderEntryPointName,\r
1835                         E_GEOMETRY_SHADER_TYPE gsCompileTarget,\r
1836                         scene::E_PRIMITIVE_TYPE inType,\r
1837                         scene::E_PRIMITIVE_TYPE outType,\r
1838                         u32 verticesOut,\r
1839                         IShaderConstantSetCallBack* callback,\r
1840                         E_MATERIAL_TYPE baseMaterial,\r
1841                         s32 userData)\r
1842         {\r
1843                 s32 nr = -1;\r
1844                 COpenGL3MaterialRenderer* r = new COpenGL3MaterialRenderer(\r
1845                         this, nr, vertexShaderProgram,\r
1846                         pixelShaderProgram,\r
1847                         callback, baseMaterial, userData);\r
1848 \r
1849                 r->drop();\r
1850                 return nr;\r
1851         }\r
1852 \r
1853         //! Returns a pointer to the IVideoDriver interface. (Implementation for\r
1854         //! IMaterialRendererServices)\r
1855         IVideoDriver* COpenGL3Driver::getVideoDriver()\r
1856         {\r
1857                 return this;\r
1858         }\r
1859 \r
1860 \r
1861         //! Returns pointer to the IGPUProgrammingServices interface.\r
1862         IGPUProgrammingServices* COpenGL3Driver::getGPUProgrammingServices()\r
1863         {\r
1864                 return this;\r
1865         }\r
1866 \r
1867         ITexture* COpenGL3Driver::addRenderTargetTexture(const core::dimension2d<u32>& size,\r
1868                 const io::path& name, const ECOLOR_FORMAT format)\r
1869         {\r
1870                 //disable mip-mapping\r
1871                 bool generateMipLevels = getTextureCreationFlag(ETCF_CREATE_MIP_MAPS);\r
1872                 setTextureCreationFlag(ETCF_CREATE_MIP_MAPS, false);\r
1873 \r
1874                 COpenGL3Texture* renderTargetTexture = new COpenGL3Texture(name, size, ETT_2D, format, this);\r
1875                 addTexture(renderTargetTexture);\r
1876                 renderTargetTexture->drop();\r
1877 \r
1878                 //restore mip-mapping\r
1879                 setTextureCreationFlag(ETCF_CREATE_MIP_MAPS, generateMipLevels);\r
1880 \r
1881                 return renderTargetTexture;\r
1882         }\r
1883 \r
1884         ITexture* COpenGL3Driver::addRenderTargetTextureCubemap(const irr::u32 sideLen, const io::path& name, const ECOLOR_FORMAT format)\r
1885         {\r
1886                 //disable mip-mapping\r
1887                 bool generateMipLevels = getTextureCreationFlag(ETCF_CREATE_MIP_MAPS);\r
1888                 setTextureCreationFlag(ETCF_CREATE_MIP_MAPS, false);\r
1889 \r
1890                 bool supportForFBO = (Feature.ColorAttachment > 0);\r
1891 \r
1892                 const core::dimension2d<u32> size(sideLen, sideLen);\r
1893                 core::dimension2du destSize(size);\r
1894 \r
1895                 if (!supportForFBO)\r
1896                 {\r
1897                         destSize = core::dimension2d<u32>(core::min_(size.Width, ScreenSize.Width), core::min_(size.Height, ScreenSize.Height));\r
1898                         destSize = destSize.getOptimalSize((size == size.getOptimalSize()), false, false);\r
1899                 }\r
1900 \r
1901                 COpenGL3Texture* renderTargetTexture = new COpenGL3Texture(name, destSize, ETT_CUBEMAP, format, this);\r
1902                 addTexture(renderTargetTexture);\r
1903                 renderTargetTexture->drop();\r
1904 \r
1905                 //restore mip-mapping\r
1906                 setTextureCreationFlag(ETCF_CREATE_MIP_MAPS, generateMipLevels);\r
1907 \r
1908                 return renderTargetTexture;\r
1909         }\r
1910 \r
1911 \r
1912         //! Returns the maximum amount of primitives\r
1913         u32 COpenGL3Driver::getMaximalPrimitiveCount() const\r
1914         {\r
1915                 return 65535;\r
1916         }\r
1917 \r
1918         bool COpenGL3Driver::setRenderTargetEx(IRenderTarget* target, u16 clearFlag, SColor clearColor, f32 clearDepth, u8 clearStencil)\r
1919         {\r
1920                 if (target && target->getDriverType() != EDT_OGLES2  && target->getDriverType() != EDT_WEBGL1)\r
1921                 {\r
1922                         os::Printer::log("Fatal Error: Tried to set a render target not owned by OGLES2 driver.", ELL_ERROR);\r
1923                         return false;\r
1924                 }\r
1925 \r
1926                 core::dimension2d<u32> destRenderTargetSize(0, 0);\r
1927 \r
1928                 if (target)\r
1929                 {\r
1930                         COpenGL3RenderTarget* renderTarget = static_cast<COpenGL3RenderTarget*>(target);\r
1931 \r
1932                         CacheHandler->setFBO(renderTarget->getBufferID());\r
1933                         renderTarget->update();\r
1934 \r
1935                         destRenderTargetSize = renderTarget->getSize();\r
1936 \r
1937                         setViewPortRaw(destRenderTargetSize.Width, destRenderTargetSize.Height);\r
1938                 }\r
1939                 else\r
1940                 {\r
1941                         CacheHandler->setFBO(0);\r
1942 \r
1943                         destRenderTargetSize = core::dimension2d<u32>(0, 0);\r
1944 \r
1945                         setViewPortRaw(ScreenSize.Width, ScreenSize.Height);\r
1946                 }\r
1947 \r
1948                 if (CurrentRenderTargetSize != destRenderTargetSize)\r
1949                 {\r
1950                         CurrentRenderTargetSize = destRenderTargetSize;\r
1951 \r
1952                         Transformation3DChanged = true;\r
1953                 }\r
1954 \r
1955                 CurrentRenderTarget = target;\r
1956 \r
1957                 clearBuffers(clearFlag, clearColor, clearDepth, clearStencil);\r
1958 \r
1959                 return true;\r
1960         }\r
1961 \r
1962         void COpenGL3Driver::clearBuffers(u16 flag, SColor color, f32 depth, u8 stencil)\r
1963         {\r
1964                 GLbitfield mask = 0;\r
1965                 u8 colorMask = 0;\r
1966                 bool depthMask = false;\r
1967 \r
1968                 CacheHandler->getColorMask(colorMask);\r
1969                 CacheHandler->getDepthMask(depthMask);\r
1970 \r
1971                 if (flag & ECBF_COLOR)\r
1972                 {\r
1973                         CacheHandler->setColorMask(ECP_ALL);\r
1974 \r
1975                         const f32 inv = 1.0f / 255.0f;\r
1976                         glClearColor(color.getRed() * inv, color.getGreen() * inv,\r
1977                                 color.getBlue() * inv, color.getAlpha() * inv);\r
1978 \r
1979                         mask |= GL_COLOR_BUFFER_BIT;\r
1980                 }\r
1981 \r
1982                 if (flag & ECBF_DEPTH)\r
1983                 {\r
1984                         CacheHandler->setDepthMask(true);\r
1985                         glClearDepthf(depth);\r
1986                         mask |= GL_DEPTH_BUFFER_BIT;\r
1987                 }\r
1988 \r
1989                 if (flag & ECBF_STENCIL)\r
1990                 {\r
1991                         glClearStencil(stencil);\r
1992                         mask |= GL_STENCIL_BUFFER_BIT;\r
1993                 }\r
1994 \r
1995                 if (mask)\r
1996                         glClear(mask);\r
1997 \r
1998                 CacheHandler->setColorMask(colorMask);\r
1999                 CacheHandler->setDepthMask(depthMask);\r
2000         }\r
2001 \r
2002 \r
2003         //! Returns an image created from the last rendered frame.\r
2004         // We want to read the front buffer to get the latest render finished.\r
2005         // This is not possible under ogl-es, though, so one has to call this method\r
2006         // outside of the render loop only.\r
2007         IImage* COpenGL3Driver::createScreenShot(video::ECOLOR_FORMAT format, video::E_RENDER_TARGET target)\r
2008         {\r
2009                 if (target==video::ERT_MULTI_RENDER_TEXTURES || target==video::ERT_RENDER_TEXTURE || target==video::ERT_STEREO_BOTH_BUFFERS)\r
2010                         return 0;\r
2011 \r
2012                 GLint internalformat = GL_RGBA;\r
2013                 GLint type = GL_UNSIGNED_BYTE;\r
2014                 {\r
2015 //                      glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &internalformat);\r
2016 //                      glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &type);\r
2017                         // there's a format we don't support ATM\r
2018                         if (GL_UNSIGNED_SHORT_4_4_4_4 == type)\r
2019                         {\r
2020                                 internalformat = GL_RGBA;\r
2021                                 type = GL_UNSIGNED_BYTE;\r
2022                         }\r
2023                 }\r
2024 \r
2025                 IImage* newImage = 0;\r
2026                 if (GL_RGBA == internalformat)\r
2027                 {\r
2028                         if (GL_UNSIGNED_BYTE == type)\r
2029                                 newImage = new CImage(ECF_A8R8G8B8, ScreenSize);\r
2030                         else\r
2031                                 newImage = new CImage(ECF_A1R5G5B5, ScreenSize);\r
2032                 }\r
2033                 else\r
2034                 {\r
2035                         if (GL_UNSIGNED_BYTE == type)\r
2036                                 newImage = new CImage(ECF_R8G8B8, ScreenSize);\r
2037                         else\r
2038                                 newImage = new CImage(ECF_R5G6B5, ScreenSize);\r
2039                 }\r
2040 \r
2041                 if (!newImage)\r
2042                         return 0;\r
2043 \r
2044                 u8* pixels = static_cast<u8*>(newImage->getData());\r
2045                 if (!pixels)\r
2046                 {\r
2047                         newImage->drop();\r
2048                         return 0;\r
2049                 }\r
2050 \r
2051                 glReadPixels(0, 0, ScreenSize.Width, ScreenSize.Height, internalformat, type, pixels);\r
2052                 testGLError(__LINE__);\r
2053 \r
2054                 // opengl images are horizontally flipped, so we have to fix that here.\r
2055                 const s32 pitch = newImage->getPitch();\r
2056                 u8* p2 = pixels + (ScreenSize.Height - 1) * pitch;\r
2057                 u8* tmpBuffer = new u8[pitch];\r
2058                 for (u32 i = 0; i < ScreenSize.Height; i += 2)\r
2059                 {\r
2060                         memcpy(tmpBuffer, pixels, pitch);\r
2061                         memcpy(pixels, p2, pitch);\r
2062                         memcpy(p2, tmpBuffer, pitch);\r
2063                         pixels += pitch;\r
2064                         p2 -= pitch;\r
2065                 }\r
2066                 delete [] tmpBuffer;\r
2067 \r
2068                 // also GL_RGBA doesn't match the internal encoding of the image (which is BGRA)\r
2069                 if (GL_RGBA == internalformat && GL_UNSIGNED_BYTE == type)\r
2070                 {\r
2071                         pixels = static_cast<u8*>(newImage->getData());\r
2072                         for (u32 i = 0; i < ScreenSize.Height; i++)\r
2073                         {\r
2074                                 for (u32 j = 0; j < ScreenSize.Width; j++)\r
2075                                 {\r
2076                                         u32 c = *(u32*) (pixels + 4 * j);\r
2077                                         *(u32*) (pixels + 4 * j) = (c & 0xFF00FF00) |\r
2078                                                 ((c & 0x00FF0000) >> 16) | ((c & 0x000000FF) << 16);\r
2079                                 }\r
2080                                 pixels += pitch;\r
2081                         }\r
2082                 }\r
2083 \r
2084                 if (testGLError(__LINE__))\r
2085                 {\r
2086                         newImage->drop();\r
2087                         return 0;\r
2088                 }\r
2089                 testGLError(__LINE__);\r
2090                 return newImage;\r
2091         }\r
2092 \r
2093         void COpenGL3Driver::removeTexture(ITexture* texture)\r
2094         {\r
2095                 CacheHandler->getTextureCache().remove(texture);\r
2096                 CNullDriver::removeTexture(texture);\r
2097         }\r
2098 \r
2099         //! Set/unset a clipping plane.\r
2100         bool COpenGL3Driver::setClipPlane(u32 index, const core::plane3df& plane, bool enable)\r
2101         {\r
2102                 if (index >= UserClipPlane.size())\r
2103                         UserClipPlane.push_back(SUserClipPlane());\r
2104 \r
2105                 UserClipPlane[index].Plane = plane;\r
2106                 UserClipPlane[index].Enabled = enable;\r
2107                 return true;\r
2108         }\r
2109 \r
2110         //! Enable/disable a clipping plane.\r
2111         void COpenGL3Driver::enableClipPlane(u32 index, bool enable)\r
2112         {\r
2113                 UserClipPlane[index].Enabled = enable;\r
2114         }\r
2115 \r
2116         //! Get the ClipPlane Count\r
2117         u32 COpenGL3Driver::getClipPlaneCount() const\r
2118         {\r
2119                 return UserClipPlane.size();\r
2120         }\r
2121 \r
2122         const core::plane3df& COpenGL3Driver::getClipPlane(irr::u32 index) const\r
2123         {\r
2124                 if (index < UserClipPlane.size())\r
2125                         return UserClipPlane[index].Plane;\r
2126                 else\r
2127                 {\r
2128                         _IRR_DEBUG_BREAK_IF(true)       // invalid index\r
2129                         static const core::plane3df dummy;\r
2130                         return dummy;\r
2131                 }\r
2132         }\r
2133 \r
2134         core::dimension2du COpenGL3Driver::getMaxTextureSize() const\r
2135         {\r
2136                 return core::dimension2du(MaxTextureSize, MaxTextureSize);\r
2137         }\r
2138 \r
2139         GLenum COpenGL3Driver::getGLBlend(E_BLEND_FACTOR factor) const\r
2140         {\r
2141                 static GLenum const blendTable[] =\r
2142                 {\r
2143                         GL_ZERO,\r
2144                         GL_ONE,\r
2145                         GL_DST_COLOR,\r
2146                         GL_ONE_MINUS_DST_COLOR,\r
2147                         GL_SRC_COLOR,\r
2148                         GL_ONE_MINUS_SRC_COLOR,\r
2149                         GL_SRC_ALPHA,\r
2150                         GL_ONE_MINUS_SRC_ALPHA,\r
2151                         GL_DST_ALPHA,\r
2152                         GL_ONE_MINUS_DST_ALPHA,\r
2153                         GL_SRC_ALPHA_SATURATE\r
2154                 };\r
2155 \r
2156                 return blendTable[factor];\r
2157         }\r
2158 \r
2159         GLenum COpenGL3Driver::getZBufferBits() const\r
2160         {\r
2161                 // TODO: never used, so not sure what this was really about (zbuffer used by device? Or for RTT's?)\r
2162 \r
2163                 GLenum bits = 0;\r
2164 \r
2165                 switch (Params.ZBufferBits)\r
2166                 {\r
2167                 case 24:\r
2168 #if defined(GL_OES_depth24)\r
2169                         if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_OES_depth24))\r
2170                                 bits = GL_DEPTH_COMPONENT24_OES;\r
2171                         else\r
2172 #endif\r
2173                                 bits = GL_DEPTH_COMPONENT16;\r
2174                         break;\r
2175                 case 32:\r
2176 #if defined(GL_OES_depth32)\r
2177                         if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_OES_depth32))\r
2178                                 bits = GL_DEPTH_COMPONENT32_OES;\r
2179                         else\r
2180 #endif\r
2181                                 bits = GL_DEPTH_COMPONENT16;\r
2182                         break;\r
2183                 default:\r
2184                         bits = GL_DEPTH_COMPONENT16;\r
2185                         break;\r
2186                 }\r
2187 \r
2188                 return bits;\r
2189         }\r
2190 \r
2191         bool COpenGL3Driver::getColorFormatParameters(ECOLOR_FORMAT format, GLint& internalFormat, GLenum& pixelFormat,\r
2192                 GLenum& pixelType, void(**converter)(const void*, s32, void*)) const\r
2193         {\r
2194                 bool supported = false;\r
2195                 pixelFormat = GL_RGBA;\r
2196                 pixelType = GL_UNSIGNED_BYTE;\r
2197                 *converter = 0;\r
2198 \r
2199                 switch (format)\r
2200                 {\r
2201                 case ECF_A1R5G5B5:\r
2202                         supported = true;\r
2203                         pixelFormat = GL_RGBA;\r
2204                         pixelType = GL_UNSIGNED_SHORT_5_5_5_1;\r
2205                         *converter = CColorConverter::convert_A1R5G5B5toR5G5B5A1;\r
2206                         break;\r
2207                 case ECF_R5G6B5:\r
2208                         supported = true;\r
2209                         pixelFormat = GL_RGB;\r
2210                         pixelType = GL_UNSIGNED_SHORT_5_6_5;\r
2211                         break;\r
2212                 case ECF_R8G8B8:\r
2213                         supported = true;\r
2214                         pixelFormat = GL_RGB;\r
2215                         pixelType = GL_UNSIGNED_BYTE;\r
2216                         break;\r
2217                 case ECF_A8R8G8B8:\r
2218                         supported = true;\r
2219                         if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_IMG_texture_format_BGRA8888) ||\r
2220                                 queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_EXT_texture_format_BGRA8888) ||\r
2221                                 queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_APPLE_texture_format_BGRA8888))\r
2222                         {\r
2223                                 pixelFormat = GL_BGRA;\r
2224                         }\r
2225                         else\r
2226                         {\r
2227                                 pixelFormat = GL_RGBA;\r
2228                                 *converter = CColorConverter::convert_A8R8G8B8toA8B8G8R8;\r
2229                         }\r
2230                         pixelType = GL_UNSIGNED_BYTE;\r
2231                         break;\r
2232 #ifdef GL_EXT_texture_compression_s3tc\r
2233                 case ECF_DXT1:\r
2234                         supported = true;\r
2235                         pixelFormat = GL_RGBA;\r
2236                         pixelType = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;\r
2237                         break;\r
2238 #endif\r
2239 #ifdef GL_EXT_texture_compression_s3tc\r
2240                 case ECF_DXT2:\r
2241                 case ECF_DXT3:\r
2242                         supported = true;\r
2243                         pixelFormat = GL_RGBA;\r
2244                         pixelType = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;\r
2245                         break;\r
2246 #endif\r
2247 #ifdef GL_EXT_texture_compression_s3tc\r
2248                 case ECF_DXT4:\r
2249                 case ECF_DXT5:\r
2250                         supported = true;\r
2251                         pixelFormat = GL_RGBA;\r
2252                         pixelType = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;\r
2253                         break;\r
2254 #endif\r
2255 #ifdef GL_IMG_texture_compression_pvrtc\r
2256                 case ECF_PVRTC_RGB2:\r
2257                         supported = true;\r
2258                         pixelFormat = GL_RGB;\r
2259                         pixelType = GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG;\r
2260                         break;\r
2261 #endif\r
2262 #ifdef GL_IMG_texture_compression_pvrtc\r
2263                 case ECF_PVRTC_ARGB2:\r
2264                         supported = true;\r
2265                         pixelFormat = GL_RGBA;\r
2266                         pixelType = GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;\r
2267                         break;\r
2268 #endif\r
2269 #ifdef GL_IMG_texture_compression_pvrtc\r
2270                 case ECF_PVRTC_RGB4:\r
2271                         supported = true;\r
2272                         pixelFormat = GL_RGB;\r
2273                         pixelType = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG;\r
2274                         break;\r
2275 #endif\r
2276 #ifdef GL_IMG_texture_compression_pvrtc\r
2277                 case ECF_PVRTC_ARGB4:\r
2278                         supported = true;\r
2279                         pixelFormat = GL_RGBA;\r
2280                         pixelType = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;\r
2281                         break;\r
2282 #endif\r
2283 #ifdef GL_IMG_texture_compression_pvrtc2\r
2284                 case ECF_PVRTC2_ARGB2:\r
2285                         supported = true;\r
2286                         pixelFormat = GL_RGBA;\r
2287                         pixelType = GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG;\r
2288                         break;\r
2289 #endif\r
2290 #ifdef GL_IMG_texture_compression_pvrtc2\r
2291                 case ECF_PVRTC2_ARGB4:\r
2292                         supported = true;\r
2293                         pixelFormat = GL_RGBA;\r
2294                         pixelType = GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG;\r
2295                         break;\r
2296 #endif\r
2297 #ifdef GL_OES_compressed_ETC1_RGB8_texture\r
2298                 case ECF_ETC1:\r
2299                         supported = true;\r
2300                         pixelFormat = GL_RGB;\r
2301                         pixelType = GL_ETC1_RGB8_OES;\r
2302                         break;\r
2303 #endif\r
2304 #ifdef GL_ES_VERSION_3_0 // TO-DO - fix when extension name will be available\r
2305                 case ECF_ETC2_RGB:\r
2306                         supported = true;\r
2307                         pixelFormat = GL_RGB;\r
2308                         pixelType = GL_COMPRESSED_RGB8_ETC2;\r
2309                         break;\r
2310 #endif\r
2311 #ifdef GL_ES_VERSION_3_0 // TO-DO - fix when extension name will be available\r
2312                 case ECF_ETC2_ARGB:\r
2313                         supported = true;\r
2314                         pixelFormat = GL_RGBA;\r
2315                         pixelType = GL_COMPRESSED_RGBA8_ETC2_EAC;\r
2316                         break;\r
2317 #endif\r
2318                 case ECF_D16:\r
2319                         supported = true;\r
2320                         pixelFormat = GL_DEPTH_COMPONENT;\r
2321                         pixelType = GL_UNSIGNED_SHORT;\r
2322                         break;\r
2323                 case ECF_D32:\r
2324 #if defined(GL_OES_depth32)\r
2325                         if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_OES_depth32))\r
2326                         {\r
2327                                 supported = true;\r
2328                                 pixelFormat = GL_DEPTH_COMPONENT;\r
2329                                 pixelType = GL_UNSIGNED_INT;\r
2330                         }\r
2331 #endif\r
2332                         break;\r
2333                 case ECF_D24S8:\r
2334 #ifdef GL_OES_packed_depth_stencil\r
2335                         if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_OES_packed_depth_stencil))\r
2336                         {\r
2337                                 supported = true;\r
2338                                 pixelFormat = GL_DEPTH_STENCIL_OES;\r
2339                                 pixelType = GL_UNSIGNED_INT_24_8_OES;\r
2340                         }\r
2341 #endif\r
2342                         break;\r
2343                 case ECF_R8:\r
2344 #if defined(GL_EXT_texture_rg)\r
2345                         if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_EXT_texture_rg))\r
2346                         {\r
2347                                 supported = true;\r
2348                                 pixelFormat = GL_RED_EXT;\r
2349                                 pixelType = GL_UNSIGNED_BYTE;\r
2350                         }\r
2351 #endif\r
2352                         break;\r
2353                 case ECF_R8G8:\r
2354 #if defined(GL_EXT_texture_rg)\r
2355                         if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_EXT_texture_rg))\r
2356                         {\r
2357                                 supported = true;\r
2358                                 pixelFormat = GL_RG_EXT;\r
2359                                 pixelType = GL_UNSIGNED_BYTE;\r
2360                         }\r
2361 #endif\r
2362                         break;\r
2363                 case ECF_R16:\r
2364                         break;\r
2365                 case ECF_R16G16:\r
2366                         break;\r
2367                 case ECF_R16F:\r
2368 #if defined(GL_OES_texture_half_float) && defined(GL_EXT_texture_rg)\r
2369                         if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_EXT_texture_rg)\r
2370                                 && queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_OES_texture_half_float)\r
2371                                 )\r
2372                         {\r
2373                                 supported = true;\r
2374                                 pixelFormat = GL_RED_EXT;\r
2375                                 pixelType = GL_HALF_FLOAT_OES ;\r
2376                         }\r
2377 #endif\r
2378                         break;\r
2379                 case ECF_G16R16F:\r
2380 #if defined(GL_OES_texture_half_float) && defined(GL_EXT_texture_rg)\r
2381                         if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_EXT_texture_rg)\r
2382                                 && queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_OES_texture_half_float)\r
2383                                 )\r
2384                         {\r
2385                                 supported = true;\r
2386                                 pixelFormat = GL_RG_EXT;\r
2387                                 pixelType = GL_HALF_FLOAT_OES ;\r
2388                         }\r
2389 #endif\r
2390                         break;\r
2391                 case ECF_A16B16G16R16F:\r
2392 #if defined(GL_OES_texture_half_float)\r
2393                         if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_OES_texture_half_float))\r
2394                         {\r
2395                                 supported = true;\r
2396                                 pixelFormat = GL_RGBA;\r
2397                                 pixelType = GL_HALF_FLOAT_OES ;\r
2398                         }\r
2399 #endif\r
2400                         break;\r
2401                 case ECF_R32F:\r
2402 #if defined(GL_OES_texture_float) && defined(GL_EXT_texture_rg)\r
2403                         if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_EXT_texture_rg)\r
2404                                 && queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_OES_texture_float)\r
2405                                 )\r
2406                         {\r
2407                                 supported = true;\r
2408                                 pixelFormat = GL_RED_EXT;\r
2409                                 pixelType = GL_FLOAT;\r
2410                         }\r
2411 #endif\r
2412                         break;\r
2413                 case ECF_G32R32F:\r
2414 #if defined(GL_OES_texture_float) && defined(GL_EXT_texture_rg)\r
2415                         if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_EXT_texture_rg)\r
2416                                 && queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_OES_texture_float)\r
2417                                 )\r
2418                         {\r
2419                                 supported = true;\r
2420                                 pixelFormat = GL_RG_EXT;\r
2421                                 pixelType = GL_FLOAT;\r
2422                         }\r
2423 #endif\r
2424                         break;\r
2425                 case ECF_A32B32G32R32F:\r
2426 #if defined(GL_OES_texture_float)\r
2427                         if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_OES_texture_half_float))\r
2428                         {\r
2429                                 supported = true;\r
2430                                 pixelFormat = GL_RGBA;\r
2431                                 pixelType = GL_FLOAT ;\r
2432                         }\r
2433 #endif\r
2434                         break;\r
2435                 default:\r
2436                         break;\r
2437                 }\r
2438 \r
2439                 // ES 2.0 says internalFormat must match pixelFormat (chapter 3.7.1 in Spec).\r
2440                 // Doesn't mention if "match" means "equal" or some other way of matching, but\r
2441                 // some bug on Emscripten and browsing discussions by others lead me to believe\r
2442                 // it means they have to be equal. Note that this was different in OpenGL.\r
2443                 internalFormat = pixelFormat;\r
2444 \r
2445 #ifdef _IRR_IOS_PLATFORM_\r
2446                 if (internalFormat == GL_BGRA)\r
2447                         internalFormat = GL_RGBA;\r
2448 #endif\r
2449 \r
2450                 return supported;\r
2451         }\r
2452 \r
2453         bool COpenGL3Driver::queryTextureFormat(ECOLOR_FORMAT format) const\r
2454         {\r
2455                 GLint dummyInternalFormat;\r
2456                 GLenum dummyPixelFormat;\r
2457                 GLenum dummyPixelType;\r
2458                 void (*dummyConverter)(const void*, s32, void*);\r
2459                 return getColorFormatParameters(format, dummyInternalFormat, dummyPixelFormat, dummyPixelType, &dummyConverter);\r
2460         }\r
2461 \r
2462         bool COpenGL3Driver::needsTransparentRenderPass(const irr::video::SMaterial& material) const\r
2463         {\r
2464                 return CNullDriver::needsTransparentRenderPass(material) || material.isAlphaBlendOperation();\r
2465         }\r
2466 \r
2467         const SMaterial& COpenGL3Driver::getCurrentMaterial() const\r
2468         {\r
2469                 return Material;\r
2470         }\r
2471 \r
2472         COpenGL3CacheHandler* COpenGL3Driver::getCacheHandler() const\r
2473         {\r
2474                 return CacheHandler;\r
2475         }\r
2476 \r
2477 \r
2478 IVideoDriver* createOpenGL3Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager)\r
2479 {\r
2480         COpenGL3Driver* driver = new COpenGL3Driver(params, io, contextManager);\r
2481         driver->genericDriverInit(params.WindowSize, params.Stencilbuffer);     // don't call in constructor, it uses virtual function calls of driver\r
2482         return driver;\r
2483 }\r
2484 \r
2485 } // end namespace\r
2486 } // end namespace\r