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