Split new GL3/GLES2 drivers

The classes are tiny wrappers currently but should they be customized, they are there

diff --git a/source/Irrlicht/CIrrDeviceSDL.cpp b/source/Irrlicht/CIrrDeviceSDL.cpp
index 48c586169d9f8b8cf9c162639118fe2a2a22ba8c..6ebf63b975ff7cb316879b9fca6a632b15f227bb 100644 (file)
--- a/source/Irrlicht/CIrrDeviceSDL.cpp
+++ b/source/Irrlicht/CIrrDeviceSDL.cpp
@@ -56,10 +56,15 @@ namespace irr
                }\r
                #endif\r
 \r
-               static IVideoDriver* createOpenGLES2Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager)\r
+               #ifdef _IRR_COMPILE_WITH_OGLES2_\r
+               IVideoDriver* createOGLES2Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager);\r
+               #else\r
+               static IVideoDriver* createOGLES2Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager)\r
                {\r
-                       return createOpenGL3Driver(params, io, contextManager);\r
+                       os::Printer::log("No OpenGL ES 2 support compiled in.", ELL_ERROR);\r
+                       return nullptr;\r
                }\r
+               #endif\r
 \r
                #ifdef _IRR_COMPILE_WITH_WEBGL1_\r
                IVideoDriver* createWebGL1Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager);\r
@@ -506,7 +511,7 @@ void CIrrDeviceSDL::createDriver()
        {\r
        case video::EDT_OPENGL: VideoDriver = video::createOpenGLDriver(CreationParams, FileSystem, ContextManager); break;\r
        case video::EDT_OPENGL3: VideoDriver = video::createOpenGL3Driver(CreationParams, FileSystem, ContextManager); break;\r
-       case video::EDT_OGLES2: VideoDriver = video::createOpenGLES2Driver(CreationParams, FileSystem, ContextManager); break;\r
+       case video::EDT_OGLES2: VideoDriver = video::createOGLES2Driver(CreationParams, FileSystem, ContextManager); break;\r
        case video::EDT_WEBGL1: VideoDriver = video::createWebGL1Driver(CreationParams, FileSystem, ContextManager); break;\r
        default:;\r
        }\r

diff --git a/source/Irrlicht/CMakeLists.txt b/source/Irrlicht/CMakeLists.txt
index 4b3fa21b68590cd0d31bb0cc1dd5db3f9a8a0b8a..a2ca46e4828c835735a5ae99d86f6dc3d3ca64e1 100644 (file)
--- a/source/Irrlicht/CMakeLists.txt
+++ b/source/Irrlicht/CMakeLists.txt
@@ -198,6 +198,14 @@ if(ENABLE_OPENGL)
        endif()
 endif()
 
+if(ENABLE_OPENGL3)
+       if (NOT USE_SDL2)
+               message(SEND_ERROR "OpenGL3 support requires SDL2")
+       endif()
+       set(USE_SDLGL ON)
+       set(USE_SDLGL3 ON)
+endif()
+
 if(ENABLE_GLES1)
        add_definitions(-D_IRR_COMPILE_WITH_OGLES1_)
        if(DEVICE MATCHES "^WINDOWS|X11|ANDROID$")
@@ -213,6 +221,9 @@ if(ENABLE_GLES2)
                add_definitions(-D_IRR_COMPILE_WITH_EGL_MANAGER_ -D_IRR_OGLES2_USE_EXTPOINTER_)
        elseif(DEVICE STREQUAL "IOS")
                add_definitions(-D_IRR_COMPILE_WITH_EAGL_MANAGER_)
+       elseif(DEVICE STREQUAL "SDL")
+               set(USE_SDLGL ON)
+               set(USE_SDLGLES2 ON)
        endif()
 endif()
 
@@ -232,6 +243,7 @@ endif()
 
 message(STATUS "Device: ${DEVICE}")
 message(STATUS "OpenGL: ${ENABLE_OPENGL}")
+message(STATUS "OpenGL 3: ${ENABLE_OPENGL3}")
 message(STATUS "OpenGL ES: ${ENABLE_GLES1}")
 message(STATUS "OpenGL ES 2: ${ENABLE_GLES2}")
 message(STATUS "WebGL: ${ENABLE_WEBGL1}")
@@ -353,12 +365,6 @@ set(IRRDRVROBJ
        COpenGLExtensionHandler.cpp
        COGLESDriver.cpp
        COGLESExtensionHandler.cpp
-       COGLES2Driver.cpp
-       COGLES2ExtensionHandler.cpp
-       COGLES2FixedPipelineRenderer.cpp
-       COGLES2MaterialRenderer.cpp
-       COGLES2Renderer2D.cpp
-       CWebGL1Driver.cpp
        CGLXManager.cpp
        CWGLManager.cpp
        CEGLManager.cpp
@@ -383,10 +389,7 @@ add_library(IRRVIDEOOBJ OBJECT
        ${IRRIMAGEOBJ}
 )
 
-if(ENABLE_OPENGL3)
-       if (NOT USE_SDL2)
-               message(SEND_ERROR "OpenGL3 support requires SDL2")
-       endif()
+if(USE_SDLGL)
        target_sources(IRRVIDEOOBJ PUBLIC
                OpenGL/Driver.cpp
                OpenGL/ExtensionHandler.cpp
@@ -396,6 +399,27 @@ if(ENABLE_OPENGL3)
        )
 endif()
 
+if(USE_SDLGL3)
+       target_sources(IRRVIDEOOBJ PUBLIC
+               OpenGL3/Driver.cpp
+       )
+endif()
+
+if(USE_SDLGLES2)
+       target_sources(IRRVIDEOOBJ PUBLIC
+               OpenGLES2/Driver.cpp
+       )
+else()
+       target_sources(IRRVIDEOOBJ PUBLIC
+               COGLES2Driver.cpp
+               COGLES2ExtensionHandler.cpp
+               COGLES2FixedPipelineRenderer.cpp
+               COGLES2MaterialRenderer.cpp
+               COGLES2Renderer2D.cpp
+               CWebGL1Driver.cpp
+       )
+endif()
+
 add_library(IRRIOOBJ OBJECT
        CFileList.cpp
        CFileSystem.cpp

diff --git a/source/Irrlicht/OpenGL/Common.h b/source/Irrlicht/OpenGL/Common.h
index 3f71f6508c1d7348df61d3b0dd6d1a602d98d34b..a69bcc62d5963e842521f25dc8e26d6979a89111 100644 (file)
--- a/source/Irrlicht/OpenGL/Common.h
+++ b/source/Irrlicht/OpenGL/Common.h
@@ -27,10 +27,10 @@ namespace video
        template <class TOpenGLDriver, class TOpenGLTexture>\r
        class COpenGLCoreCacheHandler;\r
 \r
-       class COpenGL3Driver;\r
-       typedef COpenGLCoreTexture<COpenGL3Driver> COpenGL3Texture;\r
-       typedef COpenGLCoreRenderTarget<COpenGL3Driver, COpenGL3Texture> COpenGL3RenderTarget;\r
-       typedef COpenGLCoreCacheHandler<COpenGL3Driver, COpenGL3Texture> COpenGL3CacheHandler;\r
+       class COpenGL3DriverBase;\r
+       typedef COpenGLCoreTexture<COpenGL3DriverBase> COpenGL3Texture;\r
+       typedef COpenGLCoreRenderTarget<COpenGL3DriverBase, COpenGL3Texture> COpenGL3RenderTarget;\r
+       typedef COpenGLCoreCacheHandler<COpenGL3DriverBase, COpenGL3Texture> COpenGL3CacheHandler;\r
 \r
 }\r
 }\r

diff --git a/source/Irrlicht/OpenGL/Driver.cpp b/source/Irrlicht/OpenGL/Driver.cpp
index 6a60316dc56c251f6dda64cd4b202baeaa2c0e01..27ab1bad0513b358b916e1bd7e19ba9dd5f8e36e 100644 (file)
--- a/source/Irrlicht/OpenGL/Driver.cpp
+++ b/source/Irrlicht/OpenGL/Driver.cpp
@@ -123,17 +123,17 @@ namespace video
        };\r
 \r
 \r
-void APIENTRY COpenGL3Driver::debugCb(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam)\r
+void APIENTRY COpenGL3DriverBase::debugCb(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam)\r
 {\r
-       ((COpenGL3Driver *)userParam)->debugCb(source, type, id, severity, length, message);\r
+       ((COpenGL3DriverBase *)userParam)->debugCb(source, type, id, severity, length, message);\r
 }\r
 \r
-void COpenGL3Driver::debugCb(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message)\r
+void COpenGL3DriverBase::debugCb(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message)\r
 {\r
        printf("%04x %04x %x %x %.*s\n", source, type, id, severity, length, message);\r
 }\r
 \r
-COpenGL3Driver::COpenGL3Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager) :\r
+COpenGL3DriverBase::COpenGL3DriverBase(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager) :\r
        CNullDriver(io, params.WindowSize), COpenGL3ExtensionHandler(), CacheHandler(0),\r
        Params(params), ResetRenderStates(true), LockRenderStateMode(false), AntiAlias(params.AntiAlias),\r
        MaterialRenderer2DActive(0), MaterialRenderer2DTexture(0), MaterialRenderer2DNoTexture(0),\r
@@ -158,7 +158,7 @@ COpenGL3Driver::COpenGL3Driver(const SIrrlichtCreationParameters& params, io::IF
        initQuadsIndices();\r
 }\r
 \r
-COpenGL3Driver::~COpenGL3Driver()\r
+COpenGL3DriverBase::~COpenGL3DriverBase()\r
 {\r
        deleteMaterialRenders();\r
 \r
@@ -182,7 +182,7 @@ COpenGL3Driver::~COpenGL3Driver()
        }\r
 }\r
 \r
-       void COpenGL3Driver::initQuadsIndices(int max_vertex_count)\r
+       void COpenGL3DriverBase::initQuadsIndices(int max_vertex_count)\r
        {\r
                int max_quad_count = max_vertex_count / 4;\r
                QuadsIndices.reserve(6 * max_quad_count);\r
@@ -196,7 +196,7 @@ COpenGL3Driver::~COpenGL3Driver()
                }\r
        }\r
 \r
-       bool COpenGL3Driver::genericDriverInit(const core::dimension2d<u32>& screenSize, bool stencilBuffer)\r
+       bool COpenGL3DriverBase::genericDriverInit(const core::dimension2d<u32>& screenSize, bool stencilBuffer)\r
        {\r
                Name = glGetString(GL_VERSION);\r
                printVersion();\r
@@ -261,7 +261,7 @@ COpenGL3Driver::~COpenGL3Driver()
                return true;\r
        }\r
 \r
-       void COpenGL3Driver::loadShaderData(const io::path& vertexShaderName, const io::path& fragmentShaderName, c8** vertexShaderData, c8** fragmentShaderData)\r
+       void COpenGL3DriverBase::loadShaderData(const io::path& vertexShaderName, const io::path& fragmentShaderName, c8** vertexShaderData, c8** fragmentShaderData)\r
        {\r
                io::path vsPath(OGLES2ShaderPath);\r
                vsPath += vertexShaderName;\r
@@ -316,7 +316,7 @@ COpenGL3Driver::~COpenGL3Driver()
                fsFile->drop();\r
        }\r
 \r
-       void COpenGL3Driver::createMaterialRenderers()\r
+       void COpenGL3DriverBase::createMaterialRenderers()\r
        {\r
                // Create callbacks.\r
 \r
@@ -469,13 +469,13 @@ COpenGL3Driver::~COpenGL3Driver()
                delete[] fs2DData;\r
        }\r
 \r
-       bool COpenGL3Driver::setMaterialTexture(irr::u32 layerIdx, const irr::video::ITexture* texture)\r
+       bool COpenGL3DriverBase::setMaterialTexture(irr::u32 layerIdx, const irr::video::ITexture* texture)\r
        {\r
                Material.TextureLayer[layerIdx].Texture = const_cast<ITexture*>(texture); // function uses const-pointer for texture because all draw functions use const-pointers already\r
                return CacheHandler->getTextureCache().set(0, texture);\r
        }\r
 \r
-       bool COpenGL3Driver::beginScene(u16 clearFlag, SColor clearColor, f32 clearDepth, u8 clearStencil, const SExposedVideoData& videoData, core::rect<s32>* sourceRect)\r
+       bool COpenGL3DriverBase::beginScene(u16 clearFlag, SColor clearColor, f32 clearDepth, u8 clearStencil, const SExposedVideoData& videoData, core::rect<s32>* sourceRect)\r
        {\r
                CNullDriver::beginScene(clearFlag, clearColor, clearDepth, clearStencil, videoData, sourceRect);\r
 \r
@@ -487,7 +487,7 @@ COpenGL3Driver::~COpenGL3Driver()
                return true;\r
        }\r
 \r
-       bool COpenGL3Driver::endScene()\r
+       bool COpenGL3DriverBase::endScene()\r
        {\r
                CNullDriver::endScene();\r
 \r
@@ -501,21 +501,21 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
 \r
        //! Returns the transformation set by setTransform\r
-       const core::matrix4& COpenGL3Driver::getTransform(E_TRANSFORMATION_STATE state) const\r
+       const core::matrix4& COpenGL3DriverBase::getTransform(E_TRANSFORMATION_STATE state) const\r
        {\r
                return Matrices[state];\r
        }\r
 \r
 \r
        //! sets transformation\r
-       void COpenGL3Driver::setTransform(E_TRANSFORMATION_STATE state, const core::matrix4& mat)\r
+       void COpenGL3DriverBase::setTransform(E_TRANSFORMATION_STATE state, const core::matrix4& mat)\r
        {\r
                Matrices[state] = mat;\r
                Transformation3DChanged = true;\r
        }\r
 \r
 \r
-       bool COpenGL3Driver::updateVertexHardwareBuffer(SHWBufferLink_opengl *HWBuffer)\r
+       bool COpenGL3DriverBase::updateVertexHardwareBuffer(SHWBufferLink_opengl *HWBuffer)\r
        {\r
                if (!HWBuffer)\r
                        return false;\r
@@ -563,7 +563,7 @@ COpenGL3Driver::~COpenGL3Driver()
        }\r
 \r
 \r
-       bool COpenGL3Driver::updateIndexHardwareBuffer(SHWBufferLink_opengl *HWBuffer)\r
+       bool COpenGL3DriverBase::updateIndexHardwareBuffer(SHWBufferLink_opengl *HWBuffer)\r
        {\r
                if (!HWBuffer)\r
                        return false;\r
@@ -627,7 +627,7 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
 \r
        //! updates hardware buffer if needed\r
-       bool COpenGL3Driver::updateHardwareBuffer(SHWBufferLink *HWBuffer)\r
+       bool COpenGL3DriverBase::updateHardwareBuffer(SHWBufferLink *HWBuffer)\r
        {\r
                if (!HWBuffer)\r
                        return false;\r
@@ -663,7 +663,7 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
 \r
        //! Create hardware buffer from meshbuffer\r
-       COpenGL3Driver::SHWBufferLink *COpenGL3Driver::createHardwareBuffer(const scene::IMeshBuffer* mb)\r
+       COpenGL3DriverBase::SHWBufferLink *COpenGL3DriverBase::createHardwareBuffer(const scene::IMeshBuffer* mb)\r
        {\r
                if (!mb || (mb->getHardwareMappingHint_Index() == scene::EHM_NEVER && mb->getHardwareMappingHint_Vertex() == scene::EHM_NEVER))\r
                        return 0;\r
@@ -692,7 +692,7 @@ COpenGL3Driver::~COpenGL3Driver()
        }\r
 \r
 \r
-       void COpenGL3Driver::deleteHardwareBuffer(SHWBufferLink *_HWBuffer)\r
+       void COpenGL3DriverBase::deleteHardwareBuffer(SHWBufferLink *_HWBuffer)\r
        {\r
                if (!_HWBuffer)\r
                        return;\r
@@ -714,7 +714,7 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
 \r
        //! Draw hardware buffer\r
-       void COpenGL3Driver::drawHardwareBuffer(SHWBufferLink *_HWBuffer)\r
+       void COpenGL3DriverBase::drawHardwareBuffer(SHWBufferLink *_HWBuffer)\r
        {\r
                if (!_HWBuffer)\r
                        return;\r
@@ -753,7 +753,7 @@ COpenGL3Driver::~COpenGL3Driver()
        }\r
 \r
 \r
-       IRenderTarget* COpenGL3Driver::addRenderTarget()\r
+       IRenderTarget* COpenGL3DriverBase::addRenderTarget()\r
        {\r
                COpenGL3RenderTarget* renderTarget = new COpenGL3RenderTarget(this);\r
                RenderTargets.push_back(renderTarget);\r
@@ -770,7 +770,7 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
 \r
        //! draws a vertex primitive list\r
-       void COpenGL3Driver::drawVertexPrimitiveList(const void* vertices, u32 vertexCount,\r
+       void COpenGL3DriverBase::drawVertexPrimitiveList(const void* vertices, u32 vertexCount,\r
                        const void* indexList, u32 primitiveCount,\r
                        E_VERTEX_TYPE vType, scene::E_PRIMITIVE_TYPE pType, E_INDEX_TYPE iType)\r
        {\r
@@ -842,7 +842,7 @@ COpenGL3Driver::~COpenGL3Driver()
        }\r
 \r
 \r
-       void COpenGL3Driver::draw2DImage(const video::ITexture* texture, const core::position2d<s32>& destPos,\r
+       void COpenGL3DriverBase::draw2DImage(const video::ITexture* texture, const core::position2d<s32>& destPos,\r
                const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect, SColor color,\r
                bool useAlphaChannelOfTexture)\r
        {\r
@@ -857,7 +857,7 @@ COpenGL3Driver::~COpenGL3Driver()
        }\r
 \r
 \r
-       void COpenGL3Driver::draw2DImage(const video::ITexture* texture, const core::rect<s32>& destRect,\r
+       void COpenGL3DriverBase::draw2DImage(const video::ITexture* texture, const core::rect<s32>& destRect,\r
                const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect,\r
                const video::SColor* const colors, bool useAlphaChannelOfTexture)\r
        {\r
@@ -924,7 +924,7 @@ COpenGL3Driver::~COpenGL3Driver()
                testGLError(__LINE__);\r
        }\r
 \r
-       void COpenGL3Driver::draw2DImage(const video::ITexture* texture, u32 layer, bool flip)\r
+       void COpenGL3DriverBase::draw2DImage(const video::ITexture* texture, u32 layer, bool flip)\r
        {\r
                if (!texture)\r
                        return;\r
@@ -957,7 +957,7 @@ COpenGL3Driver::~COpenGL3Driver()
                drawQuad(vt2DImage, quad2DVertices);\r
        }\r
 \r
-       void COpenGL3Driver::draw2DImageBatch(const video::ITexture* texture,\r
+       void COpenGL3DriverBase::draw2DImageBatch(const video::ITexture* texture,\r
                        const core::array<core::position2d<s32> >& positions,\r
                        const core::array<core::rect<s32> >& sourceRects,\r
                        const core::rect<s32>* clipRect,\r
@@ -1033,7 +1033,7 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
 \r
        //! draw a 2d rectangle\r
-       void COpenGL3Driver::draw2DRectangle(SColor color,\r
+       void COpenGL3DriverBase::draw2DRectangle(SColor color,\r
                        const core::rect<s32>& position,\r
                        const core::rect<s32>* clip)\r
        {\r
@@ -1068,7 +1068,7 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
 \r
        //! draw an 2d rectangle\r
-       void COpenGL3Driver::draw2DRectangle(const core::rect<s32>& position,\r
+       void COpenGL3DriverBase::draw2DRectangle(const core::rect<s32>& position,\r
                        SColor colorLeftUp, SColor colorRightUp,\r
                        SColor colorLeftDown, SColor colorRightDown,\r
                        const core::rect<s32>* clip)\r
@@ -1107,7 +1107,7 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
 \r
        //! Draws a 2d line.\r
-       void COpenGL3Driver::draw2DLine(const core::position2d<s32>& start,\r
+       void COpenGL3DriverBase::draw2DLine(const core::position2d<s32>& start,\r
                        const core::position2d<s32>& end, SColor color)\r
        {\r
                if (start==end)\r
@@ -1136,7 +1136,7 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
 \r
        //! Draws a pixel\r
-       void COpenGL3Driver::drawPixel(u32 x, u32 y, const SColor &color)\r
+       void COpenGL3DriverBase::drawPixel(u32 x, u32 y, const SColor &color)\r
        {\r
                const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();\r
                if (x > (u32)renderTargetSize.Width || y > (u32)renderTargetSize.Height)\r
@@ -1156,26 +1156,26 @@ COpenGL3Driver::~COpenGL3Driver()
                drawArrays(GL_POINTS, vtPrimitive, vertices, 1);\r
        }\r
 \r
-       void COpenGL3Driver::drawQuad(const VertexType &vertexType, const S3DVertex (&vertices)[4])\r
+       void COpenGL3DriverBase::drawQuad(const VertexType &vertexType, const S3DVertex (&vertices)[4])\r
        {\r
                drawArrays(GL_TRIANGLE_FAN, vertexType, vertices, 4);\r
        }\r
 \r
-       void COpenGL3Driver::drawArrays(GLenum primitiveType, const VertexType &vertexType, const void *vertices, int vertexCount)\r
+       void COpenGL3DriverBase::drawArrays(GLenum primitiveType, const VertexType &vertexType, const void *vertices, int vertexCount)\r
        {\r
                beginDraw(vertexType, reinterpret_cast<uintptr_t>(vertices));\r
                glDrawArrays(primitiveType, 0, vertexCount);\r
                endDraw(vertexType);\r
        }\r
 \r
-       void COpenGL3Driver::drawElements(GLenum primitiveType, const VertexType &vertexType, const void *vertices, const u16 *indices, int indexCount)\r
+       void COpenGL3DriverBase::drawElements(GLenum primitiveType, const VertexType &vertexType, const void *vertices, const u16 *indices, int indexCount)\r
        {\r
                beginDraw(vertexType, reinterpret_cast<uintptr_t>(vertices));\r
                glDrawElements(primitiveType, indexCount, GL_UNSIGNED_SHORT, indices);\r
                endDraw(vertexType);\r
        }\r
 \r
-       void COpenGL3Driver::beginDraw(const VertexType &vertexType, uintptr_t verticesBase)\r
+       void COpenGL3DriverBase::beginDraw(const VertexType &vertexType, uintptr_t verticesBase)\r
        {\r
                for (auto attr: vertexType) {\r
                        glEnableVertexAttribArray(attr.Index);\r
@@ -1187,13 +1187,13 @@ COpenGL3Driver::~COpenGL3Driver()
                }\r
        }\r
 \r
-       void COpenGL3Driver::endDraw(const VertexType &vertexType)\r
+       void COpenGL3DriverBase::endDraw(const VertexType &vertexType)\r
        {\r
                for (auto attr: vertexType)\r
                        glDisableVertexAttribArray(attr.Index);\r
        }\r
 \r
-       ITexture* COpenGL3Driver::createDeviceDependentTexture(const io::path& name, IImage* image)\r
+       ITexture* COpenGL3DriverBase::createDeviceDependentTexture(const io::path& name, IImage* image)\r
        {\r
                core::array<IImage*> imageArray(1);\r
                imageArray.push_back(image);\r
@@ -1203,7 +1203,7 @@ COpenGL3Driver::~COpenGL3Driver()
                return texture;\r
        }\r
 \r
-       ITexture* COpenGL3Driver::createDeviceDependentTextureCubemap(const io::path& name, const core::array<IImage*>& image)\r
+       ITexture* COpenGL3DriverBase::createDeviceDependentTextureCubemap(const io::path& name, const core::array<IImage*>& image)\r
        {\r
                COpenGL3Texture* texture = new COpenGL3Texture(name, image, ETT_CUBEMAP, this);\r
 \r
@@ -1211,7 +1211,7 @@ COpenGL3Driver::~COpenGL3Driver()
        }\r
 \r
        //! Sets a material.\r
-       void COpenGL3Driver::setMaterial(const SMaterial& material)\r
+       void COpenGL3DriverBase::setMaterial(const SMaterial& material)\r
        {\r
                Material = material;\r
                OverrideMaterial.apply(Material);\r
@@ -1224,7 +1224,7 @@ COpenGL3Driver::~COpenGL3Driver()
        }\r
 \r
        //! prints error if an error happened.\r
-       bool COpenGL3Driver::testGLError(int code)\r
+       bool COpenGL3DriverBase::testGLError(int code)\r
        {\r
 #ifdef _DEBUG\r
                GLenum g = glGetError();\r
@@ -1252,7 +1252,7 @@ COpenGL3Driver::~COpenGL3Driver()
        }\r
 \r
        //! prints error if an error happened.\r
-       bool COpenGL3Driver::testEGLError()\r
+       bool COpenGL3DriverBase::testEGLError()\r
        {\r
 #if defined(EGL_VERSION_1_0) && defined(_DEBUG)\r
                EGLint g = eglGetError();\r
@@ -1310,7 +1310,7 @@ COpenGL3Driver::~COpenGL3Driver()
        }\r
 \r
 \r
-       void COpenGL3Driver::setRenderStates3DMode()\r
+       void COpenGL3DriverBase::setRenderStates3DMode()\r
        {\r
                if ( LockRenderStateMode )\r
                        return;\r
@@ -1355,7 +1355,7 @@ COpenGL3Driver::~COpenGL3Driver()
        }\r
 \r
        //! Can be called by an IMaterialRenderer to make its work easier.\r
-       void COpenGL3Driver::setBasicRenderStates(const SMaterial& material, const SMaterial& lastmaterial, bool resetAllRenderStates)\r
+       void COpenGL3DriverBase::setBasicRenderStates(const SMaterial& material, const SMaterial& lastmaterial, bool resetAllRenderStates)\r
        {\r
                // ZBuffer\r
                switch (material.ZBuffer)\r
@@ -1493,7 +1493,7 @@ COpenGL3Driver::~COpenGL3Driver()
        }\r
 \r
        //! Compare in SMaterial doesn't check texture parameters, so we should call this on each OnRender call.\r
-       void COpenGL3Driver::setTextureRenderStates(const SMaterial& material, bool resetAllRenderstates)\r
+       void COpenGL3DriverBase::setTextureRenderStates(const SMaterial& material, bool resetAllRenderstates)\r
        {\r
                // Set textures to TU/TIU and apply filters to them\r
 \r
@@ -1579,7 +1579,7 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
 \r
        // Get OpenGL ES2.0 texture wrap mode from Irrlicht wrap mode.\r
-       GLint COpenGL3Driver::getTextureWrapMode(u8 clamp) const\r
+       GLint COpenGL3DriverBase::getTextureWrapMode(u8 clamp) const\r
        {\r
                switch (clamp)\r
                {\r
@@ -1596,7 +1596,7 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
 \r
        //! sets the needed renderstates\r
-       void COpenGL3Driver::setRenderStates2DMode(bool alpha, bool texture, bool alphaChannel)\r
+       void COpenGL3DriverBase::setRenderStates2DMode(bool alpha, bool texture, bool alphaChannel)\r
        {\r
                if ( LockRenderStateMode )\r
                        return;\r
@@ -1652,7 +1652,7 @@ COpenGL3Driver::~COpenGL3Driver()
        }\r
 \r
 \r
-       void COpenGL3Driver::chooseMaterial2D()\r
+       void COpenGL3DriverBase::chooseMaterial2D()\r
        {\r
                if (!OverrideMaterial2DEnabled)\r
                        Material = InitMaterial2D;\r
@@ -1670,12 +1670,12 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
 \r
        //! \return Returns the name of the video driver.\r
-       const wchar_t* COpenGL3Driver::getName() const\r
+       const wchar_t* COpenGL3DriverBase::getName() const\r
        {\r
                return Name.c_str();\r
        }\r
 \r
-       void COpenGL3Driver::setViewPort(const core::rect<s32>& area)\r
+       void COpenGL3DriverBase::setViewPort(const core::rect<s32>& area)\r
        {\r
                core::rect<s32> vp = area;\r
                core::rect<s32> rendert(0, 0, getCurrentRenderTargetSize().Width, getCurrentRenderTargetSize().Height);\r
@@ -1688,7 +1688,7 @@ COpenGL3Driver::~COpenGL3Driver()
        }\r
 \r
 \r
-       void COpenGL3Driver::setViewPortRaw(u32 width, u32 height)\r
+       void COpenGL3DriverBase::setViewPortRaw(u32 width, u32 height)\r
        {\r
                CacheHandler->setViewport(0, 0, width, height);\r
                ViewPort = core::recti(0, 0, width, height);\r
@@ -1696,7 +1696,7 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
 \r
        //! Draws a 3d line.\r
-       void COpenGL3Driver::draw3DLine(const core::vector3df& start,\r
+       void COpenGL3DriverBase::draw3DLine(const core::vector3df& start,\r
                        const core::vector3df& end, SColor color)\r
        {\r
                setRenderStates3DMode();\r
@@ -1711,7 +1711,7 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
        //! Only used by the internal engine. Used to notify the driver that\r
        //! the window was resized.\r
-       void COpenGL3Driver::OnResize(const core::dimension2d<u32>& size)\r
+       void COpenGL3DriverBase::OnResize(const core::dimension2d<u32>& size)\r
        {\r
                CNullDriver::OnResize(size);\r
                CacheHandler->setViewport(0, 0, size.Width, size.Height);\r
@@ -1720,79 +1720,79 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
 \r
        //! Returns type of video driver\r
-       E_DRIVER_TYPE COpenGL3Driver::getDriverType() const\r
+       E_DRIVER_TYPE COpenGL3DriverBase::getDriverType() const\r
        {\r
                return EDT_OPENGL3;\r
        }\r
 \r
 \r
        //! returns color format\r
-       ECOLOR_FORMAT COpenGL3Driver::getColorFormat() const\r
+       ECOLOR_FORMAT COpenGL3DriverBase::getColorFormat() const\r
        {\r
                return ColorFormat;\r
        }\r
 \r
 \r
        //! Get a vertex shader constant index.\r
-       s32 COpenGL3Driver::getVertexShaderConstantID(const c8* name)\r
+       s32 COpenGL3DriverBase::getVertexShaderConstantID(const c8* name)\r
        {\r
                return getPixelShaderConstantID(name);\r
        }\r
 \r
        //! Get a pixel shader constant index.\r
-       s32 COpenGL3Driver::getPixelShaderConstantID(const c8* name)\r
+       s32 COpenGL3DriverBase::getPixelShaderConstantID(const c8* name)\r
        {\r
                os::Printer::log("Error: Please call services->getPixelShaderConstantID(), not VideoDriver->getPixelShaderConstantID().");\r
                return -1;\r
        }\r
 \r
        //! Sets a vertex shader constant.\r
-       void COpenGL3Driver::setVertexShaderConstant(const f32* data, s32 startRegister, s32 constantAmount)\r
+       void COpenGL3DriverBase::setVertexShaderConstant(const f32* data, s32 startRegister, s32 constantAmount)\r
        {\r
                os::Printer::log("Error: Please call services->setVertexShaderConstant(), not VideoDriver->setPixelShaderConstant().");\r
        }\r
 \r
        //! Sets a pixel shader constant.\r
-       void COpenGL3Driver::setPixelShaderConstant(const f32* data, s32 startRegister, s32 constantAmount)\r
+       void COpenGL3DriverBase::setPixelShaderConstant(const f32* data, s32 startRegister, s32 constantAmount)\r
        {\r
                os::Printer::log("Error: Please call services->setPixelShaderConstant(), not VideoDriver->setPixelShaderConstant().");\r
        }\r
 \r
        //! Sets a constant for the vertex shader based on an index.\r
-       bool COpenGL3Driver::setVertexShaderConstant(s32 index, const f32* floats, int count)\r
+       bool COpenGL3DriverBase::setVertexShaderConstant(s32 index, const f32* floats, int count)\r
        {\r
                os::Printer::log("Error: Please call services->setVertexShaderConstant(), not VideoDriver->setVertexShaderConstant().");\r
                return false;\r
        }\r
 \r
        //! Int interface for the above.\r
-       bool COpenGL3Driver::setVertexShaderConstant(s32 index, const s32* ints, int count)\r
+       bool COpenGL3DriverBase::setVertexShaderConstant(s32 index, const s32* ints, int count)\r
        {\r
                os::Printer::log("Error: Please call services->setVertexShaderConstant(), not VideoDriver->setVertexShaderConstant().");\r
                return false;\r
        }\r
 \r
-       bool COpenGL3Driver::setVertexShaderConstant(s32 index, const u32* ints, int count)\r
+       bool COpenGL3DriverBase::setVertexShaderConstant(s32 index, const u32* ints, int count)\r
        {\r
                os::Printer::log("Error: Please call services->setVertexShaderConstant(), not VideoDriver->setVertexShaderConstant().");\r
                return false;\r
        }\r
 \r
        //! Sets a constant for the pixel shader based on an index.\r
-       bool COpenGL3Driver::setPixelShaderConstant(s32 index, const f32* floats, int count)\r
+       bool COpenGL3DriverBase::setPixelShaderConstant(s32 index, const f32* floats, int count)\r
        {\r
                os::Printer::log("Error: Please call services->setPixelShaderConstant(), not VideoDriver->setPixelShaderConstant().");\r
                return false;\r
        }\r
 \r
        //! Int interface for the above.\r
-       bool COpenGL3Driver::setPixelShaderConstant(s32 index, const s32* ints, int count)\r
+       bool COpenGL3DriverBase::setPixelShaderConstant(s32 index, const s32* ints, int count)\r
        {\r
                os::Printer::log("Error: Please call services->setPixelShaderConstant(), not VideoDriver->setPixelShaderConstant().");\r
                return false;\r
        }\r
 \r
-       bool COpenGL3Driver::setPixelShaderConstant(s32 index, const u32* ints, int count)\r
+       bool COpenGL3DriverBase::setPixelShaderConstant(s32 index, const u32* ints, int count)\r
        {\r
                os::Printer::log("Error: Please call services->setPixelShaderConstant(), not VideoDriver->setPixelShaderConstant().");\r
                return false;\r
@@ -1800,7 +1800,7 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
        //! Adds a new material renderer to the VideoDriver, using pixel and/or\r
        //! vertex shaders to render geometry.\r
-       s32 COpenGL3Driver::addShaderMaterial(const c8* vertexShaderProgram,\r
+       s32 COpenGL3DriverBase::addShaderMaterial(const c8* vertexShaderProgram,\r
                        const c8* pixelShaderProgram,\r
                        IShaderConstantSetCallBack* callback,\r
                        E_MATERIAL_TYPE baseMaterial, s32 userData)\r
@@ -1811,7 +1811,7 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
 \r
        //! Adds a new material renderer to the VideoDriver, using GLSL to render geometry.\r
-       s32 COpenGL3Driver::addHighLevelShaderMaterial(\r
+       s32 COpenGL3DriverBase::addHighLevelShaderMaterial(\r
                        const c8* vertexShaderProgram,\r
                        const c8* vertexShaderEntryPointName,\r
                        E_VERTEX_SHADER_TYPE vsCompileTarget,\r
@@ -1840,19 +1840,19 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
        //! Returns a pointer to the IVideoDriver interface. (Implementation for\r
        //! IMaterialRendererServices)\r
-       IVideoDriver* COpenGL3Driver::getVideoDriver()\r
+       IVideoDriver* COpenGL3DriverBase::getVideoDriver()\r
        {\r
                return this;\r
        }\r
 \r
 \r
        //! Returns pointer to the IGPUProgrammingServices interface.\r
-       IGPUProgrammingServices* COpenGL3Driver::getGPUProgrammingServices()\r
+       IGPUProgrammingServices* COpenGL3DriverBase::getGPUProgrammingServices()\r
        {\r
                return this;\r
        }\r
 \r
-       ITexture* COpenGL3Driver::addRenderTargetTexture(const core::dimension2d<u32>& size,\r
+       ITexture* COpenGL3DriverBase::addRenderTargetTexture(const core::dimension2d<u32>& size,\r
                const io::path& name, const ECOLOR_FORMAT format)\r
        {\r
                //disable mip-mapping\r
@@ -1869,7 +1869,7 @@ COpenGL3Driver::~COpenGL3Driver()
                return renderTargetTexture;\r
        }\r
 \r
-       ITexture* COpenGL3Driver::addRenderTargetTextureCubemap(const irr::u32 sideLen, const io::path& name, const ECOLOR_FORMAT format)\r
+       ITexture* COpenGL3DriverBase::addRenderTargetTextureCubemap(const irr::u32 sideLen, const io::path& name, const ECOLOR_FORMAT format)\r
        {\r
                //disable mip-mapping\r
                bool generateMipLevels = getTextureCreationFlag(ETCF_CREATE_MIP_MAPS);\r
@@ -1898,14 +1898,14 @@ COpenGL3Driver::~COpenGL3Driver()
 \r
 \r
        //! Returns the maximum amount of primitives\r
-       u32 COpenGL3Driver::getMaximalPrimitiveCount() const\r
+       u32 COpenGL3DriverBase::getMaximalPrimitiveCount() const\r
        {\r
                return 65535;\r
        }\r
 \r
-       bool COpenGL3Driver::setRenderTargetEx(IRenderTarget* target, u16 clearFlag, SColor clearColor, f32 clearDepth, u8 clearStencil)\r
+       bool COpenGL3DriverBase::setRenderTargetEx(IRenderTarget* target, u16 clearFlag, SColor clearColor, f32 clearDepth, u8 clearStencil)\r
        {\r
-               if (target && target->getDriverType() != EDT_OPENGL3)\r
+               if (target && target->getDriverType() != getDriverType())\r
                {\r
                        os::Printer::log("Fatal Error: Tried to set a render target not owned by OpenGL 3 driver.", ELL_ERROR);\r
                        return false;\r
@@ -1947,7 +1947,7 @@ COpenGL3Driver::~COpenGL3Driver()
                return true;\r
        }\r
 \r
-       void COpenGL3Driver::clearBuffers(u16 flag, SColor color, f32 depth, u8 stencil)\r
+       void COpenGL3DriverBase::clearBuffers(u16 flag, SColor color, f32 depth, u8 stencil)\r
        {\r
                GLbitfield mask = 0;\r
                u8 colorMask = 0;\r
@@ -1992,7 +1992,7 @@ COpenGL3Driver::~COpenGL3Driver()
        // We want to read the front buffer to get the latest render finished.\r
        // This is not possible under ogl-es, though, so one has to call this method\r
        // outside of the render loop only.\r
-       IImage* COpenGL3Driver::createScreenShot(video::ECOLOR_FORMAT format, video::E_RENDER_TARGET target)\r
+       IImage* COpenGL3DriverBase::createScreenShot(video::ECOLOR_FORMAT format, video::E_RENDER_TARGET target)\r
        {\r
                if (target==video::ERT_MULTI_RENDER_TEXTURES || target==video::ERT_RENDER_TEXTURE || target==video::ERT_STEREO_BOTH_BUFFERS)\r
                        return 0;\r
@@ -2078,14 +2078,14 @@ COpenGL3Driver::~COpenGL3Driver()
                return newImage;\r
        }\r
 \r
-       void COpenGL3Driver::removeTexture(ITexture* texture)\r
+       void COpenGL3DriverBase::removeTexture(ITexture* texture)\r
        {\r
                CacheHandler->getTextureCache().remove(texture);\r
                CNullDriver::removeTexture(texture);\r
        }\r
 \r
        //! Set/unset a clipping plane.\r
-       bool COpenGL3Driver::setClipPlane(u32 index, const core::plane3df& plane, bool enable)\r
+       bool COpenGL3DriverBase::setClipPlane(u32 index, const core::plane3df& plane, bool enable)\r
        {\r
                if (index >= UserClipPlane.size())\r
                        UserClipPlane.push_back(SUserClipPlane());\r
@@ -2096,18 +2096,18 @@ COpenGL3Driver::~COpenGL3Driver()
        }\r
 \r
        //! Enable/disable a clipping plane.\r
-       void COpenGL3Driver::enableClipPlane(u32 index, bool enable)\r
+       void COpenGL3DriverBase::enableClipPlane(u32 index, bool enable)\r
        {\r
                UserClipPlane[index].Enabled = enable;\r
        }\r
 \r
        //! Get the ClipPlane Count\r
-       u32 COpenGL3Driver::getClipPlaneCount() const\r
+       u32 COpenGL3DriverBase::getClipPlaneCount() const\r
        {\r
                return UserClipPlane.size();\r
        }\r
 \r
-       const core::plane3df& COpenGL3Driver::getClipPlane(irr::u32 index) const\r
+       const core::plane3df& COpenGL3DriverBase::getClipPlane(irr::u32 index) const\r
        {\r
                if (index < UserClipPlane.size())\r
                        return UserClipPlane[index].Plane;\r
@@ -2119,12 +2119,12 @@ COpenGL3Driver::~COpenGL3Driver()
                }\r
        }\r
 \r
-       core::dimension2du COpenGL3Driver::getMaxTextureSize() const\r
+       core::dimension2du COpenGL3DriverBase::getMaxTextureSize() const\r
        {\r
                return core::dimension2du(MaxTextureSize, MaxTextureSize);\r
        }\r
 \r
-       GLenum COpenGL3Driver::getGLBlend(E_BLEND_FACTOR factor) const\r
+       GLenum COpenGL3DriverBase::getGLBlend(E_BLEND_FACTOR factor) const\r
        {\r
                static GLenum const blendTable[] =\r
                {\r
@@ -2144,7 +2144,7 @@ COpenGL3Driver::~COpenGL3Driver()
                return blendTable[factor];\r
        }\r
 \r
-       bool COpenGL3Driver::getColorFormatParameters(ECOLOR_FORMAT format, GLint& internalFormat, GLenum& pixelFormat,\r
+       bool COpenGL3DriverBase::getColorFormatParameters(ECOLOR_FORMAT format, GLint& internalFormat, GLenum& pixelFormat,\r
                GLenum& pixelType, void(**converter)(const void*, s32, void*)) const\r
        {\r
                bool supported = false;\r
@@ -2360,7 +2360,7 @@ COpenGL3Driver::~COpenGL3Driver()
                return supported;\r
        }\r
 \r
-       bool COpenGL3Driver::queryTextureFormat(ECOLOR_FORMAT format) const\r
+       bool COpenGL3DriverBase::queryTextureFormat(ECOLOR_FORMAT format) const\r
        {\r
                GLint dummyInternalFormat;\r
                GLenum dummyPixelFormat;\r
@@ -2369,28 +2369,20 @@ COpenGL3Driver::~COpenGL3Driver()
                return getColorFormatParameters(format, dummyInternalFormat, dummyPixelFormat, dummyPixelType, &dummyConverter);\r
        }\r
 \r
-       bool COpenGL3Driver::needsTransparentRenderPass(const irr::video::SMaterial& material) const\r
+       bool COpenGL3DriverBase::needsTransparentRenderPass(const irr::video::SMaterial& material) const\r
        {\r
                return CNullDriver::needsTransparentRenderPass(material) || material.isAlphaBlendOperation();\r
        }\r
 \r
-       const SMaterial& COpenGL3Driver::getCurrentMaterial() const\r
+       const SMaterial& COpenGL3DriverBase::getCurrentMaterial() const\r
        {\r
                return Material;\r
        }\r
 \r
-       COpenGL3CacheHandler* COpenGL3Driver::getCacheHandler() const\r
+       COpenGL3CacheHandler* COpenGL3DriverBase::getCacheHandler() const\r
        {\r
                return CacheHandler;\r
        }\r
 \r
-\r
-IVideoDriver* createOpenGL3Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager)\r
-{\r
-       COpenGL3Driver* driver = new COpenGL3Driver(params, io, contextManager);\r
-       driver->genericDriverInit(params.WindowSize, params.Stencilbuffer);     // don't call in constructor, it uses virtual function calls of driver\r
-       return driver;\r
-}\r
-\r
 } // end namespace\r
 } // end namespace\r

diff --git a/source/Irrlicht/OpenGL/Driver.h b/source/Irrlicht/OpenGL/Driver.h
index 6cbf7bd2dcbc418d4c6779985a22b322d1d40cc0..e95a633c546f408402a0d87f17be370e57adc157 100644 (file)
--- a/source/Irrlicht/OpenGL/Driver.h
+++ b/source/Irrlicht/OpenGL/Driver.h
@@ -25,19 +25,18 @@ namespace video
        class COpenGL3FixedPipelineRenderer;\r
        class COpenGL3Renderer2D;\r
 \r
-       class COpenGL3Driver : public CNullDriver, public IMaterialRendererServices, public COpenGL3ExtensionHandler\r
+       class COpenGL3DriverBase : public CNullDriver, public IMaterialRendererServices, public COpenGL3ExtensionHandler\r
        {\r
-               friend class COpenGLCoreTexture<COpenGL3Driver>;\r
-               friend IVideoDriver* createOpenGL3Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager);\r
+               friend class COpenGLCoreTexture<COpenGL3DriverBase>;\r
 \r
        protected:\r
                //! constructor (use createOpenGL3Driver instead)\r
-               COpenGL3Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager);\r
+               COpenGL3DriverBase(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager);\r
 \r
        public:\r
 \r
                //! destructor\r
-               virtual ~COpenGL3Driver();\r
+               virtual ~COpenGL3DriverBase();\r
 \r
                virtual bool beginScene(u16 clearFlag, SColor clearColor = SColor(255, 0, 0, 0), f32 clearDepth = 1.f, u8 clearStencil = 0,\r
                        const SExposedVideoData& videoData = SExposedVideoData(), core::rect<s32>* sourceRect = 0) override;\r

diff --git a/source/Irrlicht/OpenGL/MaterialRenderer.cpp b/source/Irrlicht/OpenGL/MaterialRenderer.cpp
index 080835c93dc665e340736f0cac22ee9232599e12..20d684c870845a12ff4aaac4f4dd12b0305903d7 100644 (file)
--- a/source/Irrlicht/OpenGL/MaterialRenderer.cpp
+++ b/source/Irrlicht/OpenGL/MaterialRenderer.cpp
@@ -21,7 +21,7 @@ namespace video
 {\r
 \r
 \r
-COpenGL3MaterialRenderer::COpenGL3MaterialRenderer(COpenGL3Driver* driver,\r
+COpenGL3MaterialRenderer::COpenGL3MaterialRenderer(COpenGL3DriverBase* driver,\r
                s32& outMaterialTypeNr,\r
                const c8* vertexShaderProgram,\r
                const c8* pixelShaderProgram,\r
@@ -57,7 +57,7 @@ COpenGL3MaterialRenderer::COpenGL3MaterialRenderer(COpenGL3Driver* driver,
 }\r
 \r
 \r
-COpenGL3MaterialRenderer::COpenGL3MaterialRenderer(COpenGL3Driver* driver,\r
+COpenGL3MaterialRenderer::COpenGL3MaterialRenderer(COpenGL3DriverBase* driver,\r
                                        IShaderConstantSetCallBack* callback,\r
                                        E_MATERIAL_TYPE baseMaterial, s32 userData)\r
 : Driver(driver), CallBack(callback), Alpha(false), Blending(false), FixedBlending(false), Program(0), UserData(userData)\r

diff --git a/source/Irrlicht/OpenGL/MaterialRenderer.h b/source/Irrlicht/OpenGL/MaterialRenderer.h
index f45e72549f5aa2168a651ba59f09f751b7fb6ee8..dbac6cf6bfbe1016e8ea23dd4203bb1e98ce5e29 100644 (file)
--- a/source/Irrlicht/OpenGL/MaterialRenderer.h
+++ b/source/Irrlicht/OpenGL/MaterialRenderer.h
@@ -18,14 +18,14 @@ namespace irr
 namespace video\r
 {\r
 \r
-class COpenGL3Driver;\r
+class COpenGL3DriverBase;\r
 \r
 class COpenGL3MaterialRenderer : public IMaterialRenderer, public IMaterialRendererServices\r
 {\r
 public:\r
 \r
        COpenGL3MaterialRenderer(\r
-               COpenGL3Driver* driver,\r
+               COpenGL3DriverBase* driver,\r
                s32& outMaterialTypeNr,\r
                const c8* vertexShaderProgram = 0,\r
                const c8* pixelShaderProgram = 0,\r
@@ -65,7 +65,7 @@ public:
 \r
 protected:\r
 \r
-       COpenGL3MaterialRenderer(COpenGL3Driver* driver,\r
+       COpenGL3MaterialRenderer(COpenGL3DriverBase* driver,\r
                                        IShaderConstantSetCallBack* callback = 0,\r
                                        E_MATERIAL_TYPE baseMaterial = EMT_SOLID,\r
                                        s32 userData = 0);\r
@@ -75,7 +75,7 @@ protected:
        bool createShader(GLenum shaderType, const char* shader);\r
        bool linkProgram();\r
 \r
-       COpenGL3Driver* Driver;\r
+       COpenGL3DriverBase* Driver;\r
        IShaderConstantSetCallBack* CallBack;\r
 \r
        bool Alpha;\r

diff --git a/source/Irrlicht/OpenGL/Renderer2D.cpp b/source/Irrlicht/OpenGL/Renderer2D.cpp
index d0a2c0ae81588e825cd97e2964448fd6fecbe394..8bedb17925604c3de10493d4af4e85e20d47652d 100644 (file)
--- a/source/Irrlicht/OpenGL/Renderer2D.cpp
+++ b/source/Irrlicht/OpenGL/Renderer2D.cpp
@@ -18,7 +18,7 @@ namespace irr
 namespace video\r
 {\r
 \r
-COpenGL3Renderer2D::COpenGL3Renderer2D(const c8* vertexShaderProgram, const c8* pixelShaderProgram, COpenGL3Driver* driver, bool withTexture) :\r
+COpenGL3Renderer2D::COpenGL3Renderer2D(const c8* vertexShaderProgram, const c8* pixelShaderProgram, COpenGL3DriverBase* driver, bool withTexture) :\r
        COpenGL3MaterialRenderer(driver, 0, EMT_SOLID),\r
        WithTexture(withTexture)\r
 {\r

diff --git a/source/Irrlicht/OpenGL/Renderer2D.h b/source/Irrlicht/OpenGL/Renderer2D.h
index 8df192b465780216a991f55fb59939d719d51e2c..806d1e7cd28682806743cc3d7cc019fd1a56c969 100644 (file)
--- a/source/Irrlicht/OpenGL/Renderer2D.h
+++ b/source/Irrlicht/OpenGL/Renderer2D.h
@@ -14,7 +14,7 @@ namespace video
 class COpenGL3Renderer2D : public COpenGL3MaterialRenderer\r
 {\r
 public:\r
-       COpenGL3Renderer2D(const c8* vertexShaderProgram, const c8* pixelShaderProgram, COpenGL3Driver* driver, bool withTexture);\r
+       COpenGL3Renderer2D(const c8* vertexShaderProgram, const c8* pixelShaderProgram, COpenGL3DriverBase* driver, bool withTexture);\r
        ~COpenGL3Renderer2D();\r
 \r
        virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,\r

diff --git a/source/Irrlicht/OpenGL3/Driver.cpp b/source/Irrlicht/OpenGL3/Driver.cpp
new file mode 100644 (file)
index 0000000..925c6ea
--- /dev/null
+++ b/source/Irrlicht/OpenGL3/Driver.cpp
@@ -0,0 +1,22 @@
+// Copyright (C) 2023 Vitaliy Lobachevskiy
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in Irrlicht.h
+
+#include "Driver.h"
+
+namespace irr {
+namespace video {
+
+       E_DRIVER_TYPE COpenGL3Driver::getDriverType() const {
+               return EDT_OPENGL3;
+       }
+
+       IVideoDriver* createOpenGL3Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager)
+       {
+               COpenGL3Driver* driver = new COpenGL3Driver(params, io, contextManager);
+               driver->genericDriverInit(params.WindowSize, params.Stencilbuffer);     // don't call in constructor, it uses virtual function calls of driver
+               return driver;
+       }
+
+}
+}

diff --git a/source/Irrlicht/OpenGL3/Driver.h b/source/Irrlicht/OpenGL3/Driver.h
new file mode 100644 (file)
index 0000000..cb30432
--- /dev/null
+++ b/source/Irrlicht/OpenGL3/Driver.h
@@ -0,0 +1,19 @@
+// Copyright (C) 2023 Vitaliy Lobachevskiy
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in Irrlicht.h
+
+#pragma once
+#include "OpenGL/Driver.h"
+
+namespace irr {
+namespace video {
+
+       class COpenGL3Driver : public COpenGL3DriverBase {
+               friend IVideoDriver* createOpenGL3Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager);
+       public:
+               using COpenGL3DriverBase::COpenGL3DriverBase;
+               E_DRIVER_TYPE getDriverType() const override;
+       };
+
+}
+}

diff --git a/source/Irrlicht/OpenGLES2/Driver.cpp b/source/Irrlicht/OpenGLES2/Driver.cpp
new file mode 100644 (file)
index 0000000..2b03464
--- /dev/null
+++ b/source/Irrlicht/OpenGLES2/Driver.cpp
@@ -0,0 +1,22 @@
+// Copyright (C) 2023 Vitaliy Lobachevskiy
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in Irrlicht.h
+
+#include "Driver.h"
+
+namespace irr {
+namespace video {
+
+       E_DRIVER_TYPE COpenGLES2Driver::getDriverType() const {
+               return EDT_OGLES2;
+       }
+
+       IVideoDriver* createOGLES2Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager)
+       {
+               COpenGLES2Driver* driver = new COpenGLES2Driver(params, io, contextManager);
+               driver->genericDriverInit(params.WindowSize, params.Stencilbuffer);     // don't call in constructor, it uses virtual function calls of driver
+               return driver;
+       }
+
+}
+}

diff --git a/source/Irrlicht/OpenGLES2/Driver.h b/source/Irrlicht/OpenGLES2/Driver.h
new file mode 100644 (file)
index 0000000..cdfb2fe
--- /dev/null
+++ b/source/Irrlicht/OpenGLES2/Driver.h
@@ -0,0 +1,19 @@
+// Copyright (C) 2023 Vitaliy Lobachevskiy
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in Irrlicht.h
+
+#pragma once
+#include "OpenGL/Driver.h"
+
+namespace irr {
+namespace video {
+
+       class COpenGLES2Driver : public COpenGL3DriverBase {
+               friend IVideoDriver* createOGLES2Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager);
+       public:
+               using COpenGL3DriverBase::COpenGL3DriverBase;
+               E_DRIVER_TYPE getDriverType() const override;
+       };
+
+}
+}