48 files changed, 5686 insertions, 455 deletions
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 41dc3d6..2cf7d60 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -83,6 +83,60 @@ jobs:
           cd bin/Linux
           ./AutomatedTest null
 
+  linux-sdl-gl3:
+    runs-on: ubuntu-latest
+    container:
+      image: ubuntu:jammy
+      env: { LANG: "C.UTF-8" }
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install deps
+        run: |
+          apt-get update
+          apt-get install g++ cmake libsdl2-dev libpng-dev libjpeg-dev zlib1g-dev xvfb -qyy
+
+      - name: Build
+        run: |
+          cmake . -DBUILD_EXAMPLES=1 -DUSE_SDL2=ON -DENABLE_OPENGL3=ON
+          make -j2
+
+      - name: Test (headless)
+        run: |
+          cd bin/Linux
+          ./AutomatedTest null
+
+      - name: Test (Xvfb)
+        run: |
+          cd bin/Linux
+          LIBGL_ALWAYS_SOFTWARE=true xvfb-run ./AutomatedTest opengl3
+
+  linux-sdl-gles2:
+    runs-on: ubuntu-latest
+    container:
+      image: ubuntu:jammy
+      env: { LANG: "C.UTF-8" }
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install deps
+        run: |
+          apt-get update
+          apt-get install g++ cmake libsdl2-dev libpng-dev libjpeg-dev zlib1g-dev xvfb -qyy
+
+      - name: Build
+        run: |
+          cmake . -DBUILD_EXAMPLES=1 -DUSE_SDL2=ON -DENABLE_GLES2=ON
+          make -j2
+
+      - name: Test (headless)
+        run: |
+          cd bin/Linux
+          ./AutomatedTest null
+
+      - name: Test (Xvfb)
+        run: |
+          cd bin/Linux
+          LIBGL_ALWAYS_SOFTWARE=true xvfb-run ./AutomatedTest gles2
+
   win32:
     runs-on: ubuntu-20.04
     steps:
diff --git a/examples/AutomatedTest/main.cpp b/examples/AutomatedTest/main.cpp
index 5df7a29..96cbc73 100644
--- a/examples/AutomatedTest/main.cpp
+++ b/examples/AutomatedTest/main.cpp
@@ -20,6 +20,8 @@ static video::E_DRIVER_TYPE chooseDriver(core::stringc arg_)
 		return video::EDT_OGLES2;
 	if (arg_ == "opengl")
 		return video::EDT_OPENGL;
+	if (arg_ == "opengl3")
+		return video::EDT_OPENGL3;
 	std::cerr << "Unknown driver type: " << arg_.c_str() << ". Trying OpenGL." << std::endl;
 	return video::EDT_OPENGL;
 }
diff --git a/include/EDriverTypes.h b/include/EDriverTypes.h
index f5a2e92..71cea54 100644
--- a/include/EDriverTypes.h
+++ b/include/EDriverTypes.h
@@ -20,31 +20,11 @@ namespace video
 		render and display any graphics. */
 		EDT_NULL,
 
-		//! The Irrlicht Engine Software renderer.
-		/** Runs on all platforms, with every hardware. It should only
-		be used for 2d graphics, but it can also perform some primitive
-		3d functions. These 3d drawing functions are quite fast, but
-		very inaccurate, and don't even support clipping in 3D mode. */
+		// obsolete constants to make some code happy
+		// TODO delete
 		EDT_SOFTWARE,
-
-		//! The Burning's Software Renderer, an alternative software renderer
-		/** Basically it can be described as the Irrlicht Software
-		renderer on steroids. It rasterizes 3D geometry perfectly: It
-		is able to perform correct 3d clipping, perspective correct
-		texture mapping, perspective correct color mapping, and renders
-		sub pixel correct, sub texel correct primitives. In addition,
-		it does bilinear texel filtering and supports more materials
-		than the EDT_SOFTWARE driver. This renderer has been written
-		entirely by Thomas Alten, thanks a lot for this huge
-		contribution. */
 		EDT_BURNINGSVIDEO,
-
-		//! Direct3D8 device is longer supported in Irrlicht. You have to go back to Irrlicht 1.8 if you still need that.
-		DEPRECATED_EDT_DIRECT3D8_NO_LONGER_EXISTS, // keep enum to avoid breaking enumeration order (might be used in ini-files, serialization, etc)
-
-		//! Direct3D 9 device, only available on Win32 platforms.
-		/** Performs hardware accelerated rendering of 3D and 2D
-		primitives. */
+		DEPRECATED_EDT_DIRECT3D8_NO_LONGER_EXISTS,
 		EDT_DIRECT3D9,
 
 		//! OpenGL device, available on most platforms.
@@ -52,7 +32,7 @@ namespace video
 		primitives. */
 		EDT_OPENGL,
 
-        //! OpenGL-ES 1.x driver, for embedded and mobile systems
+		//! OpenGL-ES 1.x driver, for embedded and mobile systems
 		EDT_OGLES1,
 
 		//! OpenGL-ES 2.x driver, for embedded and mobile systems
@@ -62,38 +42,12 @@ namespace video
 		//! WebGL1 friendly subset of OpenGL-ES 2.x driver for Emscripten
 		EDT_WEBGL1,
 
+		EDT_OPENGL3,
+
 		//! No driver, just for counting the elements
 		EDT_COUNT
 	};
 
-	const c8* const DRIVER_TYPE_NAMES[] =
-	{
-		"NullDriver",
-		"Software Renderer",
-		"Burning's Video",
-		"Direct3D 8.1",
-		"Direct3D 9.0c",
-		"OpenGL 1.x/2.x/3.x",
-		"OpenGL ES1",
-		"OpenGL ES2",
-		"WebGL 1",
-		0
-	};
-
-	const c8* const DRIVER_TYPE_NAMES_SHORT[] =
-	{
-		"null",
-		"software",
-		"burning",
-		"d3d8",
-		"d3d9",
-		"opengl",
-		"ogles1",
-		"ogles2",
-		"webgl1",
-		0
-	};
-
 } // end namespace video
 } // end namespace irr
 
diff --git a/include/IVideoDriver.h b/include/IVideoDriver.h
index 2fcb0ab..f93d761 100644
--- a/include/IVideoDriver.h
+++ b/include/IVideoDriver.h
@@ -717,23 +717,6 @@ namespace video
 		virtual void draw3DLine(const core::vector3df& start,
 			const core::vector3df& end, SColor color = SColor(255,255,255,255)) =0;
 
-		//! Draws a 3d triangle.
-		/** This method calls drawVertexPrimitiveList for some triangles.
-		This method works with all drivers because it simply calls
-		drawVertexPrimitiveList, but it is hence not very fast.
-		Note that the triangle is drawn using the current
-		transformation matrix and material. So if you need to draw it
-		independently of the current transformation, use
-		\code
-		driver->setMaterial(someMaterial);
-		driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
-		\endcode
-		for some properly set up material before drawing the triangle.
-		\param triangle The triangle to draw.
-		\param color Color of the line. */
-		virtual void draw3DTriangle(const core::triangle3df& triangle,
-			SColor color = SColor(255,255,255,255)) =0;
-
 		//! Draws a 3d axis aligned box.
 		/** This method simply calls draw3DLine for the edges of the
 		box. Note that the box is drawn using the current transformation
@@ -779,35 +762,6 @@ namespace video
 			SColor color=SColor(255,255,255,255), bool useAlphaChannelOfTexture=false) =0;
 
 		//! Draws a set of 2d images, using a color and the alpha channel of the texture.
-		/** The images are drawn beginning at pos and concatenated in
-		one line. All drawings are clipped against clipRect (if != 0).
-		The subtextures are defined by the array of sourceRects and are
-		chosen by the indices given.
-		\param texture Texture to be drawn.
-		\param pos Upper left 2d destination position where the image
-		will be drawn.
-		\param sourceRects Source rectangles of the texture (based on it's OriginalSize)
-		\param indices List of indices which choose the actual
-		rectangle used each time.
-		\param kerningWidth Offset to Position on X
-		\param clipRect Pointer to rectangle on the screen where the
-		image is clipped to.
-		If this pointer is 0 then the image is not clipped.
-		\param color Color with which the image is drawn.
-		Note that the alpha component is used. If alpha is other than
-		255, the image will be transparent.
-		\param useAlphaChannelOfTexture: If true, the alpha channel of
-		the texture is used to draw the image. */
-		virtual void draw2DImageBatch(const video::ITexture* texture,
-				const core::position2d<s32>& pos,
-				const core::array<core::rect<s32> >& sourceRects,
-				const core::array<s32>& indices,
-				s32 kerningWidth=0,
-				const core::rect<s32>* clipRect=0,
-				SColor color=SColor(255,255,255,255),
-				bool useAlphaChannelOfTexture=false) =0;
-
-		//! Draws a set of 2d images, using a color and the alpha channel of the texture.
 		/** All drawings are clipped against clipRect (if != 0).
 		The subtextures are defined by the array of sourceRects and are
 		positioned using the array of positions.
@@ -877,13 +831,6 @@ namespace video
 				SColor colorLeftDown, SColor colorRightDown,
 				const core::rect<s32>* clip =0) =0;
 
-		//! Draws the outline of a 2D rectangle.
-		/** \param pos Position of the rectangle.
-		\param color Color of the rectangle to draw. The alpha component
-		specifies how transparent the rectangle outline will be. */
-		virtual void draw2DRectangleOutline(const core::recti& pos,
-				SColor color=SColor(255,255,255,255)) =0;
-
 		//! Draws a 2d line.
 		/** In theory both start and end will be included in coloring.
 		BUG: Currently d3d ignores the last pixel
@@ -897,72 +844,6 @@ namespace video
 					const core::position2d<s32>& end,
 					SColor color=SColor(255,255,255,255)) =0;
 
-		//! Draws a pixel.
-		/** \param x The x-position of the pixel.
-		\param y The y-position of the pixel.
-		\param color Color of the pixel to draw. */
-		virtual void drawPixel(u32 x, u32 y, const SColor& color) =0;
-
-		//! Draws a non filled concyclic regular 2d polygon.
-		/** This method can be used to draw circles, but also
-		triangles, tetragons, pentagons, hexagons, heptagons, octagons,
-		enneagons, decagons, hendecagons, dodecagon, triskaidecagons,
-		etc. I think you'll got it now. And all this by simply
-		specifying the vertex count. Welcome to the wonders of
-		geometry.
-		\param center Position of center of circle (pixels).
-		\param radius Radius of circle in pixels.
-		\param color Color of the circle.
-		\param vertexCount Amount of vertices of the polygon. Specify 2
-		to draw a line, 3 to draw a triangle, 4 for tetragons and a lot
-		(>10) for nearly a circle. */
-		virtual void draw2DPolygon(core::position2d<s32> center,
-				f32 radius,
-				video::SColor color=SColor(100,255,255,255),
-				s32 vertexCount=10) =0;
-
-		//! Draws a shadow volume into the stencil buffer.
-		/** To draw a stencil shadow, do this: First, draw all geometry.
-		Then use this method, to draw the shadow volume. Then, use
-		IVideoDriver::drawStencilShadow() to visualize the shadow.
-		Please note that the code for the opengl version of the method
-		is based on free code sent in by Philipp Dortmann, lots of
-		thanks go to him!
-		\param triangles Array of 3d vectors, specifying the shadow
-		volume.
-		\param zfail If set to true, zfail method is used, otherwise
-		zpass.
-		\param debugDataVisible The debug data that is enabled for this
-		shadow node
-		*/
-		virtual void drawStencilShadowVolume(const core::array<core::vector3df>& triangles, bool zfail=true, u32 debugDataVisible=0) =0;
-
-		//! Fills the stencil shadow with color.
-		/** After the shadow volume has been drawn into the stencil
-		buffer using IVideoDriver::drawStencilShadowVolume(), use this
-		to draw the color of the shadow.
-		Please note that the code for the opengl version of the method
-		is based on free code sent in by Philipp Dortmann, lots of
-		thanks go to him!
-		\param clearStencilBuffer Set this to false, if you want to
-		draw every shadow with the same color, and only want to call
-		drawStencilShadow() once after all shadow volumes have been
-		drawn. Set this to true, if you want to paint every shadow with
-		its own color.
-		\param leftUpEdge Color of the shadow in the upper left corner
-		of screen.
-		\param rightUpEdge Color of the shadow in the upper right
-		corner of screen.
-		\param leftDownEdge Color of the shadow in the lower left
-		corner of screen.
-		\param rightDownEdge Color of the shadow in the lower right
-		corner of screen. */
-		virtual void drawStencilShadow(bool clearStencilBuffer=false,
-			video::SColor leftUpEdge = video::SColor(255,0,0,0),
-			video::SColor rightUpEdge = video::SColor(255,0,0,0),
-			video::SColor leftDownEdge = video::SColor(255,0,0,0),
-			video::SColor rightDownEdge = video::SColor(255,0,0,0)) =0;
-
 		//! Draws a mesh buffer
 		/** \param mb Buffer to draw */
 		virtual void drawMeshBuffer(const scene::IMeshBuffer* mb) =0;
diff --git a/include/SIrrCreationParameters.h b/include/SIrrCreationParameters.h
index 5c1f8da..1ac150b 100644
--- a/include/SIrrCreationParameters.h
+++ b/include/SIrrCreationParameters.h
@@ -24,7 +24,7 @@ namespace irr
 		//! Constructs a SIrrlichtCreationParameters structure with default values.
 		SIrrlichtCreationParameters() :
 			DeviceType(EIDT_BEST),
-			DriverType(video::EDT_BURNINGSVIDEO),
+			DriverType(video::EDT_OPENGL),
 			WindowSize(core::dimension2d<u32>(800, 600)),
 			WindowPosition(core::position2di(-1,-1)),
 			Bits(32),
diff --git a/include/irrlicht.h b/include/irrlicht.h
index e099cf7..359f810 100644
--- a/include/irrlicht.h
+++ b/include/irrlicht.h
@@ -271,7 +271,7 @@ namespace irr
 	device could not be created.
 	*/
 	extern "C" IRRLICHT_API IrrlichtDevice* IRRCALLCONV createDevice(
-		video::E_DRIVER_TYPE driverType = video::EDT_SOFTWARE,
+		video::E_DRIVER_TYPE driverType = video::EDT_OPENGL,
 		// parentheses are necessary for some compilers
 		const core::dimension2d<u32>& windowSize = (core::dimension2d<u32>(640,480)),
 		u32 bits = 32,
diff --git a/media/Shaders/DetailMap.fsh b/media/Shaders/DetailMap.fsh
new file mode 100644
index 0000000..01c94d7
--- /dev/null
+++ b/media/Shaders/DetailMap.fsh
@@ -0,0 +1,72 @@
+#version 100
+
+precision mediump float;
+
+/* Uniforms */
+
+uniform int uTextureUsage0;
+uniform int uTextureUsage1;
+uniform sampler2D uTextureUnit0;
+uniform sampler2D uTextureUnit1;
+uniform int uFogEnable;
+uniform int uFogType;
+uniform vec4 uFogColor;
+uniform float uFogStart;
+uniform float uFogEnd;
+uniform float uFogDensity;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec2 vTextureCoord1;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+float computeFog()
+{
+	const float LOG2 = 1.442695;
+	float FogFactor = 0.0;
+
+	if (uFogType == 0) // Exp
+	{
+		FogFactor = exp2(-uFogDensity * vFogCoord * LOG2);
+	}
+	else if (uFogType == 1) // Linear
+	{
+		float Scale = 1.0 / (uFogEnd - uFogStart);
+		FogFactor = (uFogEnd - vFogCoord) * Scale;
+	}
+	else if (uFogType == 2) // Exp2
+	{
+		FogFactor = exp2(-uFogDensity * uFogDensity * vFogCoord * vFogCoord * LOG2);
+	}
+
+	FogFactor = clamp(FogFactor, 0.0, 1.0);
+
+	return FogFactor;
+}
+
+void main()
+{
+	vec4 Color0 = vec4(1.0, 1.0, 1.0, 1.0);
+	vec4 Color1 = vec4(1.0, 1.0, 1.0, 1.0);
+
+	if (bool(uTextureUsage0))
+		Color0 = texture2D(uTextureUnit0, vTextureCoord0);
+
+	if (bool(uTextureUsage1))
+		Color1 = texture2D(uTextureUnit1, vTextureCoord1);
+
+	vec4 FinalColor = vec4(Color0 + (Color1 - 0.5)) * vVertexColor + vSpecularColor;
+
+	if (bool(uFogEnable))
+	{
+		float FogFactor = computeFog();
+		vec4 FogColor = uFogColor;
+		FogColor.a = 1.0;
+		FinalColor = mix(FogColor, FinalColor, FogFactor);
+	}
+
+	gl_FragColor = FinalColor;
+}
diff --git a/media/Shaders/LightmapAdd.fsh b/media/Shaders/LightmapAdd.fsh
new file mode 100644
index 0000000..895625f
--- /dev/null
+++ b/media/Shaders/LightmapAdd.fsh
@@ -0,0 +1,72 @@
+#version 100
+
+precision mediump float;
+
+/* Uniforms */
+
+uniform int uTextureUsage0;
+uniform int uTextureUsage1;
+uniform sampler2D uTextureUnit0;
+uniform sampler2D uTextureUnit1;
+uniform int uFogEnable;
+uniform int uFogType;
+uniform vec4 uFogColor;
+uniform float uFogStart;
+uniform float uFogEnd;
+uniform float uFogDensity;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec2 vTextureCoord1;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+float computeFog()
+{
+	const float LOG2 = 1.442695;
+	float FogFactor = 0.0;
+
+	if (uFogType == 0) // Exp
+	{
+		FogFactor = exp2(-uFogDensity * vFogCoord * LOG2);
+	}
+	else if (uFogType == 1) // Linear
+	{
+		float Scale = 1.0 / (uFogEnd - uFogStart);
+		FogFactor = (uFogEnd - vFogCoord) * Scale;
+	}
+	else if (uFogType == 2) // Exp2
+	{
+		FogFactor = exp2(-uFogDensity * uFogDensity * vFogCoord * vFogCoord * LOG2);
+	}
+
+	FogFactor = clamp(FogFactor, 0.0, 1.0);
+
+	return FogFactor;
+}
+
+void main()
+{
+	vec4 Color0 = vec4(1.0, 1.0, 1.0, 1.0);
+	vec4 Color1 = vec4(1.0, 1.0, 1.0, 1.0);
+
+	if (bool(uTextureUsage0))
+		Color0 = texture2D(uTextureUnit0, vTextureCoord0);
+
+	if (bool(uTextureUsage1))
+		Color1 = texture2D(uTextureUnit1, vTextureCoord1);
+
+	vec4 FinalColor = (Color0 + Color1) * vVertexColor + vSpecularColor;
+
+	if (bool(uFogEnable))
+	{
+		float FogFactor = computeFog();
+		vec4 FogColor = uFogColor;
+		FogColor.a = 1.0;
+		FinalColor = mix(FogColor, FinalColor, FogFactor);
+	}
+
+	gl_FragColor = FinalColor;
+}
diff --git a/media/Shaders/LightmapModulate.fsh b/media/Shaders/LightmapModulate.fsh
new file mode 100644
index 0000000..74e9df1
--- /dev/null
+++ b/media/Shaders/LightmapModulate.fsh
@@ -0,0 +1,74 @@
+#version 100
+
+precision mediump float;
+
+/* Uniforms */
+
+uniform float uModulate;
+uniform int uTextureUsage0;
+uniform int uTextureUsage1;
+uniform sampler2D uTextureUnit0;
+uniform sampler2D uTextureUnit1;
+uniform int uFogEnable;
+uniform int uFogType;
+uniform vec4 uFogColor;
+uniform float uFogStart;
+uniform float uFogEnd;
+uniform float uFogDensity;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec2 vTextureCoord1;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+float computeFog()
+{
+	const float LOG2 = 1.442695;
+	float FogFactor = 0.0;
+
+	if (uFogType == 0) // Exp
+	{
+		FogFactor = exp2(-uFogDensity * vFogCoord * LOG2);
+	}
+	else if (uFogType == 1) // Linear
+	{
+		float Scale = 1.0 / (uFogEnd - uFogStart);
+		FogFactor = (uFogEnd - vFogCoord) * Scale;
+	}
+	else if (uFogType == 2) // Exp2
+	{
+		FogFactor = exp2(-uFogDensity * uFogDensity * vFogCoord * vFogCoord * LOG2);
+	}
+
+	FogFactor = clamp(FogFactor, 0.0, 1.0);
+
+	return FogFactor;
+}
+
+void main()
+{
+	vec4 Color0 = vec4(1.0, 1.0, 1.0, 1.0);
+	vec4 Color1 = vec4(1.0, 1.0, 1.0, 1.0);
+
+	if (bool(uTextureUsage0))
+		Color0 = texture2D(uTextureUnit0, vTextureCoord0);
+
+	if (bool(uTextureUsage1))
+		Color1 = texture2D(uTextureUnit1, vTextureCoord1);
+
+	vec4 FinalColor = (Color0 * Color1 * uModulate) * vVertexColor;
+	FinalColor += vSpecularColor;
+
+	if (bool(uFogEnable))
+	{
+		float FogFactor = computeFog();
+		vec4 FogColor = uFogColor;
+		FogColor.a = 1.0;
+		FinalColor = mix(FogColor, FinalColor, FogFactor);
+	}
+
+	gl_FragColor = FinalColor;
+}
diff --git a/media/Shaders/OneTextureBlend.fsh b/media/Shaders/OneTextureBlend.fsh
new file mode 100644
index 0000000..c348016
--- /dev/null
+++ b/media/Shaders/OneTextureBlend.fsh
@@ -0,0 +1,77 @@
+#version 100
+
+precision mediump float;
+
+/* Uniforms */
+
+uniform int uTextureUsage0;
+uniform sampler2D uTextureUnit0;
+uniform int uBlendType;
+uniform int uFogEnable;
+uniform int uFogType;
+uniform vec4 uFogColor;
+uniform float uFogStart;
+uniform float uFogEnd;
+uniform float uFogDensity;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+float computeFog()
+{
+	const float LOG2 = 1.442695;
+	float FogFactor = 0.0;
+
+	if (uFogType == 0) // Exp
+	{
+		FogFactor = exp2(-uFogDensity * vFogCoord * LOG2);
+	}
+	else if (uFogType == 1) // Linear
+	{
+		float Scale = 1.0 / (uFogEnd - uFogStart);
+		FogFactor = (uFogEnd - vFogCoord) * Scale;
+	}
+	else if (uFogType == 2) // Exp2
+	{
+		FogFactor = exp2(-uFogDensity * uFogDensity * vFogCoord * vFogCoord * LOG2);
+	}
+
+	FogFactor = clamp(FogFactor, 0.0, 1.0);
+
+	return FogFactor;
+}
+
+void main()
+{
+	vec4 Color0 = vVertexColor;
+	vec4 Color1 = vec4(1.0, 1.0, 1.0, 1.0);
+
+	if (bool(uTextureUsage0))
+		Color1 = texture2D(uTextureUnit0, vTextureCoord0);
+
+	vec4 FinalColor = Color0 * Color1;
+	FinalColor += vSpecularColor;
+
+	if (uBlendType == 1)
+	{
+		FinalColor.w = Color0.w;
+	}
+	else if (uBlendType == 2)
+	{
+		FinalColor.w = Color1.w;
+	}
+
+	if (bool(uFogEnable))
+	{
+		float FogFactor = computeFog();
+		vec4 FogColor = uFogColor;
+		FogColor.a = 1.0;
+		FinalColor = mix(FogColor, FinalColor, FogFactor);
+	}
+
+	gl_FragColor = FinalColor;
+}
diff --git a/media/Shaders/Reflection2Layer.fsh b/media/Shaders/Reflection2Layer.fsh
new file mode 100644
index 0000000..bdc3c66
--- /dev/null
+++ b/media/Shaders/Reflection2Layer.fsh
@@ -0,0 +1,72 @@
+#version 100
+
+precision mediump float;
+
+/* Uniforms */
+
+uniform int uTextureUsage0;
+uniform int uTextureUsage1;
+uniform sampler2D uTextureUnit0;
+uniform sampler2D uTextureUnit1;
+uniform int uFogEnable;
+uniform int uFogType;
+uniform vec4 uFogColor;
+uniform float uFogStart;
+uniform float uFogEnd;
+uniform float uFogDensity;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec2 vTextureCoord1;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+float computeFog()
+{
+	const float LOG2 = 1.442695;
+	float FogFactor = 0.0;
+
+	if (uFogType == 0) // Exp
+	{
+		FogFactor = exp2(-uFogDensity * vFogCoord * LOG2);
+	}
+	else if (uFogType == 1) // Linear
+	{
+		float Scale = 1.0 / (uFogEnd - uFogStart);
+		FogFactor = (uFogEnd - vFogCoord) * Scale;
+	}
+	else if (uFogType == 2) // Exp2
+	{
+		FogFactor = exp2(-uFogDensity * uFogDensity * vFogCoord * vFogCoord * LOG2);
+	}
+
+	FogFactor = clamp(FogFactor, 0.0, 1.0);
+
+	return FogFactor;
+}
+
+void main()
+{
+	vec4 Color0 = vec4(1.0, 1.0, 1.0, 1.0);
+	vec4 Color1 = vec4(1.0, 1.0, 1.0, 1.0);
+
+	if (bool(uTextureUsage0))
+		Color0 = texture2D(uTextureUnit0, vTextureCoord0);
+
+	if (bool(uTextureUsage1))
+		Color1 = texture2D(uTextureUnit1, vTextureCoord1);
+
+	vec4 FinalColor = (Color0 * Color1) * vVertexColor + vSpecularColor;
+
+	if (bool(uFogEnable))
+	{
+		float FogFactor = computeFog();
+		vec4 FogColor = uFogColor;
+		FogColor.a = 1.0;
+		FinalColor = mix(FogColor, FinalColor, FogFactor);
+	}
+
+	gl_FragColor = FinalColor;
+}
diff --git a/media/Shaders/Reflection2Layer.vsh b/media/Shaders/Reflection2Layer.vsh
new file mode 100644
index 0000000..aafac22
--- /dev/null
+++ b/media/Shaders/Reflection2Layer.vsh
@@ -0,0 +1,55 @@
+#version 100
+
+/* Attributes */
+
+attribute vec3 inVertexPosition;
+attribute vec3 inVertexNormal;
+attribute vec4 inVertexColor;
+attribute vec2 inTexCoord0;
+attribute vec2 inTexCoord1;
+
+/* Uniforms */
+
+uniform mat4 uWVPMatrix;
+uniform mat4 uWVMatrix;
+uniform mat4 uNMatrix;
+uniform mat4 uTMatrix0;
+
+uniform vec4 uGlobalAmbient;
+uniform vec4 uMaterialAmbient;
+uniform vec4 uMaterialDiffuse;
+uniform vec4 uMaterialEmissive;
+uniform vec4 uMaterialSpecular;
+uniform float uMaterialShininess;
+
+uniform float uThickness;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec2 vTextureCoord1;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+void main()
+{
+	gl_Position = uWVPMatrix * vec4(inVertexPosition, 1.0);
+	gl_PointSize = uThickness;
+
+	vec4 TextureCoord0 = vec4(inTexCoord0.x, inTexCoord0.y, 1.0, 1.0);
+	vTextureCoord0 = vec4(uTMatrix0 * TextureCoord0).xy;
+
+	vec3 Position = (uWVMatrix * vec4(inVertexPosition, 1.0)).xyz;
+	vec3 P = normalize(Position);
+	vec3 N = normalize(vec4(uNMatrix * vec4(inVertexNormal, 0.0)).xyz);
+	vec3 R = reflect(P, N);
+
+	float V = 2.0 * sqrt(R.x*R.x + R.y*R.y + (R.z+1.0)*(R.z+1.0));
+	vTextureCoord1 = vec2(R.x/V + 0.5, R.y/V + 0.5);
+
+	vVertexColor = inVertexColor.bgra;
+	vSpecularColor = vec4(0.0, 0.0, 0.0, 0.0);
+
+	vFogCoord = length(Position);
+}
diff --git a/media/Shaders/Renderer2D.fsh b/media/Shaders/Renderer2D.fsh
new file mode 100644
index 0000000..89aef7e
--- /dev/null
+++ b/media/Shaders/Renderer2D.fsh
@@ -0,0 +1,23 @@
+#version 100
+
+precision mediump float;
+
+/* Uniforms */
+
+uniform int uTextureUsage;
+uniform sampler2D uTextureUnit;
+
+/* Varyings */
+
+varying vec2 vTextureCoord;
+varying vec4 vVertexColor;
+
+void main()
+{
+	vec4 Color = vVertexColor;
+
+	if (bool(uTextureUsage))
+		Color *= texture2D(uTextureUnit, vTextureCoord);
+
+	gl_FragColor = Color;
+}
diff --git a/media/Shaders/Renderer2D.vsh b/media/Shaders/Renderer2D.vsh
new file mode 100644
index 0000000..9142148
--- /dev/null
+++ b/media/Shaders/Renderer2D.vsh
@@ -0,0 +1,24 @@
+#version 100
+
+/* Attributes */
+
+attribute vec4 inVertexPosition;
+attribute vec4 inVertexColor;
+attribute vec2 inTexCoord0;
+
+/* Uniforms */
+
+uniform float uThickness;
+
+/* Varyings */
+
+varying vec2 vTextureCoord;
+varying vec4 vVertexColor;
+
+void main()
+{
+	gl_Position = inVertexPosition;
+	gl_PointSize = uThickness;
+	vTextureCoord = inTexCoord0;
+	vVertexColor = inVertexColor.bgra;
+}
diff --git a/media/Shaders/Renderer2D_noTex.fsh b/media/Shaders/Renderer2D_noTex.fsh
new file mode 100644
index 0000000..6000972
--- /dev/null
+++ b/media/Shaders/Renderer2D_noTex.fsh
@@ -0,0 +1,11 @@
+#version 100
+
+precision mediump float;
+
+/* Varyings */
+varying vec4 vVertexColor;
+
+void main()
+{
+	gl_FragColor = vVertexColor;
+}
diff --git a/media/Shaders/Solid.fsh b/media/Shaders/Solid.fsh
new file mode 100644
index 0000000..df1010e
--- /dev/null
+++ b/media/Shaders/Solid.fsh
@@ -0,0 +1,64 @@
+#version 100
+
+precision mediump float;
+
+/* Uniforms */
+
+uniform int uTextureUsage0;
+uniform sampler2D uTextureUnit0;
+uniform int uFogEnable;
+uniform int uFogType;
+uniform vec4 uFogColor;
+uniform float uFogStart;
+uniform float uFogEnd;
+uniform float uFogDensity;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+float computeFog()
+{
+	const float LOG2 = 1.442695;
+	float FogFactor = 0.0;
+
+	if (uFogType == 0) // Exp
+	{
+		FogFactor = exp2(-uFogDensity * vFogCoord * LOG2);
+	}
+	else if (uFogType == 1) // Linear
+	{
+		float Scale = 1.0 / (uFogEnd - uFogStart);
+		FogFactor = (uFogEnd - vFogCoord) * Scale;
+	}
+	else if (uFogType == 2) // Exp2
+	{
+		FogFactor = exp2(-uFogDensity * uFogDensity * vFogCoord * vFogCoord * LOG2);
+	}
+
+	FogFactor = clamp(FogFactor, 0.0, 1.0);
+
+	return FogFactor;
+}
+
+void main()
+{
+	vec4 Color = vVertexColor;
+
+	if (bool(uTextureUsage0))
+		Color *= texture2D(uTextureUnit0, vTextureCoord0);
+	Color += vSpecularColor;
+
+	if (bool(uFogEnable))
+	{
+		float FogFactor = computeFog();
+		vec4 FogColor = uFogColor;
+		FogColor.a = 1.0;
+		Color = mix(FogColor, Color, FogFactor);
+	}
+
+	gl_FragColor = Color;
+}
diff --git a/media/Shaders/Solid.vsh b/media/Shaders/Solid.vsh
new file mode 100644
index 0000000..98d0dae
--- /dev/null
+++ b/media/Shaders/Solid.vsh
@@ -0,0 +1,47 @@
+#version 100
+
+/* Attributes */
+
+attribute vec3 inVertexPosition;
+attribute vec3 inVertexNormal;
+attribute vec4 inVertexColor;
+attribute vec2 inTexCoord0;
+
+/* Uniforms */
+
+uniform mat4 uWVPMatrix;
+uniform mat4 uWVMatrix;
+uniform mat4 uNMatrix;
+uniform mat4 uTMatrix0;
+
+uniform vec4 uGlobalAmbient;
+uniform vec4 uMaterialAmbient;
+uniform vec4 uMaterialDiffuse;
+uniform vec4 uMaterialEmissive;
+uniform vec4 uMaterialSpecular;
+uniform float uMaterialShininess;
+
+uniform float uThickness;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+void main()
+{
+	gl_Position = uWVPMatrix * vec4(inVertexPosition, 1.0);
+	gl_PointSize = uThickness;
+
+	vec4 TextureCoord0 = vec4(inTexCoord0.x, inTexCoord0.y, 1.0, 1.0);
+	vTextureCoord0 = vec4(uTMatrix0 * TextureCoord0).xy;
+
+	vVertexColor = inVertexColor.bgra;
+	vSpecularColor = vec4(0.0, 0.0, 0.0, 0.0);
+
+	vec3 Position = (uWVMatrix * vec4(inVertexPosition, 1.0)).xyz;
+
+	vFogCoord = length(Position);
+}
diff --git a/media/Shaders/Solid2.vsh b/media/Shaders/Solid2.vsh
new file mode 100644
index 0000000..c49ecfc
--- /dev/null
+++ b/media/Shaders/Solid2.vsh
@@ -0,0 +1,53 @@
+#version 100
+
+/* Attributes */
+
+attribute vec3 inVertexPosition;
+attribute vec3 inVertexNormal;
+attribute vec4 inVertexColor;
+attribute vec2 inTexCoord0;
+attribute vec2 inTexCoord1;
+
+/* Uniforms */
+
+uniform mat4 uWVPMatrix;
+uniform mat4 uWVMatrix;
+uniform mat4 uNMatrix;
+uniform mat4 uTMatrix0;
+uniform mat4 uTMatrix1;
+
+uniform vec4 uGlobalAmbient;
+uniform vec4 uMaterialAmbient;
+uniform vec4 uMaterialDiffuse;
+uniform vec4 uMaterialEmissive;
+uniform vec4 uMaterialSpecular;
+uniform float uMaterialShininess;
+
+uniform float uThickness;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec2 vTextureCoord1;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+void main()
+{
+	gl_Position = uWVPMatrix * vec4(inVertexPosition, 1.0);
+	gl_PointSize = uThickness;
+
+	vec4 TextureCoord0 = vec4(inTexCoord0.x, inTexCoord0.y, 1.0, 1.0);
+	vTextureCoord0 = vec4(uTMatrix0 * TextureCoord0).xy;
+
+	vec4 TextureCoord1 = vec4(inTexCoord1.x, inTexCoord1.y, 1.0, 1.0);
+	vTextureCoord1 = vec4(uTMatrix1 * TextureCoord1).xy;
+
+	vVertexColor = inVertexColor.bgra;
+	vSpecularColor = vec4(0.0, 0.0, 0.0, 0.0);
+
+	vec3 Position = (uWVMatrix * vec4(inVertexPosition, 1.0)).xyz;
+
+	vFogCoord = length(Position);
+}
diff --git a/media/Shaders/Solid2Layer.fsh b/media/Shaders/Solid2Layer.fsh
new file mode 100644
index 0000000..3c8a39d
--- /dev/null
+++ b/media/Shaders/Solid2Layer.fsh
@@ -0,0 +1,74 @@
+#version 100
+
+precision mediump float;
+
+/* Uniforms */
+
+uniform int uTextureUsage0;
+uniform int uTextureUsage1;
+uniform sampler2D uTextureUnit0;
+uniform sampler2D uTextureUnit1;
+uniform int uFogEnable;
+uniform int uFogType;
+uniform vec4 uFogColor;
+uniform float uFogStart;
+uniform float uFogEnd;
+uniform float uFogDensity;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec2 vTextureCoord1;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+float computeFog()
+{
+	const float LOG2 = 1.442695;
+	float FogFactor = 0.0;
+
+	if (uFogType == 0) // Exp
+	{
+		FogFactor = exp2(-uFogDensity * vFogCoord * LOG2);
+	}
+	else if (uFogType == 1) // Linear
+	{
+		float Scale = 1.0 / (uFogEnd - uFogStart);
+		FogFactor = (uFogEnd - vFogCoord) * Scale;
+	}
+	else if (uFogType == 2) // Exp2
+	{
+		FogFactor = exp2(-uFogDensity * uFogDensity * vFogCoord * vFogCoord * LOG2);
+	}
+
+	FogFactor = clamp(FogFactor, 0.0, 1.0);
+
+	return FogFactor;
+}
+
+void main()
+{
+	vec4 Color0 = vec4(1.0, 1.0, 1.0, 1.0);
+	vec4 Color1 = vec4(1.0, 1.0, 1.0, 1.0);
+
+	if (bool(uTextureUsage0))
+		Color0 = texture2D(uTextureUnit0, vTextureCoord0);
+
+	if (bool(uTextureUsage1))
+		Color1 = texture2D(uTextureUnit1, vTextureCoord1);
+
+	vec4 FinalColor = (Color0 * vVertexColor.a + Color1 * (1.0 - vVertexColor.a)) * vVertexColor;
+	FinalColor += vSpecularColor;
+
+	if (bool(uFogEnable))
+	{
+		float FogFactor = computeFog();
+		vec4 FogColor = uFogColor;
+		FogColor.a = 1.0;
+		FinalColor = mix(FogColor, FinalColor, FogFactor);
+	}
+
+	gl_FragColor = FinalColor;
+
+}
diff --git a/media/Shaders/SphereMap.fsh b/media/Shaders/SphereMap.fsh
new file mode 100644
index 0000000..df1010e
--- /dev/null
+++ b/media/Shaders/SphereMap.fsh
@@ -0,0 +1,64 @@
+#version 100
+
+precision mediump float;
+
+/* Uniforms */
+
+uniform int uTextureUsage0;
+uniform sampler2D uTextureUnit0;
+uniform int uFogEnable;
+uniform int uFogType;
+uniform vec4 uFogColor;
+uniform float uFogStart;
+uniform float uFogEnd;
+uniform float uFogDensity;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+float computeFog()
+{
+	const float LOG2 = 1.442695;
+	float FogFactor = 0.0;
+
+	if (uFogType == 0) // Exp
+	{
+		FogFactor = exp2(-uFogDensity * vFogCoord * LOG2);
+	}
+	else if (uFogType == 1) // Linear
+	{
+		float Scale = 1.0 / (uFogEnd - uFogStart);
+		FogFactor = (uFogEnd - vFogCoord) * Scale;
+	}
+	else if (uFogType == 2) // Exp2
+	{
+		FogFactor = exp2(-uFogDensity * uFogDensity * vFogCoord * vFogCoord * LOG2);
+	}
+
+	FogFactor = clamp(FogFactor, 0.0, 1.0);
+
+	return FogFactor;
+}
+
+void main()
+{
+	vec4 Color = vVertexColor;
+
+	if (bool(uTextureUsage0))
+		Color *= texture2D(uTextureUnit0, vTextureCoord0);
+	Color += vSpecularColor;
+
+	if (bool(uFogEnable))
+	{
+		float FogFactor = computeFog();
+		vec4 FogColor = uFogColor;
+		FogColor.a = 1.0;
+		Color = mix(FogColor, Color, FogFactor);
+	}
+
+	gl_FragColor = Color;
+}
diff --git a/media/Shaders/SphereMap.vsh b/media/Shaders/SphereMap.vsh
new file mode 100644
index 0000000..5062d79
--- /dev/null
+++ b/media/Shaders/SphereMap.vsh
@@ -0,0 +1,50 @@
+#version 100
+
+/* Attributes */
+
+attribute vec3 inVertexPosition;
+attribute vec3 inVertexNormal;
+attribute vec4 inVertexColor;
+attribute vec2 inTexCoord0;
+attribute vec2 inTexCoord1;
+
+/* Uniforms */
+
+uniform mat4 uWVPMatrix;
+uniform mat4 uWVMatrix;
+uniform mat4 uNMatrix;
+
+uniform vec4 uGlobalAmbient;
+uniform vec4 uMaterialAmbient;
+uniform vec4 uMaterialDiffuse;
+uniform vec4 uMaterialEmissive;
+uniform vec4 uMaterialSpecular;
+uniform float uMaterialShininess;
+
+uniform float uThickness;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+void main()
+{
+	gl_Position = uWVPMatrix * vec4(inVertexPosition, 1.0);
+	gl_PointSize = uThickness;
+
+	vec3 Position = (uWVMatrix * vec4(inVertexPosition, 1.0)).xyz;
+	vec3 P = normalize(Position);
+	vec3 N = normalize(vec4(uNMatrix * vec4(inVertexNormal, 0.0)).xyz);
+	vec3 R = reflect(P, N);
+
+	float V = 2.0 * sqrt(R.x*R.x + R.y*R.y + (R.z+1.0)*(R.z+1.0));
+	vTextureCoord0 = vec2(R.x/V + 0.5, R.y/V + 0.5);
+
+	vVertexColor = inVertexColor.bgra;
+	vSpecularColor = vec4(0.0, 0.0, 0.0, 0.0);
+
+	vFogCoord = length(Position);
+}
diff --git a/media/Shaders/TransparentAlphaChannel.fsh b/media/Shaders/TransparentAlphaChannel.fsh
new file mode 100644
index 0000000..cef349a
--- /dev/null
+++ b/media/Shaders/TransparentAlphaChannel.fsh
@@ -0,0 +1,71 @@
+#version 100
+
+precision mediump float;
+
+/* Uniforms */
+
+uniform float uAlphaRef;
+uniform int uTextureUsage0;
+uniform sampler2D uTextureUnit0;
+uniform int uFogEnable;
+uniform int uFogType;
+uniform vec4 uFogColor;
+uniform float uFogStart;
+uniform float uFogEnd;
+uniform float uFogDensity;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+float computeFog()
+{
+	const float LOG2 = 1.442695;
+	float FogFactor = 0.0;
+
+	if (uFogType == 0) // Exp
+	{
+		FogFactor = exp2(-uFogDensity * vFogCoord * LOG2);
+	}
+	else if (uFogType == 1) // Linear
+	{
+		float Scale = 1.0 / (uFogEnd - uFogStart);
+		FogFactor = (uFogEnd - vFogCoord) * Scale;
+	}
+	else if (uFogType == 2) // Exp2
+	{
+		FogFactor = exp2(-uFogDensity * uFogDensity * vFogCoord * vFogCoord * LOG2);
+	}
+
+	FogFactor = clamp(FogFactor, 0.0, 1.0);
+
+	return FogFactor;
+}
+
+void main()
+{
+	vec4 Color = vVertexColor;
+
+	if (bool(uTextureUsage0))
+	{
+		Color *= texture2D(uTextureUnit0, vTextureCoord0);
+
+		// TODO: uAlphaRef should rather control sharpness of alpha, don't know how to do that right now and this works in most cases.
+		if (Color.a < uAlphaRef)
+			discard;
+	}
+	Color += vSpecularColor;
+
+	if (bool(uFogEnable))
+	{
+		float FogFactor = computeFog();
+		vec4 FogColor = uFogColor;
+		FogColor.a = 1.0;
+		Color = mix(FogColor, Color, FogFactor);
+	}
+
+	gl_FragColor = Color;
+}
diff --git a/media/Shaders/TransparentAlphaChannelRef.fsh b/media/Shaders/TransparentAlphaChannelRef.fsh
new file mode 100644
index 0000000..fab4eee
--- /dev/null
+++ b/media/Shaders/TransparentAlphaChannelRef.fsh
@@ -0,0 +1,69 @@
+#version 100
+
+precision mediump float;
+
+/* Uniforms */
+
+uniform float uAlphaRef;
+uniform int uTextureUsage0;
+uniform sampler2D uTextureUnit0;
+uniform int uFogEnable;
+uniform int uFogType;
+uniform vec4 uFogColor;
+uniform float uFogStart;
+uniform float uFogEnd;
+uniform float uFogDensity;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+float computeFog()
+{
+	const float LOG2 = 1.442695;
+	float FogFactor = 0.0;
+
+	if (uFogType == 0) // Exp
+	{
+		FogFactor = exp2(-uFogDensity * vFogCoord * LOG2);
+	}
+	else if (uFogType == 1) // Linear
+	{
+		float Scale = 1.0 / (uFogEnd - uFogStart);
+		FogFactor = (uFogEnd - vFogCoord) * Scale;
+	}
+	else if (uFogType == 2) // Exp2
+	{
+		FogFactor = exp2(-uFogDensity * uFogDensity * vFogCoord * vFogCoord * LOG2);
+	}
+
+	FogFactor = clamp(FogFactor, 0.0, 1.0);
+
+	return FogFactor;
+}
+
+void main()
+{
+	vec4 Color = vVertexColor;
+
+	if (bool(uTextureUsage0))
+		Color *= texture2D(uTextureUnit0, vTextureCoord0);
+
+	if (Color.a < uAlphaRef)
+		discard;
+
+	Color += vSpecularColor;
+
+	if (bool(uFogEnable))
+	{
+		float FogFactor = computeFog();
+		vec4 FogColor = uFogColor;
+		FogColor.a = 1.0;
+		Color = mix(FogColor, Color, FogFactor);
+	}
+
+	gl_FragColor = Color;
+}
diff --git a/media/Shaders/TransparentVertexAlpha.fsh b/media/Shaders/TransparentVertexAlpha.fsh
new file mode 100644
index 0000000..df1010e
--- /dev/null
+++ b/media/Shaders/TransparentVertexAlpha.fsh
@@ -0,0 +1,64 @@
+#version 100
+
+precision mediump float;
+
+/* Uniforms */
+
+uniform int uTextureUsage0;
+uniform sampler2D uTextureUnit0;
+uniform int uFogEnable;
+uniform int uFogType;
+uniform vec4 uFogColor;
+uniform float uFogStart;
+uniform float uFogEnd;
+uniform float uFogDensity;
+
+/* Varyings */
+
+varying vec2 vTextureCoord0;
+varying vec4 vVertexColor;
+varying vec4 vSpecularColor;
+varying float vFogCoord;
+
+float computeFog()
+{
+	const float LOG2 = 1.442695;
+	float FogFactor = 0.0;
+
+	if (uFogType == 0) // Exp
+	{
+		FogFactor = exp2(-uFogDensity * vFogCoord * LOG2);
+	}
+	else if (uFogType == 1) // Linear
+	{
+		float Scale = 1.0 / (uFogEnd - uFogStart);
+		FogFactor = (uFogEnd - vFogCoord) * Scale;
+	}
+	else if (uFogType == 2) // Exp2
+	{
+		FogFactor = exp2(-uFogDensity * uFogDensity * vFogCoord * vFogCoord * LOG2);
+	}
+
+	FogFactor = clamp(FogFactor, 0.0, 1.0);
+
+	return FogFactor;
+}
+
+void main()
+{
+	vec4 Color = vVertexColor;
+
+	if (bool(uTextureUsage0))
+		Color *= texture2D(uTextureUnit0, vTextureCoord0);
+	Color += vSpecularColor;
+
+	if (bool(uFogEnable))
+	{
+		float FogFactor = computeFog();
+		vec4 FogColor = uFogColor;
+		FogColor.a = 1.0;
+		Color = mix(FogColor, Color, FogFactor);
+	}
+
+	gl_FragColor = Color;
+}
diff --git a/source/Irrlicht/CIrrDeviceSDL.cpp b/source/Irrlicht/CIrrDeviceSDL.cpp
index 26683a7..c1e7527 100644
--- a/source/Irrlicht/CIrrDeviceSDL.cpp
+++ b/source/Irrlicht/CIrrDeviceSDL.cpp
@@ -20,15 +20,10 @@
 #include <SDL_video.h>
 
 #ifdef _IRR_EMSCRIPTEN_PLATFORM_
-#ifdef _IRR_COMPILE_WITH_OGLES2_
-#include "CEGLManager.h"
-#endif
 #include <emscripten.h>
 #endif
 
-#ifdef _IRR_COMPILE_WITH_OPENGL_
 #include "CSDLManager.h"
-#endif
 
 static int SDLDeviceInstances = 0;
 
@@ -38,14 +33,42 @@ namespace irr
 	{
 		#ifdef _IRR_COMPILE_WITH_OPENGL_
 		IVideoDriver* createOpenGLDriver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager);
+		#else
+		static IVideoDriver* createOpenGLDriver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager)
+		{
+			os::Printer::log("No OpenGL support compiled in.", ELL_ERROR);
+			return nullptr;
+		}
+		#endif
+
+		#ifdef ENABLE_OPENGL3
+		IVideoDriver* createOpenGL3Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager);
+		#else
+		static IVideoDriver* createOpenGL3Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager)
+		{
+			os::Printer::log("No OpenGL 3 support compiled in.", ELL_ERROR);
+			return nullptr;
+		}
 		#endif
 
 		#ifdef _IRR_COMPILE_WITH_OGLES2_
 		IVideoDriver* createOGLES2Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager);
+		#else
+		static IVideoDriver* createOGLES2Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager)
+		{
+			os::Printer::log("No OpenGL ES 2 support compiled in.", ELL_ERROR);
+			return nullptr;
+		}
 		#endif
 
 		#ifdef _IRR_COMPILE_WITH_WEBGL1_
 		IVideoDriver* createWebGL1Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager);
+		#else
+		static IVideoDriver* createWebGL1Driver(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager)
+		{
+			os::Printer::log("No WebGL 1 support compiled in.", ELL_ERROR);
+			return nullptr;
+		}
 		#endif
 	} // end namespace video
 
@@ -232,28 +255,6 @@ CIrrDeviceSDL::CIrrDeviceSDL(const SIrrlichtCreationParameters& param)
 	// create keymap
 	createKeyMap();
 
-	if (CreationParams.Fullscreen) {
-#ifdef _IRR_EMSCRIPTEN_PLATFORM_
-		SDL_Flags |= SDL_WINDOW_FULLSCREEN;
-#else
-		SDL_Flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
-#endif
-	}
-	if (Resizable)
-		SDL_Flags |= SDL_WINDOW_RESIZABLE;
-	if (CreationParams.WindowMaximized)
-		SDL_Flags |= SDL_WINDOW_MAXIMIZED;
-
-	if (CreationParams.DriverType == video::EDT_OPENGL)
-	{
-		SDL_Flags |= SDL_WINDOW_OPENGL;
-		if (!CreationParams.Doublebuffer)
-			SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 0);
-	}
-#ifdef _IRR_EMSCRIPTEN_PLATFORM_
-	SDL_Flags |= SDL_WINDOW_OPENGL;
-#endif //_IRR_EMSCRIPTEN_PLATFORM_
-
 	// create window
 	if (CreationParams.DriverType != video::EDT_NULL)
 	{
@@ -343,6 +344,19 @@ void CIrrDeviceSDL::logAttributes()
 
 bool CIrrDeviceSDL::createWindow()
 {
+	if (CreationParams.Fullscreen) {
+#ifdef _IRR_EMSCRIPTEN_PLATFORM_
+		SDL_Flags |= SDL_WINDOW_FULLSCREEN;
+#else
+		SDL_Flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
+#endif
+	}
+	if (Resizable)
+		SDL_Flags |= SDL_WINDOW_RESIZABLE;
+	if (CreationParams.WindowMaximized)
+		SDL_Flags |= SDL_WINDOW_MAXIMIZED;
+	SDL_Flags |= SDL_WINDOW_OPENGL;
+
 #ifdef _IRR_EMSCRIPTEN_PLATFORM_
 	if ( Width != 0 || Height != 0 )
 		emscripten_set_canvas_size( Width, Height);
@@ -389,54 +403,73 @@ bool CIrrDeviceSDL::createWindow()
 	if ( Close )
 		return false;
 
-	if (CreationParams.DriverType == video::EDT_OPENGL) {
-		if (CreationParams.Bits == 16) {
-			SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 4);
-			SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 4);
-			SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 4);
-			SDL_GL_SetAttribute(
-					SDL_GL_ALPHA_SIZE, CreationParams.WithAlphaChannel ? 1 : 0);
-		} else {
-			SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
-			SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
-			SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
-			SDL_GL_SetAttribute(
-					SDL_GL_ALPHA_SIZE, CreationParams.WithAlphaChannel ? 8 : 0);
-		}
-		SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, CreationParams.ZBufferBits);
-		if (CreationParams.Doublebuffer)
-			SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-		SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, CreationParams.Stencilbuffer ? 8 : 0);
-		if (CreationParams.Stereobuffer)
-			SDL_GL_SetAttribute(SDL_GL_STEREO, 1);
-		if (CreationParams.AntiAlias > 1) {
-			SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
+	switch (CreationParams.DriverType) {
+		case video::EDT_OPENGL:
+			SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
+			SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
+			break;
+		case video::EDT_OPENGL3:
+			SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
+			SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
+			SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_COMPATIBILITY);
+			break;
+		case video::EDT_OGLES1:
+			SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
+			SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
+			SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
+			break;
+		case video::EDT_OGLES2:
+		case video::EDT_WEBGL1:
+			SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
+			SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
+			SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
+			break;
+		default:;
+	}
+
+#ifdef _DEBUG
+	SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG | SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG);
+#endif
+
+	if (CreationParams.Bits == 16) {
+		SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
+		SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
+		SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
+		SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, CreationParams.WithAlphaChannel ? 1 : 0);
+	} else {
+		SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
+		SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
+		SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
+		SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, CreationParams.WithAlphaChannel ? 8 : 0);
+	}
+	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, CreationParams.ZBufferBits);
+	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, CreationParams.Doublebuffer);
+	SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, CreationParams.Stencilbuffer ? 8 : 0);
+	SDL_GL_SetAttribute(SDL_GL_STEREO, CreationParams.Stereobuffer);
+	if (CreationParams.AntiAlias > 1) {
+		SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
+		SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, CreationParams.AntiAlias);
+	}
+	if (!Window)
+		Window = SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, Width, Height, SDL_Flags);
+	if (!Window) {
+		os::Printer::log("Could not create window...", SDL_GetError(), ELL_WARNING);
+	}
+	if (!Window && CreationParams.AntiAlias > 1) {
+		while (--CreationParams.AntiAlias > 1) {
 			SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, CreationParams.AntiAlias);
-		}
-		if (!Window)
 			Window = SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, Width, Height, SDL_Flags);
-		if (!Window && CreationParams.AntiAlias > 1) {
-			while (--CreationParams.AntiAlias > 1) {
-				SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, CreationParams.AntiAlias);
-				Window = SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, Width, Height, SDL_Flags);
-				if (Window)
-					break;
-			}
-			if (!Window) {
-				SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0);
-				SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0);
-				Window = SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, Width, Height, SDL_Flags);
-				if (Window)
-					os::Printer::log("AntiAliasing disabled due to lack of support!");
-			}
+			if (Window)
+				break;
 		}
-
-		if (Window)
-		{
-			Context = SDL_GL_CreateContext(Window);
+		if (!Window) {
+			SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0);
+			SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0);
+			Window = SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, Width, Height, SDL_Flags);
+			if (Window)
+				os::Printer::log("AntiAliasing disabled due to lack of support!", ELL_WARNING);
 		}
-	} else if (!Window)
-		Window = SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, Width, Height, SDL_Flags);
+	}
 
 	if ( !Window && CreationParams.Doublebuffer)
 	{
@@ -447,7 +480,14 @@ bool CIrrDeviceSDL::createWindow()
 	}
 	if ( !Window )
 	{
-		os::Printer::log("Could not initialize display!" );
+		os::Printer::log("Could not initialize display", SDL_GetError(), ELL_ERROR);
+		return false;
+	}
+
+	Context = SDL_GL_CreateContext(Window);
+	if (!Context) {
+		os::Printer::log("Could not initialize context", SDL_GetError(), ELL_ERROR);
+		SDL_DestroyWindow(Window);
 		return false;
 	}
 
@@ -459,79 +499,22 @@ bool CIrrDeviceSDL::createWindow()
 //! create the driver
 void CIrrDeviceSDL::createDriver()
 {
-	switch(CreationParams.DriverType)
-	{
-	case video::DEPRECATED_EDT_DIRECT3D8_NO_LONGER_EXISTS:
-		os::Printer::log("DIRECT3D8 Driver is no longer supported in Irrlicht. Try another one.", ELL_ERROR);
-		break;
-
-	case video::EDT_DIRECT3D9:
-		#ifdef _IRR_COMPILE_WITH_DIRECT3D_9_
-		os::Printer::log("SDL device does not support DIRECT3D9 driver. Try another one.", ELL_ERROR);
-		#else
-		os::Printer::log("DIRECT3D9 Driver was not compiled into this dll. Try another one.", ELL_ERROR);
-		#endif // _IRR_COMPILE_WITH_DIRECT3D_9_
-
-		break;
-
-	case video::EDT_OPENGL:
-		#ifdef _IRR_COMPILE_WITH_OPENGL_
-		ContextManager = new video::CSDLManager(this);
-		VideoDriver = video::createOpenGLDriver(CreationParams, FileSystem, ContextManager);
-		#else
-		os::Printer::log("No OpenGL support compiled in.", ELL_ERROR);
-		#endif
-		break;
-
-	case video::EDT_OGLES2:
-#if defined(_IRR_COMPILE_WITH_OGLES2_) && defined(_IRR_EMSCRIPTEN_PLATFORM_)
-		{
-			video::SExposedVideoData data;
-
-			ContextManager = new video::CEGLManager();
-			ContextManager->initialize(CreationParams, data);
-
-			VideoDriver = video::createOGLES2Driver(CreationParams, FileSystem, ContextManager);
-		}
-#else
-		os::Printer::log("No OpenGL-ES2 support compiled in.", ELL_ERROR);
-#endif
-		break;
-
-	case video::EDT_WEBGL1:
-#if defined(_IRR_COMPILE_WITH_WEBGL1_) && defined(_IRR_EMSCRIPTEN_PLATFORM_)
-		{
-			video::SExposedVideoData data;
-
-			ContextManager = new video::CEGLManager();
-			ContextManager->initialize(CreationParams, data);
-
-			VideoDriver = video::createWebGL1Driver(CreationParams, FileSystem, ContextManager);
-		}
-#else
-		os::Printer::log("No WebGL1 support compiled in.", ELL_ERROR);
-#endif
-		break;
-
-	case video::EDT_NULL:
+	if (CreationParams.DriverType == video::EDT_NULL) {
 		VideoDriver = video::createNullDriver(FileSystem, CreationParams.WindowSize);
-		break;
-
-	default:
-		os::Printer::log("Unable to create video driver of unknown type.", ELL_ERROR);
-		break;
+		return;
 	}
 
-	// In case we got the size from the canvas
-	if ( VideoDriver && CreationParams.WindowSize.Width == 0 && CreationParams.WindowSize.Height == 0 && Width > 0 && Height > 0 )
+	ContextManager = new video::CSDLManager(this);
+	switch(CreationParams.DriverType)
 	{
-#ifdef _IRR_EMSCRIPTEN_PLATFORM_
-		SDL_CreateWindowAndRenderer(Width, Height, SDL_Flags, &Window, &Renderer);
-#else //_IRR_EMSCRIPTEN_PLATFORM_
-		Window = SDL_CreateWindow("", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, Width, Height, SDL_Flags);
-#endif //_IRR_EMSCRIPTEN_PLATFOR
-		VideoDriver->OnResize(core::dimension2d<u32>(Width, Height));
+	case video::EDT_OPENGL: VideoDriver = video::createOpenGLDriver(CreationParams, FileSystem, ContextManager); break;
+	case video::EDT_OPENGL3: VideoDriver = video::createOpenGL3Driver(CreationParams, FileSystem, ContextManager); break;
+	case video::EDT_OGLES2: VideoDriver = video::createOGLES2Driver(CreationParams, FileSystem, ContextManager); break;
+	case video::EDT_WEBGL1: VideoDriver = video::createWebGL1Driver(CreationParams, FileSystem, ContextManager); break;
+	default:;
 	}
+	if (!VideoDriver)
+		os::Printer::log("Could not create video driver", ELL_ERROR);
 }
 
 
diff --git a/source/Irrlicht/CMakeLists.txt b/source/Irrlicht/CMakeLists.txt
index e993ace..4d7141e 100644
--- a/source/Irrlicht/CMakeLists.txt
+++ b/source/Irrlicht/CMakeLists.txt
@@ -89,8 +89,7 @@ elseif(APPLE)
 elseif(ANDROID)
 	add_definitions(-D_IRR_ANDROID_PLATFORM_ -D_IRR_COMPILE_ANDROID_ASSET_READER_)
 	if(USE_SDL2)
-		message(WARNING "SDL2 backend is not supported on Android")
-		set(USE_SDL2 FALSE)
+		message(SEND_ERROR "SDL2 backend is not supported on Android")
 	endif()
 	set(DEVICE "Android")
 elseif(EMSCRIPTEN)
@@ -140,6 +139,8 @@ endif()
 
 # OpenGL
 
+option(ENABLE_OPENGL3 "Enable OpenGL 3+" FALSE)
+
 if(ANDROID OR EMSCRIPTEN)
 	set(ENABLE_OPENGL FALSE)
 else()
@@ -185,7 +186,18 @@ 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)
+	if (USE_SDL2)
+		message(SEND_ERROR "OpenGL ES 1 is not supported with SDL2")
+	endif()
 	add_definitions(-D_IRR_COMPILE_WITH_OGLES1_)
 	if(DEVICE MATCHES "^(WINDOWS|X11|ANDROID)$")
 		add_definitions(-D_IRR_COMPILE_WITH_EGL_MANAGER_ -D_IRR_OGLES1_USE_EXTPOINTER_)
@@ -196,6 +208,9 @@ if(ENABLE_GLES2)
 	add_definitions(-D_IRR_COMPILE_WITH_OGLES2_)
 	if(DEVICE MATCHES "^(WINDOWS|X11|ANDROID)$" OR EMSCRIPTEN)
 		add_definitions(-D_IRR_COMPILE_WITH_EGL_MANAGER_ -D_IRR_OGLES2_USE_EXTPOINTER_)
+	elseif(DEVICE STREQUAL "SDL")
+		set(USE_SDLGL ON)
+		set(USE_SDLGLES2 ON)
 	endif()
 endif()
 
@@ -215,8 +230,15 @@ endif()
 
 message(STATUS "Device: ${DEVICE}")
 message(STATUS "OpenGL: ${ENABLE_OPENGL}")
+message(STATUS "OpenGL 3: ${USE_SDLGL3}")
 message(STATUS "OpenGL ES: ${ENABLE_GLES1}")
-message(STATUS "OpenGL ES 2: ${ENABLE_GLES2}")
+if (USE_SDLGLES2)
+	message(STATUS "OpenGL ES 2: ON (unified)")
+elseif (ENABLE_GLES2)
+	message(STATUS "OpenGL ES 2: ON (legacy)")
+else()
+	message(STATUS "OpenGL ES 2: OFF")
+endif()
 message(STATUS "WebGL: ${ENABLE_WEBGL1}")
 
 # Required libs
@@ -336,12 +358,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
@@ -366,6 +382,37 @@ add_library(IRRVIDEOOBJ OBJECT
 	${IRRIMAGEOBJ}
 )
 
+if(USE_SDLGL)
+	target_sources(IRRVIDEOOBJ PRIVATE
+		OpenGL/Driver.cpp
+		OpenGL/ExtensionHandler.cpp
+		OpenGL/FixedPipelineRenderer.cpp
+		OpenGL/MaterialRenderer.cpp
+		OpenGL/Renderer2D.cpp
+	)
+endif()
+
+if(USE_SDLGL3)
+	target_sources(IRRVIDEOOBJ PRIVATE
+		OpenGL3/Driver.cpp
+	)
+endif()
+
+if(USE_SDLGLES2)
+	target_sources(IRRVIDEOOBJ PRIVATE
+		OpenGLES2/Driver.cpp
+	)
+else()
+	target_sources(IRRVIDEOOBJ PRIVATE
+		COGLES2Driver.cpp
+		COGLES2ExtensionHandler.cpp
+		COGLES2FixedPipelineRenderer.cpp
+		COGLES2MaterialRenderer.cpp
+		COGLES2Renderer2D.cpp
+		CWebGL1Driver.cpp
+	)
+endif()
+
 add_library(IRRIOOBJ OBJECT
 	CFileList.cpp
 	CFileSystem.cpp
@@ -388,6 +435,10 @@ add_library(IRROTHEROBJ OBJECT
 	os.cpp
 )
 
+if(ENABLE_OPENGL3)
+	target_compile_definitions(IRROTHEROBJ PRIVATE ENABLE_OPENGL3)
+endif()
+
 if(ANDROID)
 	target_sources(IRROTHEROBJ PRIVATE
 		Android/CIrrDeviceAndroid.cpp
diff --git a/source/Irrlicht/CNullDriver.cpp b/source/Irrlicht/CNullDriver.cpp
index 21e143a..a02431c 100644
--- a/source/Irrlicht/CNullDriver.cpp
+++ b/source/Irrlicht/CNullDriver.cpp
@@ -719,27 +719,6 @@ void CNullDriver::draw3DLine(const core::vector3df& start,
 }
 
 
-//! Draws a 3d triangle.
-void CNullDriver::draw3DTriangle(const core::triangle3df& triangle, SColor color)
-{
-	S3DVertex vertices[3];
-	vertices[0].Pos=triangle.pointA;
-	vertices[0].Color=color;
-	vertices[0].Normal=triangle.getNormal().normalize();
-	vertices[0].TCoords.set(0.f,0.f);
-	vertices[1].Pos=triangle.pointB;
-	vertices[1].Color=color;
-	vertices[1].Normal=vertices[0].Normal;
-	vertices[1].TCoords.set(0.5f,1.f);
-	vertices[2].Pos=triangle.pointC;
-	vertices[2].Color=color;
-	vertices[2].Normal=vertices[0].Normal;
-	vertices[2].TCoords.set(1.f,0.f);
-	const u16 indexList[] = {0,1,2};
-	drawVertexPrimitiveList(vertices, 3, indexList, 1, EVT_STANDARD, scene::EPT_TRIANGLES, EIT_16BIT);
-}
-
-
 //! Draws a 3d axis aligned box.
 void CNullDriver::draw3DBox(const core::aabbox3d<f32>& box, SColor color)
 {
@@ -779,31 +758,6 @@ void CNullDriver::draw2DImage(const video::ITexture* texture, const core::positi
 }
 
 
-
-//! draws a set of 2d images, using a color and the alpha channel of the
-//! texture if desired. The images are drawn beginning at pos and concatenated
-//! in one line. All drawings are clipped against clipRect (if != 0).
-//! The subtextures are defined by the array of sourceRects and are chosen
-//! by the indices given.
-void CNullDriver::draw2DImageBatch(const video::ITexture* texture,
-				const core::position2d<s32>& pos,
-				const core::array<core::rect<s32> >& sourceRects,
-				const core::array<s32>& indices,
-				s32 kerningWidth,
-				const core::rect<s32>* clipRect, SColor color,
-				bool useAlphaChannelOfTexture)
-{
-	core::position2d<s32> target(pos);
-
-	for (u32 i=0; i<indices.size(); ++i)
-	{
-		draw2DImage(texture, target, sourceRects[indices[i]],
-				clipRect, color, useAlphaChannelOfTexture);
-		target.X += sourceRects[indices[i]].getWidth();
-		target.X += kerningWidth;
-	}
-}
-
 //! draws a set of 2d images, using a color and the alpha channel of the
 //! texture if desired.
 void CNullDriver::draw2DImageBatch(const video::ITexture* texture,
@@ -844,16 +798,6 @@ void CNullDriver::draw2DImage(const video::ITexture* texture, const core::positi
 }
 
 
-//! Draws the outline of a 2d rectangle
-void CNullDriver::draw2DRectangleOutline(const core::recti& pos, SColor color)
-{
-	draw2DLine(pos.UpperLeftCorner, core::position2di(pos.LowerRightCorner.X, pos.UpperLeftCorner.Y), color);
-	draw2DLine(core::position2di(pos.LowerRightCorner.X, pos.UpperLeftCorner.Y), pos.LowerRightCorner, color);
-	draw2DLine(pos.LowerRightCorner, core::position2di(pos.UpperLeftCorner.X, pos.LowerRightCorner.Y), color);
-	draw2DLine(core::position2di(pos.UpperLeftCorner.X, pos.LowerRightCorner.Y), pos.UpperLeftCorner, color);
-}
-
-
 //! Draw a 2d rectangle
 void CNullDriver::draw2DRectangle(SColor color, const core::rect<s32>& pos, const core::rect<s32>* clip)
 {
@@ -877,38 +821,6 @@ void CNullDriver::draw2DLine(const core::position2d<s32>& start,
 {
 }
 
-//! Draws a pixel
-void CNullDriver::drawPixel(u32 x, u32 y, const SColor & color)
-{
-}
-
-
-//! Draws a non filled concyclic regular 2d polygon.
-void CNullDriver::draw2DPolygon(core::position2d<s32> center,
-	f32 radius, video::SColor color, s32 count)
-{
-	if (count < 2)
-		return;
-
-	core::position2d<s32> first;
-	core::position2d<s32> a,b;
-
-	for (s32 j=0; j<count; ++j)
-	{
-		b = a;
-
-		f32 p = j / (f32)count * (core::PI*2);
-		a = center + core::position2d<s32>((s32)(sin(p)*radius), (s32)(cos(p)*radius));
-
-		if (j==0)
-			first = a;
-		else
-			draw2DLine(a, b, color);
-	}
-
-	draw2DLine(a, first, color);
-}
-
 
 //! returns color format
 ECOLOR_FORMAT CNullDriver::getColorFormat() const
@@ -979,25 +891,6 @@ const wchar_t* CNullDriver::getName() const
 }
 
 
-
-//! Draws a shadow volume into the stencil buffer. To draw a stencil shadow, do
-//! this: First, draw all geometry. Then use this method, to draw the shadow
-//! volume. Then, use IVideoDriver::drawStencilShadow() to visualize the shadow.
-void CNullDriver::drawStencilShadowVolume(const core::array<core::vector3df>& triangles, bool zfail, u32 debugDataVisible)
-{
-}
-
-
-//! Fills the stencil shadow with color. After the shadow volume has been drawn
-//! into the stencil buffer using IVideoDriver::drawStencilShadowVolume(), use this
-//! to draw the color of the shadow.
-void CNullDriver::drawStencilShadow(bool clearStencilBuffer,
-		video::SColor leftUpEdge, video::SColor rightUpEdge,
-		video::SColor leftDownEdge, video::SColor rightDownEdge)
-{
-}
-
-
 //! Creates a boolean alpha channel of the texture based of an color key.
 void CNullDriver::makeColorKeyTexture(video::ITexture* texture,
 									video::SColor color,
diff --git a/source/Irrlicht/CNullDriver.h b/source/Irrlicht/CNullDriver.h
index 625ff1a..e6b27d8 100644
--- a/source/Irrlicht/CNullDriver.h
+++ b/source/Irrlicht/CNullDriver.h
@@ -126,9 +126,8 @@ namespace video
 		virtual void draw3DLine(const core::vector3df& start,
 			const core::vector3df& end, SColor color = SColor(255,255,255,255)) override;
 
-		//! Draws a 3d triangle.
-		virtual void draw3DTriangle(const core::triangle3df& triangle,
-			SColor color = SColor(255,255,255,255)) override;
+		[[deprecated]] virtual void draw3DTriangle(const core::triangle3df& triangle,
+			SColor color = SColor(255,255,255,255)) {}
 
 		//! Draws a 3d axis aligned box.
 		virtual void draw3DBox(const core::aabbox3d<f32>& box,
@@ -154,14 +153,14 @@ namespace video
 		Note that the alpha component is used: If alpha is other than 255, the image will be transparent.
 		\param useAlphaChannelOfTexture: If true, the alpha channel of the texture is
 		used to draw the image. */
-		virtual void draw2DImageBatch(const video::ITexture* texture,
+		[[deprecated]] virtual void draw2DImageBatch(const video::ITexture* texture,
 				const core::position2d<s32>& pos,
 				const core::array<core::rect<s32> >& sourceRects,
 				const core::array<s32>& indices,
 				s32 kerningWidth = 0,
 				const core::rect<s32>* clipRect = 0,
 				SColor color=SColor(255,255,255,255),
-				bool useAlphaChannelOfTexture=false) override;
+				bool useAlphaChannelOfTexture=false) {}
 
 		//! Draws a set of 2d images, using a color and the alpha channel of the texture.
 		/** All drawings are clipped against clipRect (if != 0).
@@ -205,7 +204,7 @@ namespace video
 			const core::rect<s32>* clip = 0) override;
 
 		//! Draws the outline of a 2d rectangle
-		void draw2DRectangleOutline(const core::recti& pos, SColor color=SColor(255,255,255,255)) override;
+		[[deprecated]] virtual void draw2DRectangleOutline(const core::recti& pos, SColor color=SColor(255,255,255,255)) {}
 
 		//! Draws a 2d line.
 		virtual void draw2DLine(const core::position2d<s32>& start,
@@ -213,11 +212,11 @@ namespace video
 					SColor color=SColor(255,255,255,255)) override;
 
 		//! Draws a pixel
-		void drawPixel(u32 x, u32 y, const SColor & color) override;
+		[[deprecated]] virtual void drawPixel(u32 x, u32 y, const SColor & color) {}
 
 		//! Draws a non filled concyclic reqular 2d polygon.
-		virtual void draw2DPolygon(core::position2d<s32> center,
-			f32 radius, video::SColor Color, s32 vertexCount) override;
+		[[deprecated]] virtual void draw2DPolygon(core::position2d<s32> center,
+			f32 radius, video::SColor Color, s32 vertexCount) {}
 
 		virtual void setFog(SColor color=SColor(0,255,255,255),
 				E_FOG_TYPE fogType=EFT_FOG_LINEAR,
@@ -268,17 +267,17 @@ namespace video
 		//! Draws a shadow volume into the stencil buffer. To draw a stencil shadow, do
 		//! this: First, draw all geometry. Then use this method, to draw the shadow
 		//! volume. Then, use IVideoDriver::drawStencilShadow() to visualize the shadow.
-		virtual void drawStencilShadowVolume(const core::array<core::vector3df>& triangles,
-			bool zfail=true, u32 debugDataVisible=0) override;
+		[[deprecated]] virtual void drawStencilShadowVolume(const core::array<core::vector3df>& triangles,
+			bool zfail=true, u32 debugDataVisible=0) {}
 
 		//! Fills the stencil shadow with color. After the shadow volume has been drawn
 		//! into the stencil buffer using IVideoDriver::drawStencilShadowVolume(), use this
 		//! to draw the color of the shadow.
-		virtual void drawStencilShadow(bool clearStencilBuffer=false,
+		[[deprecated]] virtual void drawStencilShadow(bool clearStencilBuffer=false,
 			video::SColor leftUpEdge = video::SColor(0,0,0,0),
 			video::SColor rightUpEdge = video::SColor(0,0,0,0),
 			video::SColor leftDownEdge = video::SColor(0,0,0,0),
-			video::SColor rightDownEdge = video::SColor(0,0,0,0)) override;
+			video::SColor rightDownEdge = video::SColor(0,0,0,0)) {}
 
 
 		//! Removes a texture from the texture cache and deletes it, freeing lot of
diff --git a/source/Irrlicht/COGLESCoreExtensionHandler.h b/source/Irrlicht/COGLESCoreExtensionHandler.h
index ce6ea1d..1b4a2bb 100644
--- a/source/Irrlicht/COGLESCoreExtensionHandler.h
+++ b/source/Irrlicht/COGLESCoreExtensionHandler.h
@@ -2,13 +2,10 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in Irrlicht.h
 
-#ifndef __E_OGLES_CORE_EXTENSION_HANDLER_H_INCLUDED__
-#define __E_OGLES_CORE_EXTENSION_HANDLER_H_INCLUDED__
-
+#pragma once
 
 // Can be included from different ES versions
 // (this is also the reason why this file is header-only as correct OGL ES headers have to be included first)
-#if defined(_IRR_COMPILE_WITH_OGLES2_) || defined(_IRR_COMPILE_WITH_OGLES1_)
 
 #include "irrMath.h"
 #include "COpenGLCoreFeature.h"
@@ -773,6 +770,3 @@ namespace video
 	};
 }
 }
-
-#endif // defined(_IRR_COMPILE_WITH_OGLES2_) || defined(_IRR_COMPILE_WITH_OGLES1_)
-#endif // __E_OGLES_CORE_EXTENSION_HANDLER_H_INCLUDED__
diff --git a/source/Irrlicht/COpenGLCoreRenderTarget.h b/source/Irrlicht/COpenGLCoreRenderTarget.h
index 0dd08eb..f893c17 100644
--- a/source/Irrlicht/COpenGLCoreRenderTarget.h
+++ b/source/Irrlicht/COpenGLCoreRenderTarget.h
@@ -10,6 +10,14 @@
 
 #include "IRenderTarget.h"
 
+#ifndef GL_FRAMEBUFFER_INCOMPLETE_FORMATS
+#define GL_FRAMEBUFFER_INCOMPLETE_FORMATS GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT
+#endif
+
+#ifndef GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS
+#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT
+#endif
+
 namespace irr
 {
 namespace video
diff --git a/source/Irrlicht/COpenGLCoreTexture.h b/source/Irrlicht/COpenGLCoreTexture.h
index c19215b..2ad8af1 100644
--- a/source/Irrlicht/COpenGLCoreTexture.h
+++ b/source/Irrlicht/COpenGLCoreTexture.h
@@ -433,9 +433,6 @@ public:
 		else
 		{
 #ifdef IRR_OPENGL_HAS_glGenerateMipmap
-	#if !defined(IRR_COMPILE_GLES2_COMMON)
-			glEnable(GL_TEXTURE_2D);	// Hack some ATI cards need this glEnable according to https://www.khronos.org/opengl/wiki/Common_Mistakes
-	#endif
 			Driver->irrGlGenerateMipmap(TextureType);
 #endif
 		}
diff --git a/source/Irrlicht/Irrlicht.cpp b/source/Irrlicht/Irrlicht.cpp
index e598ec3..d1d2678 100644
--- a/source/Irrlicht/Irrlicht.cpp
+++ b/source/Irrlicht/Irrlicht.cpp
@@ -109,6 +109,9 @@ namespace video
 	{
 		switch (driver) {
 			case EDT_NULL: return true;
+#ifdef ENABLE_OPENGL3
+			case EDT_OPENGL3: return true;
+#endif
 #ifdef _IRR_COMPILE_WITH_OPENGL_
 			case EDT_OPENGL: return true;
 #endif
diff --git a/source/Irrlicht/OpenGL/Common.h b/source/Irrlicht/OpenGL/Common.h
new file mode 100644
index 0000000..4069307
--- /dev/null
+++ b/source/Irrlicht/OpenGL/Common.h
@@ -0,0 +1,36 @@
+// Copyright (C) 2023 Vitaliy Lobachevskiy
+// Copyright (C) 2015 Patryk Nadrowski
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#pragma once
+
+#define GL_GLEXT_PROTOTYPES
+#include <SDL_video.h>
+#include <SDL_opengl.h>
+
+namespace irr
+{
+namespace video
+{
+
+	// Forward declarations.
+
+	class COpenGLCoreFeature;
+
+	template <class TOpenGLDriver>
+	class COpenGLCoreTexture;
+
+	template <class TOpenGLDriver, class TOpenGLTexture>
+	class COpenGLCoreRenderTarget;
+
+	template <class TOpenGLDriver, class TOpenGLTexture>
+	class COpenGLCoreCacheHandler;
+
+	class COpenGL3DriverBase;
+	typedef COpenGLCoreTexture<COpenGL3DriverBase> COpenGL3Texture;
+	typedef COpenGLCoreRenderTarget<COpenGL3DriverBase, COpenGL3Texture> COpenGL3RenderTarget;
+	typedef COpenGLCoreCacheHandler<COpenGL3DriverBase, COpenGL3Texture> COpenGL3CacheHandler;
+
+}
+}
diff --git a/source/Irrlicht/OpenGL/Driver.cpp b/source/Irrlicht/OpenGL/Driver.cpp
new file mode 100644
index 0000000..641536f
--- /dev/null
+++ b/source/Irrlicht/OpenGL/Driver.cpp
@@ -0,0 +1,2389 @@
+// Copyright (C) 2023 Vitaliy Lobachevskiy
+// Copyright (C) 2014 Patryk Nadrowski
+// Copyright (C) 2009-2010 Amundis
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in Irrlicht.h
+
+#include "Driver.h"
+#include <cassert>
+#include "CNullDriver.h"
+#include "IContextManager.h"
+
+#include "COpenGLCoreTexture.h"
+#include "COpenGLCoreRenderTarget.h"
+#include "COpenGLCoreCacheHandler.h"
+
+#include "MaterialRenderer.h"
+#include "FixedPipelineRenderer.h"
+#include "Renderer2D.h"
+
+#include "EVertexAttributes.h"
+#include "CImage.h"
+#include "os.h"
+
+#ifdef _IRR_COMPILE_WITH_ANDROID_DEVICE_
+#include "android_native_app_glue.h"
+#endif
+
+#include "mt_opengl.h"
+
+namespace irr
+{
+namespace video
+{
+	struct VertexAttribute {
+		enum class Mode {
+			Regular,
+			Normalized,
+			Integral,
+		};
+		int Index;
+		int ComponentCount;
+		GLenum ComponentType;
+		Mode mode;
+		int Offset;
+	};
+
+	struct VertexType {
+		int VertexSize;
+		int AttributeCount;
+		VertexAttribute Attributes[];
+
+		VertexType(const VertexType &) = delete;
+		VertexType &operator= (const VertexType &) = delete;
+	};
+
+	static const VertexAttribute *begin(const VertexType &type)
+	{
+		return type.Attributes;
+	}
+
+	static const VertexAttribute *end(const VertexType &type)
+	{
+		return type.Attributes + type.AttributeCount;
+	}
+
+	static constexpr VertexType vtStandard = {
+		sizeof(S3DVertex), 4, {
+			{EVA_POSITION, 3, GL_FLOAT, VertexAttribute::Mode::Regular, offsetof(S3DVertex, Pos)},
+			{EVA_NORMAL, 3, GL_FLOAT, VertexAttribute::Mode::Regular, offsetof(S3DVertex, Normal)},
+			{EVA_COLOR, 4, GL_UNSIGNED_BYTE, VertexAttribute::Mode::Normalized, offsetof(S3DVertex, Color)},
+			{EVA_TCOORD0, 2, GL_FLOAT, VertexAttribute::Mode::Regular, offsetof(S3DVertex, TCoords)},
+		},
+	};
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winvalid-offsetof"
+
+	static constexpr VertexType vt2TCoords = {
+		sizeof(S3DVertex2TCoords), 5, {
+			{EVA_POSITION, 3, GL_FLOAT, VertexAttribute::Mode::Regular, offsetof(S3DVertex2TCoords, Pos)},
+			{EVA_NORMAL, 3, GL_FLOAT, VertexAttribute::Mode::Regular, offsetof(S3DVertex2TCoords, Normal)},
+			{EVA_COLOR, 4, GL_UNSIGNED_BYTE, VertexAttribute::Mode::Normalized, offsetof(S3DVertex2TCoords, Color)},
+			{EVA_TCOORD0, 2, GL_FLOAT, VertexAttribute::Mode::Regular, offsetof(S3DVertex2TCoords, TCoords)},
+			{EVA_TCOORD1, 2, GL_FLOAT, VertexAttribute::Mode::Regular, offsetof(S3DVertex2TCoords, TCoords2)},
+		},
+	};
+
+	static constexpr VertexType vtTangents = {
+		sizeof(S3DVertexTangents), 6, {
+			{EVA_POSITION, 3, GL_FLOAT, VertexAttribute::Mode::Regular, offsetof(S3DVertexTangents, Pos)},
+			{EVA_NORMAL, 3, GL_FLOAT, VertexAttribute::Mode::Regular, offsetof(S3DVertexTangents, Normal)},
+			{EVA_COLOR, 4, GL_UNSIGNED_BYTE, VertexAttribute::Mode::Normalized, offsetof(S3DVertexTangents, Color)},
+			{EVA_TCOORD0, 2, GL_FLOAT, VertexAttribute::Mode::Regular, offsetof(S3DVertexTangents, TCoords)},
+			{EVA_TANGENT, 3, GL_FLOAT, VertexAttribute::Mode::Regular, offsetof(S3DVertexTangents, Tangent)},
+			{EVA_BINORMAL, 3, GL_FLOAT, VertexAttribute::Mode::Regular, offsetof(S3DVertexTangents, Binormal)},
+		},
+	};
+
+#pragma GCC diagnostic pop
+
+	static const VertexType &getVertexTypeDescription(E_VERTEX_TYPE type)
+	{
+		switch (type) {
+			case EVT_STANDARD: return vtStandard;
+			case EVT_2TCOORDS: return vt2TCoords;
+			case EVT_TANGENTS: return vtTangents;
+			default: assert(false);
+		}
+	}
+
+	static constexpr VertexType vt2DImage = {
+		sizeof(S3DVertex), 3, {
+			{EVA_POSITION, 3, GL_FLOAT, VertexAttribute::Mode::Regular, offsetof(S3DVertex, Pos)},
+			{EVA_COLOR, 4, GL_UNSIGNED_BYTE, VertexAttribute::Mode::Normalized, offsetof(S3DVertex, Color)},
+			{EVA_TCOORD0, 2, GL_FLOAT, VertexAttribute::Mode::Regular, offsetof(S3DVertex, TCoords)},
+		},
+	};
+
+	static constexpr VertexType vtPrimitive = {
+		sizeof(S3DVertex), 2, {
+			{EVA_POSITION, 3, GL_FLOAT, VertexAttribute::Mode::Regular, offsetof(S3DVertex, Pos)},
+			{EVA_COLOR, 4, GL_UNSIGNED_BYTE, VertexAttribute::Mode::Normalized, offsetof(S3DVertex, Color)},
+		},
+	};
+
+
+void APIENTRY COpenGL3DriverBase::debugCb(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam)
+{
+	((COpenGL3DriverBase *)userParam)->debugCb(source, type, id, severity, length, message);
+}
+
+void COpenGL3DriverBase::debugCb(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message)
+{
+	printf("%04x %04x %x %x %.*s\n", source, type, id, severity, length, message);
+}
+
+COpenGL3DriverBase::COpenGL3DriverBase(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager) :
+	CNullDriver(io, params.WindowSize), COpenGL3ExtensionHandler(), CacheHandler(0),
+	Params(params), ResetRenderStates(true), LockRenderStateMode(false), AntiAlias(params.AntiAlias),
+	MaterialRenderer2DActive(0), MaterialRenderer2DTexture(0), MaterialRenderer2DNoTexture(0),
+	CurrentRenderMode(ERM_NONE), Transformation3DChanged(true),
+	OGLES2ShaderPath(params.OGLES2ShaderPath),
+	ColorFormat(ECF_R8G8B8), ContextManager(contextManager)
+{
+#ifdef _DEBUG
+	setDebugName("Driver");
+#endif
+
+	if (!ContextManager)
+		return;
+
+	ContextManager->grab();
+	ContextManager->generateSurface();
+	ContextManager->generateContext();
+	ExposedData = ContextManager->getContext();
+	ContextManager->activateContext(ExposedData, false);
+	GL.LoadAllProcedures(ContextManager);
+	GL.DebugMessageCallback(debugCb, this);
+	initQuadsIndices();
+}
+
+COpenGL3DriverBase::~COpenGL3DriverBase()
+{
+	deleteMaterialRenders();
+
+	CacheHandler->getTextureCache().clear();
+
+	removeAllRenderTargets();
+	deleteAllTextures();
+	removeAllOcclusionQueries();
+	removeAllHardwareBuffers();
+
+	delete MaterialRenderer2DTexture;
+	delete MaterialRenderer2DNoTexture;
+	delete CacheHandler;
+
+	if (ContextManager)
+	{
+		ContextManager->destroyContext();
+		ContextManager->destroySurface();
+		ContextManager->terminate();
+		ContextManager->drop();
+	}
+}
+
+	void COpenGL3DriverBase::initQuadsIndices(int max_vertex_count)
+	{
+		int max_quad_count = max_vertex_count / 4;
+		QuadsIndices.reserve(6 * max_quad_count);
+		for (int k = 0; k < max_quad_count; k++) {
+			QuadsIndices.push_back(4 * k + 0);
+			QuadsIndices.push_back(4 * k + 1);
+			QuadsIndices.push_back(4 * k + 2);
+			QuadsIndices.push_back(4 * k + 0);
+			QuadsIndices.push_back(4 * k + 2);
+			QuadsIndices.push_back(4 * k + 3);
+		}
+	}
+
+	bool COpenGL3DriverBase::genericDriverInit(const core::dimension2d<u32>& screenSize, bool stencilBuffer)
+	{
+		Name = glGetString(GL_VERSION);
+		printVersion();
+
+		// print renderer information
+		VendorName = glGetString(GL_VENDOR);
+		os::Printer::log(VendorName.c_str(), ELL_INFORMATION);
+
+		// load extensions
+		initExtensions();
+
+		// reset cache handler
+		delete CacheHandler;
+		CacheHandler = new COpenGL3CacheHandler(this);
+
+		StencilBuffer = stencilBuffer;
+
+		DriverAttributes->setAttribute("MaxTextures", (s32)Feature.MaxTextureUnits);
+		DriverAttributes->setAttribute("MaxSupportedTextures", (s32)Feature.MaxTextureUnits);
+//		DriverAttributes->setAttribute("MaxLights", MaxLights);
+		DriverAttributes->setAttribute("MaxAnisotropy", MaxAnisotropy);
+//		DriverAttributes->setAttribute("MaxUserClipPlanes", MaxUserClipPlanes);
+//		DriverAttributes->setAttribute("MaxAuxBuffers", MaxAuxBuffers);
+//		DriverAttributes->setAttribute("MaxMultipleRenderTargets", MaxMultipleRenderTargets);
+		DriverAttributes->setAttribute("MaxIndices", (s32)MaxIndices);
+		DriverAttributes->setAttribute("MaxTextureSize", (s32)MaxTextureSize);
+		DriverAttributes->setAttribute("MaxTextureLODBias", MaxTextureLODBias);
+		DriverAttributes->setAttribute("Version", Version);
+		DriverAttributes->setAttribute("AntiAlias", AntiAlias);
+
+		glPixelStorei(GL_PACK_ALIGNMENT, 1);
+
+		UserClipPlane.reallocate(0);
+
+		for (s32 i = 0; i < ETS_COUNT; ++i)
+			setTransform(static_cast<E_TRANSFORMATION_STATE>(i), core::IdentityMatrix);
+
+		setAmbientLight(SColorf(0.0f, 0.0f, 0.0f, 0.0f));
+		glClearDepthf(1.0f);
+
+		glHint(GL_GENERATE_MIPMAP_HINT, GL_NICEST);
+		glFrontFace(GL_CW);
+
+		// create material renderers
+		createMaterialRenderers();
+
+		// set the renderstates
+		setRenderStates3DMode();
+
+		// set fog mode
+		setFog(FogColor, FogType, FogStart, FogEnd, FogDensity, PixelFog, RangeFog);
+
+		// create matrix for flipping textures
+		TextureFlipMatrix.buildTextureTransform(0.0f, core::vector2df(0, 0), core::vector2df(0, 1.0f), core::vector2df(1.0f, -1.0f));
+
+		// We need to reset once more at the beginning of the first rendering.
+		// This fixes problems with intermediate changes to the material during texture load.
+		ResetRenderStates = true;
+
+		testGLError(__LINE__);
+
+		return true;
+	}
+
+	void COpenGL3DriverBase::loadShaderData(const io::path& vertexShaderName, const io::path& fragmentShaderName, c8** vertexShaderData, c8** fragmentShaderData)
+	{
+		io::path vsPath(OGLES2ShaderPath);
+		vsPath += vertexShaderName;
+
+		io::path fsPath(OGLES2ShaderPath);
+		fsPath += fragmentShaderName;
+
+		*vertexShaderData = 0;
+		*fragmentShaderData = 0;
+
+		io::IReadFile* vsFile = FileSystem->createAndOpenFile(vsPath);
+		if ( !vsFile )
+		{
+			core::stringw warning(L"Warning: Missing shader files needed to simulate fixed function materials:\n");
+			warning += core::stringw(vsPath) + L"\n";
+			warning += L"Shaderpath can be changed in SIrrCreationParamters::OGLES2ShaderPath";
+			os::Printer::log(warning.c_str(), ELL_WARNING);
+			return;
+		}
+
+		io::IReadFile* fsFile = FileSystem->createAndOpenFile(fsPath);
+		if ( !fsFile )
+		{
+			core::stringw warning(L"Warning: Missing shader files needed to simulate fixed function materials:\n");
+			warning += core::stringw(fsPath) + L"\n";
+			warning += L"Shaderpath can be changed in SIrrCreationParamters::OGLES2ShaderPath";
+			os::Printer::log(warning.c_str(), ELL_WARNING);
+			return;
+		}
+
+		long size = vsFile->getSize();
+		if (size)
+		{
+			*vertexShaderData = new c8[size+1];
+			vsFile->read(*vertexShaderData, size);
+			(*vertexShaderData)[size] = 0;
+		}
+
+		size = fsFile->getSize();
+		if (size)
+		{
+			// if both handles are the same we must reset the file
+			if (fsFile == vsFile)
+				fsFile->seek(0);
+
+			*fragmentShaderData = new c8[size+1];
+			fsFile->read(*fragmentShaderData, size);
+			(*fragmentShaderData)[size] = 0;
+		}
+
+		vsFile->drop();
+		fsFile->drop();
+	}
+
+	void COpenGL3DriverBase::createMaterialRenderers()
+	{
+		// Create callbacks.
+
+		COpenGL3MaterialSolidCB* SolidCB = new COpenGL3MaterialSolidCB();
+		COpenGL3MaterialSolid2CB* Solid2LayerCB = new COpenGL3MaterialSolid2CB();
+		COpenGL3MaterialLightmapCB* LightmapCB = new COpenGL3MaterialLightmapCB(1.f);
+		COpenGL3MaterialLightmapCB* LightmapAddCB = new COpenGL3MaterialLightmapCB(1.f);
+		COpenGL3MaterialLightmapCB* LightmapM2CB = new COpenGL3MaterialLightmapCB(2.f);
+		COpenGL3MaterialLightmapCB* LightmapM4CB = new COpenGL3MaterialLightmapCB(4.f);
+		COpenGL3MaterialLightmapCB* LightmapLightingCB = new COpenGL3MaterialLightmapCB(1.f);
+		COpenGL3MaterialLightmapCB* LightmapLightingM2CB = new COpenGL3MaterialLightmapCB(2.f);
+		COpenGL3MaterialLightmapCB* LightmapLightingM4CB = new COpenGL3MaterialLightmapCB(4.f);
+		COpenGL3MaterialSolid2CB* DetailMapCB = new COpenGL3MaterialSolid2CB();
+		COpenGL3MaterialReflectionCB* SphereMapCB = new COpenGL3MaterialReflectionCB();
+		COpenGL3MaterialReflectionCB* Reflection2LayerCB = new COpenGL3MaterialReflectionCB();
+		COpenGL3MaterialSolidCB* TransparentAddColorCB = new COpenGL3MaterialSolidCB();
+		COpenGL3MaterialSolidCB* TransparentAlphaChannelCB = new COpenGL3MaterialSolidCB();
+		COpenGL3MaterialSolidCB* TransparentAlphaChannelRefCB = new COpenGL3MaterialSolidCB();
+		COpenGL3MaterialSolidCB* TransparentVertexAlphaCB = new COpenGL3MaterialSolidCB();
+		COpenGL3MaterialReflectionCB* TransparentReflection2LayerCB = new COpenGL3MaterialReflectionCB();
+		COpenGL3MaterialOneTextureBlendCB* OneTextureBlendCB = new COpenGL3MaterialOneTextureBlendCB();
+
+		// Create built-in materials.
+
+		core::stringc VertexShader = OGLES2ShaderPath + "Solid.vsh";
+		core::stringc FragmentShader = OGLES2ShaderPath + "Solid.fsh";
+
+		addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",
+			EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, SolidCB, EMT_SOLID, 0);
+
+		VertexShader = OGLES2ShaderPath + "Solid2.vsh";
+		FragmentShader = OGLES2ShaderPath + "Solid2Layer.fsh";
+
+		addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",
+			EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, Solid2LayerCB, EMT_SOLID, 0);
+
+		VertexShader = OGLES2ShaderPath + "Solid2.vsh";
+		FragmentShader = OGLES2ShaderPath + "LightmapModulate.fsh";
+
+		addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",
+			EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, LightmapCB, EMT_SOLID, 0);
+
+		FragmentShader = OGLES2ShaderPath + "LightmapAdd.fsh";
+
+		addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",
+			EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, LightmapAddCB, EMT_SOLID, 0);
+
+		FragmentShader = OGLES2ShaderPath + "LightmapModulate.fsh";
+
+		addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",
+			EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, LightmapM2CB, EMT_SOLID, 0);
+
+		addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",
+			EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, LightmapM4CB, EMT_SOLID, 0);
+
+		addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",
+			EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, LightmapLightingCB, EMT_SOLID, 0);
+
+		addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",
+			EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, LightmapLightingM2CB, EMT_SOLID, 0);
+
+		addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",
+			EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, LightmapLightingM4CB, EMT_SOLID, 0);
+
+		VertexShader = OGLES2ShaderPath + "Solid2.vsh";
+		FragmentShader = OGLES2ShaderPath + "DetailMap.fsh";
+
+		addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",
+			EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, DetailMapCB, EMT_SOLID, 0);
+
+		VertexShader = OGLES2ShaderPath + "SphereMap.vsh";
+		FragmentShader = OGLES2ShaderPath + "SphereMap.fsh";
+
+		addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",
+			EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, SphereMapCB, EMT_SOLID, 0);
+
+		VertexShader = OGLES2ShaderPath + "Reflection2Layer.vsh";
+		FragmentShader = OGLES2ShaderPath + "Reflection2Layer.fsh";
+
+		addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",
+			EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, Reflection2LayerCB, EMT_SOLID, 0);
+
+		VertexShader = OGLES2ShaderPath + "Solid.vsh";
+		FragmentShader = OGLES2ShaderPath + "Solid.fsh";
+
+		addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",
+			EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, TransparentAddColorCB, EMT_TRANSPARENT_ADD_COLOR, 0);
+
+		FragmentShader = OGLES2ShaderPath + "TransparentAlphaChannel.fsh";
+		addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",
+			EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, TransparentAlphaChannelCB, EMT_TRANSPARENT_ALPHA_CHANNEL, 0);
+
+		FragmentShader = OGLES2ShaderPath + "TransparentAlphaChannelRef.fsh";
+
+		addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",
+			EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, TransparentAlphaChannelRefCB, EMT_SOLID, 0);
+
+		FragmentShader = OGLES2ShaderPath + "TransparentVertexAlpha.fsh";
+
+		addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",
+			EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, TransparentVertexAlphaCB, EMT_TRANSPARENT_ALPHA_CHANNEL, 0);
+
+		VertexShader = OGLES2ShaderPath + "Reflection2Layer.vsh";
+		FragmentShader = OGLES2ShaderPath + "Reflection2Layer.fsh";
+
+		addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",
+			EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, TransparentReflection2LayerCB, EMT_TRANSPARENT_ALPHA_CHANNEL, 0);
+
+		VertexShader = OGLES2ShaderPath + "Solid.vsh";
+		FragmentShader = OGLES2ShaderPath + "OneTextureBlend.fsh";
+
+		addHighLevelShaderMaterialFromFiles(VertexShader, "main", EVST_VS_2_0, FragmentShader, "main", EPST_PS_2_0, "", "main",
+			EGST_GS_4_0, scene::EPT_TRIANGLES, scene::EPT_TRIANGLE_STRIP, 0, OneTextureBlendCB, EMT_ONETEXTURE_BLEND, 0);
+
+		// Drop callbacks.
+
+		SolidCB->drop();
+		Solid2LayerCB->drop();
+		LightmapCB->drop();
+		LightmapAddCB->drop();
+		LightmapM2CB->drop();
+		LightmapM4CB->drop();
+		LightmapLightingCB->drop();
+		LightmapLightingM2CB->drop();
+		LightmapLightingM4CB->drop();
+		DetailMapCB->drop();
+		SphereMapCB->drop();
+		Reflection2LayerCB->drop();
+		TransparentAddColorCB->drop();
+		TransparentAlphaChannelCB->drop();
+		TransparentAlphaChannelRefCB->drop();
+		TransparentVertexAlphaCB->drop();
+		TransparentReflection2LayerCB->drop();
+		OneTextureBlendCB->drop();
+
+		// Create 2D material renderers
+
+		c8* vs2DData = 0;
+		c8* fs2DData = 0;
+		loadShaderData(io::path("Renderer2D.vsh"), io::path("Renderer2D.fsh"), &vs2DData, &fs2DData);
+		MaterialRenderer2DTexture = new COpenGL3Renderer2D(vs2DData, fs2DData, this, true);
+		delete[] vs2DData;
+		delete[] fs2DData;
+		vs2DData = 0;
+		fs2DData = 0;
+
+		loadShaderData(io::path("Renderer2D.vsh"), io::path("Renderer2D_noTex.fsh"), &vs2DData, &fs2DData);
+		MaterialRenderer2DNoTexture = new COpenGL3Renderer2D(vs2DData, fs2DData, this, false);
+		delete[] vs2DData;
+		delete[] fs2DData;
+	}
+
+	bool COpenGL3DriverBase::setMaterialTexture(irr::u32 layerIdx, const irr::video::ITexture* texture)
+	{
+		Material.TextureLayer[layerIdx].Texture = const_cast<ITexture*>(texture); // function uses const-pointer for texture because all draw functions use const-pointers already
+		return CacheHandler->getTextureCache().set(0, texture);
+	}
+
+	bool COpenGL3DriverBase::beginScene(u16 clearFlag, SColor clearColor, f32 clearDepth, u8 clearStencil, const SExposedVideoData& videoData, core::rect<s32>* sourceRect)
+	{
+		CNullDriver::beginScene(clearFlag, clearColor, clearDepth, clearStencil, videoData, sourceRect);
+
+		if (ContextManager)
+			ContextManager->activateContext(videoData, true);
+
+		clearBuffers(clearFlag, clearColor, clearDepth, clearStencil);
+
+		return true;
+	}
+
+	bool COpenGL3DriverBase::endScene()
+	{
+		CNullDriver::endScene();
+
+		glFlush();
+
+		if (ContextManager)
+			return ContextManager->swapBuffers();
+
+		return false;
+	}
+
+
+	//! Returns the transformation set by setTransform
+	const core::matrix4& COpenGL3DriverBase::getTransform(E_TRANSFORMATION_STATE state) const
+	{
+		return Matrices[state];
+	}
+
+
+	//! sets transformation
+	void COpenGL3DriverBase::setTransform(E_TRANSFORMATION_STATE state, const core::matrix4& mat)
+	{
+		Matrices[state] = mat;
+		Transformation3DChanged = true;
+	}
+
+
+	bool COpenGL3DriverBase::updateVertexHardwareBuffer(SHWBufferLink_opengl *HWBuffer)
+	{
+		if (!HWBuffer)
+			return false;
+
+		const scene::IMeshBuffer* mb = HWBuffer->MeshBuffer;
+		const void* vertices = mb->getVertices();
+		const u32 vertexCount = mb->getVertexCount();
+		const E_VERTEX_TYPE vType = mb->getVertexType();
+		const u32 vertexSize = getVertexPitchFromType(vType);
+
+		const void *buffer = vertices;
+		size_t bufferSize = vertexSize * vertexCount;
+
+		//get or create buffer
+		bool newBuffer = false;
+		if (!HWBuffer->vbo_verticesID)
+		{
+			glGenBuffers(1, &HWBuffer->vbo_verticesID);
+			if (!HWBuffer->vbo_verticesID) return false;
+			newBuffer = true;
+		}
+		else if (HWBuffer->vbo_verticesSize < bufferSize)
+		{
+			newBuffer = true;
+		}
+
+		glBindBuffer(GL_ARRAY_BUFFER, HWBuffer->vbo_verticesID);
+
+		// copy data to graphics card
+		if (!newBuffer)
+			glBufferSubData(GL_ARRAY_BUFFER, 0, bufferSize, buffer);
+		else
+		{
+			HWBuffer->vbo_verticesSize = bufferSize;
+
+			if (HWBuffer->Mapped_Vertex == scene::EHM_STATIC)
+				glBufferData(GL_ARRAY_BUFFER, bufferSize, buffer, GL_STATIC_DRAW);
+			else
+				glBufferData(GL_ARRAY_BUFFER, bufferSize, buffer, GL_DYNAMIC_DRAW);
+		}
+
+		glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+		return (!testGLError(__LINE__));
+	}
+
+
+	bool COpenGL3DriverBase::updateIndexHardwareBuffer(SHWBufferLink_opengl *HWBuffer)
+	{
+		if (!HWBuffer)
+			return false;
+
+		const scene::IMeshBuffer* mb = HWBuffer->MeshBuffer;
+
+		const void* indices = mb->getIndices();
+		u32 indexCount = mb->getIndexCount();
+
+		GLenum indexSize;
+		switch (mb->getIndexType())
+		{
+			case(EIT_16BIT):
+			{
+				indexSize = sizeof(u16);
+				break;
+			}
+			case(EIT_32BIT):
+			{
+				indexSize = sizeof(u32);
+				break;
+			}
+			default:
+			{
+				return false;
+			}
+		}
+
+		//get or create buffer
+		bool newBuffer = false;
+		if (!HWBuffer->vbo_indicesID)
+		{
+			glGenBuffers(1, &HWBuffer->vbo_indicesID);
+			if (!HWBuffer->vbo_indicesID) return false;
+			newBuffer = true;
+		}
+		else if (HWBuffer->vbo_indicesSize < indexCount*indexSize)
+		{
+			newBuffer = true;
+		}
+
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, HWBuffer->vbo_indicesID);
+
+		// copy data to graphics card
+		if (!newBuffer)
+			glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, indexCount * indexSize, indices);
+		else
+		{
+			HWBuffer->vbo_indicesSize = indexCount * indexSize;
+
+			if (HWBuffer->Mapped_Index == scene::EHM_STATIC)
+				glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexCount * indexSize, indices, GL_STATIC_DRAW);
+			else
+				glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexCount * indexSize, indices, GL_DYNAMIC_DRAW);
+		}
+
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+
+		return (!testGLError(__LINE__));
+	}
+
+
+	//! updates hardware buffer if needed
+	bool COpenGL3DriverBase::updateHardwareBuffer(SHWBufferLink *HWBuffer)
+	{
+		if (!HWBuffer)
+			return false;
+
+		if (HWBuffer->Mapped_Vertex != scene::EHM_NEVER)
+		{
+			if (HWBuffer->ChangedID_Vertex != HWBuffer->MeshBuffer->getChangedID_Vertex()
+				|| !static_cast<SHWBufferLink_opengl*>(HWBuffer)->vbo_verticesID)
+			{
+
+				HWBuffer->ChangedID_Vertex = HWBuffer->MeshBuffer->getChangedID_Vertex();
+
+				if (!updateVertexHardwareBuffer(static_cast<SHWBufferLink_opengl*>(HWBuffer)))
+					return false;
+			}
+		}
+
+		if (HWBuffer->Mapped_Index != scene::EHM_NEVER)
+		{
+			if (HWBuffer->ChangedID_Index != HWBuffer->MeshBuffer->getChangedID_Index()
+				|| !static_cast<SHWBufferLink_opengl*>(HWBuffer)->vbo_indicesID)
+			{
+
+				HWBuffer->ChangedID_Index = HWBuffer->MeshBuffer->getChangedID_Index();
+
+				if (!updateIndexHardwareBuffer((SHWBufferLink_opengl*)HWBuffer))
+					return false;
+			}
+		}
+
+		return true;
+	}
+
+
+	//! Create hardware buffer from meshbuffer
+	COpenGL3DriverBase::SHWBufferLink *COpenGL3DriverBase::createHardwareBuffer(const scene::IMeshBuffer* mb)
+	{
+		if (!mb || (mb->getHardwareMappingHint_Index() == scene::EHM_NEVER && mb->getHardwareMappingHint_Vertex() == scene::EHM_NEVER))
+			return 0;
+
+		SHWBufferLink_opengl *HWBuffer = new SHWBufferLink_opengl(mb);
+
+		//add to map
+		HWBuffer->listPosition = HWBufferList.insert(HWBufferList.end(), HWBuffer);
+
+		HWBuffer->ChangedID_Vertex = HWBuffer->MeshBuffer->getChangedID_Vertex();
+		HWBuffer->ChangedID_Index = HWBuffer->MeshBuffer->getChangedID_Index();
+		HWBuffer->Mapped_Vertex = mb->getHardwareMappingHint_Vertex();
+		HWBuffer->Mapped_Index = mb->getHardwareMappingHint_Index();
+		HWBuffer->vbo_verticesID = 0;
+		HWBuffer->vbo_indicesID = 0;
+		HWBuffer->vbo_verticesSize = 0;
+		HWBuffer->vbo_indicesSize = 0;
+
+		if (!updateHardwareBuffer(HWBuffer))
+		{
+			deleteHardwareBuffer(HWBuffer);
+			return 0;
+		}
+
+		return HWBuffer;
+	}
+
+
+	void COpenGL3DriverBase::deleteHardwareBuffer(SHWBufferLink *_HWBuffer)
+	{
+		if (!_HWBuffer)
+			return;
+
+		SHWBufferLink_opengl *HWBuffer = static_cast<SHWBufferLink_opengl*>(_HWBuffer);
+		if (HWBuffer->vbo_verticesID)
+		{
+			glDeleteBuffers(1, &HWBuffer->vbo_verticesID);
+			HWBuffer->vbo_verticesID = 0;
+		}
+		if (HWBuffer->vbo_indicesID)
+		{
+			glDeleteBuffers(1, &HWBuffer->vbo_indicesID);
+			HWBuffer->vbo_indicesID = 0;
+		}
+
+		CNullDriver::deleteHardwareBuffer(_HWBuffer);
+	}
+
+
+	//! Draw hardware buffer
+	void COpenGL3DriverBase::drawHardwareBuffer(SHWBufferLink *_HWBuffer)
+	{
+		if (!_HWBuffer)
+			return;
+
+		SHWBufferLink_opengl *HWBuffer = static_cast<SHWBufferLink_opengl*>(_HWBuffer);
+
+		updateHardwareBuffer(HWBuffer); //check if update is needed
+
+		const scene::IMeshBuffer* mb = HWBuffer->MeshBuffer;
+		const void *vertices = mb->getVertices();
+		const void *indexList = mb->getIndices();
+
+		if (HWBuffer->Mapped_Vertex != scene::EHM_NEVER)
+		{
+			glBindBuffer(GL_ARRAY_BUFFER, HWBuffer->vbo_verticesID);
+			vertices = 0;
+		}
+
+		if (HWBuffer->Mapped_Index != scene::EHM_NEVER)
+		{
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, HWBuffer->vbo_indicesID);
+			indexList = 0;
+		}
+
+
+		drawVertexPrimitiveList(vertices, mb->getVertexCount(),
+				indexList, mb->getPrimitiveCount(),
+				mb->getVertexType(), mb->getPrimitiveType(),
+				mb->getIndexType());
+
+		if (HWBuffer->Mapped_Vertex != scene::EHM_NEVER)
+			glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+		if (HWBuffer->Mapped_Index != scene::EHM_NEVER)
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+	}
+
+
+	IRenderTarget* COpenGL3DriverBase::addRenderTarget()
+	{
+		COpenGL3RenderTarget* renderTarget = new COpenGL3RenderTarget(this);
+		RenderTargets.push_back(renderTarget);
+
+		return renderTarget;
+	}
+
+
+	// small helper function to create vertex buffer object adress offsets
+	static inline u8* buffer_offset(const long offset)
+	{
+		return ((u8*)0 + offset);
+	}
+
+
+	//! draws a vertex primitive list
+	void COpenGL3DriverBase::drawVertexPrimitiveList(const void* vertices, u32 vertexCount,
+			const void* indexList, u32 primitiveCount,
+			E_VERTEX_TYPE vType, scene::E_PRIMITIVE_TYPE pType, E_INDEX_TYPE iType)
+	{
+		if (!primitiveCount || !vertexCount)
+			return;
+
+		if (!checkPrimitiveCount(primitiveCount))
+			return;
+
+		CNullDriver::drawVertexPrimitiveList(vertices, vertexCount, indexList, primitiveCount, vType, pType, iType);
+
+		setRenderStates3DMode();
+
+		auto &vTypeDesc = getVertexTypeDescription(vType);
+		beginDraw(vTypeDesc, reinterpret_cast<uintptr_t>(vertices));
+		GLenum indexSize = 0;
+
+		switch (iType)
+		{
+			case(EIT_16BIT):
+			{
+				indexSize = GL_UNSIGNED_SHORT;
+				break;
+			}
+			case(EIT_32BIT):
+			{
+#ifdef GL_OES_element_index_uint
+#ifndef GL_UNSIGNED_INT
+#define GL_UNSIGNED_INT 0x1405
+#endif
+				if (FeatureAvailable[COGLESCoreExtensionHandler::IRR_GL_OES_element_index_uint])
+					indexSize = GL_UNSIGNED_INT;
+				else
+#endif
+					indexSize = GL_UNSIGNED_SHORT;
+				break;
+			}
+		}
+
+		switch (pType)
+		{
+			case scene::EPT_POINTS:
+			case scene::EPT_POINT_SPRITES:
+				glDrawArrays(GL_POINTS, 0, primitiveCount);
+				break;
+			case scene::EPT_LINE_STRIP:
+				glDrawElements(GL_LINE_STRIP, primitiveCount + 1, indexSize, indexList);
+				break;
+			case scene::EPT_LINE_LOOP:
+				glDrawElements(GL_LINE_LOOP, primitiveCount, indexSize, indexList);
+				break;
+			case scene::EPT_LINES:
+				glDrawElements(GL_LINES, primitiveCount*2, indexSize, indexList);
+				break;
+			case scene::EPT_TRIANGLE_STRIP:
+				glDrawElements(GL_TRIANGLE_STRIP, primitiveCount + 2, indexSize, indexList);
+				break;
+			case scene::EPT_TRIANGLE_FAN:
+				glDrawElements(GL_TRIANGLE_FAN, primitiveCount + 2, indexSize, indexList);
+				break;
+			case scene::EPT_TRIANGLES:
+				glDrawElements((LastMaterial.Wireframe) ? GL_LINES : (LastMaterial.PointCloud) ? GL_POINTS : GL_TRIANGLES, primitiveCount*3, indexSize, indexList);
+				break;
+			default:
+				break;
+		}
+
+		endDraw(vTypeDesc);
+	}
+
+
+	void COpenGL3DriverBase::draw2DImage(const video::ITexture* texture, const core::position2d<s32>& destPos,
+		const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect, SColor color,
+		bool useAlphaChannelOfTexture)
+	{
+		if (!texture)
+			return;
+
+		if (!sourceRect.isValid())
+			return;
+
+		SColor colors[4] = {color, color, color, color};
+		draw2DImage(texture, {destPos, sourceRect.getSize()}, sourceRect, clipRect, colors, useAlphaChannelOfTexture);
+	}
+
+
+	void COpenGL3DriverBase::draw2DImage(const video::ITexture* texture, const core::rect<s32>& destRect,
+		const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect,
+		const video::SColor* const colors, bool useAlphaChannelOfTexture)
+	{
+		if (!texture)
+			return;
+
+		// texcoords need to be flipped horizontally for RTTs
+		const bool isRTT = texture->isRenderTarget();
+		const core::dimension2du& ss = texture->getOriginalSize();
+		const f32 invW = 1.f / static_cast<f32>(ss.Width);
+		const f32 invH = 1.f / static_cast<f32>(ss.Height);
+		const core::rect<f32> tcoords(
+			sourceRect.UpperLeftCorner.X * invW,
+			(isRTT ? sourceRect.LowerRightCorner.Y : sourceRect.UpperLeftCorner.Y) * invH,
+			sourceRect.LowerRightCorner.X * invW,
+			(isRTT ? sourceRect.UpperLeftCorner.Y : sourceRect.LowerRightCorner.Y) *invH);
+
+		const video::SColor temp[4] =
+		{
+			0xFFFFFFFF,
+			0xFFFFFFFF,
+			0xFFFFFFFF,
+			0xFFFFFFFF
+		};
+
+		const video::SColor* const useColor = colors ? colors : temp;
+
+		chooseMaterial2D();
+		if (!setMaterialTexture(0, texture ))
+			return;
+
+		setRenderStates2DMode(useColor[0].getAlpha() < 255 || useColor[1].getAlpha() < 255 ||
+			useColor[2].getAlpha() < 255 || useColor[3].getAlpha() < 255,
+			true, useAlphaChannelOfTexture);
+
+		const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();
+
+		if (clipRect)
+		{
+			if (!clipRect->isValid())
+				return;
+
+			glEnable(GL_SCISSOR_TEST);
+			glScissor(clipRect->UpperLeftCorner.X, renderTargetSize.Height - clipRect->LowerRightCorner.Y,
+				clipRect->getWidth(), clipRect->getHeight());
+		}
+
+		f32 left = (f32)destRect.UpperLeftCorner.X / (f32)renderTargetSize.Width * 2.f - 1.f;
+		f32 right = (f32)destRect.LowerRightCorner.X / (f32)renderTargetSize.Width * 2.f - 1.f;
+		f32 down = 2.f - (f32)destRect.LowerRightCorner.Y / (f32)renderTargetSize.Height * 2.f - 1.f;
+		f32 top = 2.f - (f32)destRect.UpperLeftCorner.Y / (f32)renderTargetSize.Height * 2.f - 1.f;
+
+		S3DVertex vertices[4];
+		vertices[0] = S3DVertex(left, top, 0, 0, 0, 1, useColor[0], tcoords.UpperLeftCorner.X, tcoords.UpperLeftCorner.Y);
+		vertices[1] = S3DVertex(right, top, 0, 0, 0, 1, useColor[3], tcoords.LowerRightCorner.X, tcoords.UpperLeftCorner.Y);
+		vertices[2] = S3DVertex(right, down, 0, 0, 0, 1, useColor[2], tcoords.LowerRightCorner.X, tcoords.LowerRightCorner.Y);
+		vertices[3] = S3DVertex(left, down, 0, 0, 0, 1, useColor[1], tcoords.UpperLeftCorner.X, tcoords.LowerRightCorner.Y);
+
+		drawQuad(vt2DImage, vertices);
+
+		if (clipRect)
+			glDisable(GL_SCISSOR_TEST);
+
+		testGLError(__LINE__);
+	}
+
+	void COpenGL3DriverBase::draw2DImage(const video::ITexture* texture, u32 layer, bool flip)
+	{
+		if (!texture)
+			return;
+
+		chooseMaterial2D();
+		if (!setMaterialTexture(0, texture ))
+			return;
+
+		setRenderStates2DMode(false, true, true);
+
+		S3DVertex quad2DVertices[4];
+
+		quad2DVertices[0].Pos = core::vector3df(-1.f, 1.f, 0.f);
+		quad2DVertices[1].Pos = core::vector3df(1.f, 1.f, 0.f);
+		quad2DVertices[2].Pos = core::vector3df(1.f, -1.f, 0.f);
+		quad2DVertices[3].Pos = core::vector3df(-1.f, -1.f, 0.f);
+
+		f32 modificator = (flip) ? 1.f : 0.f;
+
+		quad2DVertices[0].TCoords = core::vector2df(0.f, 0.f + modificator);
+		quad2DVertices[1].TCoords = core::vector2df(1.f, 0.f + modificator);
+		quad2DVertices[2].TCoords = core::vector2df(1.f, 1.f - modificator);
+		quad2DVertices[3].TCoords = core::vector2df(0.f, 1.f - modificator);
+
+		quad2DVertices[0].Color = SColor(0xFFFFFFFF);
+		quad2DVertices[1].Color = SColor(0xFFFFFFFF);
+		quad2DVertices[2].Color = SColor(0xFFFFFFFF);
+		quad2DVertices[3].Color = SColor(0xFFFFFFFF);
+
+		drawQuad(vt2DImage, quad2DVertices);
+	}
+
+	void COpenGL3DriverBase::draw2DImageBatch(const video::ITexture* texture,
+			const core::array<core::position2d<s32> >& positions,
+			const core::array<core::rect<s32> >& sourceRects,
+			const core::rect<s32>* clipRect,
+			SColor color, bool useAlphaChannelOfTexture)
+	{
+		if (!texture)
+			return;
+
+		chooseMaterial2D();
+		if (!setMaterialTexture(0, texture))
+			return;
+
+		setRenderStates2DMode(color.getAlpha() < 255, true, useAlphaChannelOfTexture);
+
+		const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();
+
+		if (clipRect)
+		{
+			if (!clipRect->isValid())
+				return;
+
+			glEnable(GL_SCISSOR_TEST);
+			glScissor(clipRect->UpperLeftCorner.X, renderTargetSize.Height - clipRect->LowerRightCorner.Y,
+					clipRect->getWidth(), clipRect->getHeight());
+		}
+
+		const irr::u32 drawCount = core::min_<u32>(positions.size(), sourceRects.size());
+		assert(6 * std::size_t(drawCount) <= QuadsIndices.size());
+
+		core::array<S3DVertex> vtx(drawCount * 4);
+
+		for (u32 i = 0; i < drawCount; i++)
+		{
+			core::position2d<s32> targetPos = positions[i];
+			core::position2d<s32> sourcePos = sourceRects[i].UpperLeftCorner;
+			// This needs to be signed as it may go negative.
+			core::dimension2d<s32> sourceSize(sourceRects[i].getSize());
+
+			// now draw it.
+
+			core::rect<f32> tcoords;
+			tcoords.UpperLeftCorner.X = (((f32)sourcePos.X)) / texture->getOriginalSize().Width ;
+			tcoords.UpperLeftCorner.Y = (((f32)sourcePos.Y)) / texture->getOriginalSize().Height;
+			tcoords.LowerRightCorner.X = tcoords.UpperLeftCorner.X + ((f32)(sourceSize.Width) / texture->getOriginalSize().Width);
+			tcoords.LowerRightCorner.Y = tcoords.UpperLeftCorner.Y + ((f32)(sourceSize.Height) / texture->getOriginalSize().Height);
+
+			const core::rect<s32> poss(targetPos, sourceSize);
+
+			f32 left = (f32)poss.UpperLeftCorner.X / (f32)renderTargetSize.Width * 2.f - 1.f;
+			f32 right = (f32)poss.LowerRightCorner.X / (f32)renderTargetSize.Width * 2.f - 1.f;
+			f32 down = 2.f - (f32)poss.LowerRightCorner.Y / (f32)renderTargetSize.Height * 2.f - 1.f;
+			f32 top = 2.f - (f32)poss.UpperLeftCorner.Y / (f32)renderTargetSize.Height * 2.f - 1.f;
+
+			vtx.push_back(S3DVertex(left, top, 0.0f,
+					0.0f, 0.0f, 0.0f, color,
+					tcoords.UpperLeftCorner.X, tcoords.UpperLeftCorner.Y));
+			vtx.push_back(S3DVertex(right, top, 0.0f,
+					0.0f, 0.0f, 0.0f, color,
+					tcoords.LowerRightCorner.X, tcoords.UpperLeftCorner.Y));
+			vtx.push_back(S3DVertex(right, down, 0.0f,
+					0.0f, 0.0f, 0.0f, color,
+					tcoords.LowerRightCorner.X, tcoords.LowerRightCorner.Y));
+			vtx.push_back(S3DVertex(left, down, 0.0f,
+					0.0f, 0.0f, 0.0f, color,
+					tcoords.UpperLeftCorner.X, tcoords.LowerRightCorner.Y));
+		}
+
+		drawElements(GL_TRIANGLES, vt2DImage, vtx.const_pointer(), QuadsIndices.data(), 6 * drawCount);
+
+		if (clipRect)
+			glDisable(GL_SCISSOR_TEST);
+	}
+
+
+	//! draw a 2d rectangle
+	void COpenGL3DriverBase::draw2DRectangle(SColor color,
+			const core::rect<s32>& position,
+			const core::rect<s32>* clip)
+	{
+		chooseMaterial2D();
+		setMaterialTexture(0, 0);
+
+		setRenderStates2DMode(color.getAlpha() < 255, false, false);
+
+		core::rect<s32> pos = position;
+
+		if (clip)
+			pos.clipAgainst(*clip);
+
+		if (!pos.isValid())
+			return;
+
+		const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();
+
+		f32 left = (f32)pos.UpperLeftCorner.X / (f32)renderTargetSize.Width * 2.f - 1.f;
+		f32 right = (f32)pos.LowerRightCorner.X / (f32)renderTargetSize.Width * 2.f - 1.f;
+		f32 down = 2.f - (f32)pos.LowerRightCorner.Y / (f32)renderTargetSize.Height * 2.f - 1.f;
+		f32 top = 2.f - (f32)pos.UpperLeftCorner.Y / (f32)renderTargetSize.Height * 2.f - 1.f;
+
+		S3DVertex vertices[4];
+		vertices[0] = S3DVertex(left, top, 0, 0, 0, 1, color, 0, 0);
+		vertices[1] = S3DVertex(right, top, 0, 0, 0, 1, color, 0, 0);
+		vertices[2] = S3DVertex(right, down, 0, 0, 0, 1, color, 0, 0);
+		vertices[3] = S3DVertex(left, down, 0, 0, 0, 1, color, 0, 0);
+
+		drawQuad(vtPrimitive, vertices);
+	}
+
+
+	//! draw an 2d rectangle
+	void COpenGL3DriverBase::draw2DRectangle(const core::rect<s32>& position,
+			SColor colorLeftUp, SColor colorRightUp,
+			SColor colorLeftDown, SColor colorRightDown,
+			const core::rect<s32>* clip)
+	{
+		core::rect<s32> pos = position;
+
+		if (clip)
+			pos.clipAgainst(*clip);
+
+		if (!pos.isValid())
+			return;
+
+		chooseMaterial2D();
+		setMaterialTexture(0, 0);
+
+		setRenderStates2DMode(colorLeftUp.getAlpha() < 255 ||
+				colorRightUp.getAlpha() < 255 ||
+				colorLeftDown.getAlpha() < 255 ||
+				colorRightDown.getAlpha() < 255, false, false);
+
+		const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();
+
+		f32 left = (f32)pos.UpperLeftCorner.X / (f32)renderTargetSize.Width * 2.f - 1.f;
+		f32 right = (f32)pos.LowerRightCorner.X / (f32)renderTargetSize.Width * 2.f - 1.f;
+		f32 down = 2.f - (f32)pos.LowerRightCorner.Y / (f32)renderTargetSize.Height * 2.f - 1.f;
+		f32 top = 2.f - (f32)pos.UpperLeftCorner.Y / (f32)renderTargetSize.Height * 2.f - 1.f;
+
+		S3DVertex vertices[4];
+		vertices[0] = S3DVertex(left, top, 0, 0, 0, 1, colorLeftUp, 0, 0);
+		vertices[1] = S3DVertex(right, top, 0, 0, 0, 1, colorRightUp, 0, 0);
+		vertices[2] = S3DVertex(right, down, 0, 0, 0, 1, colorRightDown, 0, 0);
+		vertices[3] = S3DVertex(left, down, 0, 0, 0, 1, colorLeftDown, 0, 0);
+
+		drawQuad(vtPrimitive, vertices);
+	}
+
+
+	//! Draws a 2d line.
+	void COpenGL3DriverBase::draw2DLine(const core::position2d<s32>& start,
+			const core::position2d<s32>& end, SColor color)
+	{
+		if (start==end)
+			drawPixel(start.X, start.Y, color);
+		else
+		{
+			chooseMaterial2D();
+			setMaterialTexture(0, 0);
+
+			setRenderStates2DMode(color.getAlpha() < 255, false, false);
+
+			const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();
+
+			f32 startX = (f32)start.X / (f32)renderTargetSize.Width * 2.f - 1.f;
+			f32 endX = (f32)end.X / (f32)renderTargetSize.Width * 2.f - 1.f;
+			f32 startY = 2.f - (f32)start.Y / (f32)renderTargetSize.Height * 2.f - 1.f;
+			f32 endY = 2.f - (f32)end.Y / (f32)renderTargetSize.Height * 2.f - 1.f;
+
+			S3DVertex vertices[2];
+			vertices[0] = S3DVertex(startX, startY, 0, 0, 0, 1, color, 0, 0);
+			vertices[1] = S3DVertex(endX, endY, 0, 0, 0, 1, color, 1, 1);
+
+			drawArrays(GL_LINES, vtPrimitive, vertices, 2);
+		}
+	}
+
+
+	//! Draws a pixel
+	void COpenGL3DriverBase::drawPixel(u32 x, u32 y, const SColor &color)
+	{
+		const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();
+		if (x > (u32)renderTargetSize.Width || y > (u32)renderTargetSize.Height)
+			return;
+
+		chooseMaterial2D();
+		setMaterialTexture(0, 0);
+
+		setRenderStates2DMode(color.getAlpha() < 255, false, false);
+
+		f32 X = (f32)x / (f32)renderTargetSize.Width * 2.f - 1.f;
+		f32 Y = 2.f - (f32)y / (f32)renderTargetSize.Height * 2.f - 1.f;
+
+		S3DVertex vertices[1];
+		vertices[0] = S3DVertex(X, Y, 0, 0, 0, 1, color, 0, 0);
+
+		drawArrays(GL_POINTS, vtPrimitive, vertices, 1);
+	}
+
+	void COpenGL3DriverBase::drawQuad(const VertexType &vertexType, const S3DVertex (&vertices)[4])
+	{
+		drawArrays(GL_TRIANGLE_FAN, vertexType, vertices, 4);
+	}
+
+	void COpenGL3DriverBase::drawArrays(GLenum primitiveType, const VertexType &vertexType, const void *vertices, int vertexCount)
+	{
+		beginDraw(vertexType, reinterpret_cast<uintptr_t>(vertices));
+		glDrawArrays(primitiveType, 0, vertexCount);
+		endDraw(vertexType);
+	}
+
+	void COpenGL3DriverBase::drawElements(GLenum primitiveType, const VertexType &vertexType, const void *vertices, const u16 *indices, int indexCount)
+	{
+		beginDraw(vertexType, reinterpret_cast<uintptr_t>(vertices));
+		glDrawElements(primitiveType, indexCount, GL_UNSIGNED_SHORT, indices);
+		endDraw(vertexType);
+	}
+
+	void COpenGL3DriverBase::beginDraw(const VertexType &vertexType, uintptr_t verticesBase)
+	{
+		for (auto attr: vertexType) {
+			glEnableVertexAttribArray(attr.Index);
+			switch (attr.mode) {
+			case VertexAttribute::Mode::Regular: glVertexAttribPointer(attr.Index, attr.ComponentCount, attr.ComponentType, GL_FALSE, vertexType.VertexSize, reinterpret_cast<void *>(verticesBase + attr.Offset)); break;
+			case VertexAttribute::Mode::Normalized: glVertexAttribPointer(attr.Index, attr.ComponentCount, attr.ComponentType, GL_TRUE, vertexType.VertexSize, reinterpret_cast<void *>(verticesBase + attr.Offset)); break;
+			case VertexAttribute::Mode::Integral: glVertexAttribIPointer(attr.Index, attr.ComponentCount, attr.ComponentType, vertexType.VertexSize, reinterpret_cast<void *>(verticesBase + attr.Offset)); break;
+			}
+		}
+	}
+
+	void COpenGL3DriverBase::endDraw(const VertexType &vertexType)
+	{
+		for (auto attr: vertexType)
+			glDisableVertexAttribArray(attr.Index);
+	}
+
+	ITexture* COpenGL3DriverBase::createDeviceDependentTexture(const io::path& name, IImage* image)
+	{
+		core::array<IImage*> imageArray(1);
+		imageArray.push_back(image);
+
+		COpenGL3Texture* texture = new COpenGL3Texture(name, imageArray, ETT_2D, this);
+
+		return texture;
+	}
+
+	ITexture* COpenGL3DriverBase::createDeviceDependentTextureCubemap(const io::path& name, const core::array<IImage*>& image)
+	{
+		COpenGL3Texture* texture = new COpenGL3Texture(name, image, ETT_CUBEMAP, this);
+
+		return texture;
+	}
+
+	//! Sets a material.
+	void COpenGL3DriverBase::setMaterial(const SMaterial& material)
+	{
+		Material = material;
+		OverrideMaterial.apply(Material);
+
+		for (u32 i = 0; i < Feature.MaxTextureUnits; ++i)
+		{
+			CacheHandler->getTextureCache().set(i, material.getTexture(i));
+			setTransform((E_TRANSFORMATION_STATE)(ETS_TEXTURE_0 + i), material.getTextureMatrix(i));
+		}
+	}
+
+	//! prints error if an error happened.
+	bool COpenGL3DriverBase::testGLError(int code)
+	{
+#ifdef _DEBUG
+		GLenum g = glGetError();
+		switch (g)
+		{
+			case GL_NO_ERROR:
+				return false;
+			case GL_INVALID_ENUM:
+				os::Printer::log("GL_INVALID_ENUM", core::stringc(code).c_str(), ELL_ERROR);
+				break;
+			case GL_INVALID_VALUE:
+				os::Printer::log("GL_INVALID_VALUE", core::stringc(code).c_str(), ELL_ERROR);
+				break;
+			case GL_INVALID_OPERATION:
+				os::Printer::log("GL_INVALID_OPERATION", core::stringc(code).c_str(), ELL_ERROR);
+				break;
+			case GL_OUT_OF_MEMORY:
+				os::Printer::log("GL_OUT_OF_MEMORY", core::stringc(code).c_str(), ELL_ERROR);
+				break;
+		};
+		return true;
+#else
+		return false;
+#endif
+	}
+
+	//! prints error if an error happened.
+	bool COpenGL3DriverBase::testEGLError()
+	{
+#if defined(EGL_VERSION_1_0) && defined(_DEBUG)
+		EGLint g = eglGetError();
+		switch (g)
+		{
+			case EGL_SUCCESS:
+				return false;
+			case EGL_NOT_INITIALIZED :
+				os::Printer::log("Not Initialized", ELL_ERROR);
+				break;
+			case EGL_BAD_ACCESS:
+				os::Printer::log("Bad Access", ELL_ERROR);
+				break;
+			case EGL_BAD_ALLOC:
+				os::Printer::log("Bad Alloc", ELL_ERROR);
+				break;
+			case EGL_BAD_ATTRIBUTE:
+				os::Printer::log("Bad Attribute", ELL_ERROR);
+				break;
+			case EGL_BAD_CONTEXT:
+				os::Printer::log("Bad Context", ELL_ERROR);
+				break;
+			case EGL_BAD_CONFIG:
+				os::Printer::log("Bad Config", ELL_ERROR);
+				break;
+			case EGL_BAD_CURRENT_SURFACE:
+				os::Printer::log("Bad Current Surface", ELL_ERROR);
+				break;
+			case EGL_BAD_DISPLAY:
+				os::Printer::log("Bad Display", ELL_ERROR);
+				break;
+			case EGL_BAD_SURFACE:
+				os::Printer::log("Bad Surface", ELL_ERROR);
+				break;
+			case EGL_BAD_MATCH:
+				os::Printer::log("Bad Match", ELL_ERROR);
+				break;
+			case EGL_BAD_PARAMETER:
+				os::Printer::log("Bad Parameter", ELL_ERROR);
+				break;
+			case EGL_BAD_NATIVE_PIXMAP:
+				os::Printer::log("Bad Native Pixmap", ELL_ERROR);
+				break;
+			case EGL_BAD_NATIVE_WINDOW:
+				os::Printer::log("Bad Native Window", ELL_ERROR);
+				break;
+			case EGL_CONTEXT_LOST:
+				os::Printer::log("Context Lost", ELL_ERROR);
+				break;
+		};
+		return true;
+#else
+		return false;
+#endif
+	}
+
+
+	void COpenGL3DriverBase::setRenderStates3DMode()
+	{
+		if ( LockRenderStateMode )
+			return;
+
+		if (CurrentRenderMode != ERM_3D)
+		{
+			// Reset Texture Stages
+			CacheHandler->setBlend(false);
+			CacheHandler->setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+			ResetRenderStates = true;
+		}
+
+		if (ResetRenderStates || LastMaterial != Material)
+		{
+			// unset old material
+
+			// unset last 3d material
+			if (CurrentRenderMode == ERM_2D && MaterialRenderer2DActive)
+			{
+				MaterialRenderer2DActive->OnUnsetMaterial();
+				MaterialRenderer2DActive = 0;
+			}
+			else if (LastMaterial.MaterialType != Material.MaterialType &&
+					static_cast<u32>(LastMaterial.MaterialType) < MaterialRenderers.size())
+				MaterialRenderers[LastMaterial.MaterialType].Renderer->OnUnsetMaterial();
+
+			// set new material.
+			if (static_cast<u32>(Material.MaterialType) < MaterialRenderers.size())
+				MaterialRenderers[Material.MaterialType].Renderer->OnSetMaterial(
+					Material, LastMaterial, ResetRenderStates, this);
+
+			LastMaterial = Material;
+			CacheHandler->correctCacheMaterial(LastMaterial);
+			ResetRenderStates = false;
+		}
+
+		if (static_cast<u32>(Material.MaterialType) < MaterialRenderers.size())
+			MaterialRenderers[Material.MaterialType].Renderer->OnRender(this, video::EVT_STANDARD);
+
+		CurrentRenderMode = ERM_3D;
+	}
+
+	//! Can be called by an IMaterialRenderer to make its work easier.
+	void COpenGL3DriverBase::setBasicRenderStates(const SMaterial& material, const SMaterial& lastmaterial, bool resetAllRenderStates)
+	{
+		// ZBuffer
+		switch (material.ZBuffer)
+		{
+			case ECFN_DISABLED:
+				CacheHandler->setDepthTest(false);
+				break;
+			case ECFN_LESSEQUAL:
+				CacheHandler->setDepthTest(true);
+				CacheHandler->setDepthFunc(GL_LEQUAL);
+				break;
+			case ECFN_EQUAL:
+				CacheHandler->setDepthTest(true);
+				CacheHandler->setDepthFunc(GL_EQUAL);
+				break;
+			case ECFN_LESS:
+				CacheHandler->setDepthTest(true);
+				CacheHandler->setDepthFunc(GL_LESS);
+				break;
+			case ECFN_NOTEQUAL:
+				CacheHandler->setDepthTest(true);
+				CacheHandler->setDepthFunc(GL_NOTEQUAL);
+				break;
+			case ECFN_GREATEREQUAL:
+				CacheHandler->setDepthTest(true);
+				CacheHandler->setDepthFunc(GL_GEQUAL);
+				break;
+			case ECFN_GREATER:
+				CacheHandler->setDepthTest(true);
+				CacheHandler->setDepthFunc(GL_GREATER);
+				break;
+			case ECFN_ALWAYS:
+				CacheHandler->setDepthTest(true);
+				CacheHandler->setDepthFunc(GL_ALWAYS);
+				break;
+			case ECFN_NEVER:
+				CacheHandler->setDepthTest(true);
+				CacheHandler->setDepthFunc(GL_NEVER);
+				break;
+			default:
+				break;
+		}
+
+		// ZWrite
+		if (getWriteZBuffer(material))
+		{
+			CacheHandler->setDepthMask(true);
+		}
+		else
+		{
+			CacheHandler->setDepthMask(false);
+		}
+
+		// Back face culling
+		if ((material.FrontfaceCulling) && (material.BackfaceCulling))
+		{
+			CacheHandler->setCullFaceFunc(GL_FRONT_AND_BACK);
+			CacheHandler->setCullFace(true);
+		}
+		else if (material.BackfaceCulling)
+		{
+			CacheHandler->setCullFaceFunc(GL_BACK);
+			CacheHandler->setCullFace(true);
+		}
+		else if (material.FrontfaceCulling)
+		{
+			CacheHandler->setCullFaceFunc(GL_FRONT);
+			CacheHandler->setCullFace(true);
+		}
+		else
+		{
+			CacheHandler->setCullFace(false);
+		}
+
+		// Color Mask
+		CacheHandler->setColorMask(material.ColorMask);
+
+		// Blend Equation
+		if (material.BlendOperation == EBO_NONE)
+			CacheHandler->setBlend(false);
+		else
+		{
+			CacheHandler->setBlend(true);
+
+			switch (material.BlendOperation)
+			{
+			case EBO_ADD:
+				CacheHandler->setBlendEquation(GL_FUNC_ADD);
+				break;
+			case EBO_SUBTRACT:
+				CacheHandler->setBlendEquation(GL_FUNC_SUBTRACT);
+				break;
+			case EBO_REVSUBTRACT:
+				CacheHandler->setBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
+				break;
+			default:
+				break;
+			}
+		}
+
+		// Blend Factor
+		if (IR(material.BlendFactor) & 0xFFFFFFFF	// TODO: why the & 0xFFFFFFFF?
+			&& material.MaterialType != EMT_ONETEXTURE_BLEND
+		)
+		{
+		    E_BLEND_FACTOR srcRGBFact = EBF_ZERO;
+		    E_BLEND_FACTOR dstRGBFact = EBF_ZERO;
+		    E_BLEND_FACTOR srcAlphaFact = EBF_ZERO;
+		    E_BLEND_FACTOR dstAlphaFact = EBF_ZERO;
+		    E_MODULATE_FUNC modulo = EMFN_MODULATE_1X;
+		    u32 alphaSource = 0;
+
+		    unpack_textureBlendFuncSeparate(srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact, modulo, alphaSource, material.BlendFactor);
+
+			CacheHandler->setBlendFuncSeparate(getGLBlend(srcRGBFact), getGLBlend(dstRGBFact),
+				getGLBlend(srcAlphaFact), getGLBlend(dstAlphaFact));
+		}
+
+		// TODO: Polygon Offset. Not sure if it was left out deliberately or if it won't work with this driver.
+
+		if (resetAllRenderStates || lastmaterial.Thickness != material.Thickness)
+			glLineWidth(core::clamp(static_cast<GLfloat>(material.Thickness), DimAliasedLine[0], DimAliasedLine[1]));
+
+		// Anti aliasing
+		if (resetAllRenderStates || lastmaterial.AntiAliasing != material.AntiAliasing)
+		{
+			if (material.AntiAliasing & EAAM_ALPHA_TO_COVERAGE)
+				glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE);
+			else if (lastmaterial.AntiAliasing & EAAM_ALPHA_TO_COVERAGE)
+				glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
+		}
+
+		// Texture parameters
+		setTextureRenderStates(material, resetAllRenderStates);
+	}
+
+	//! Compare in SMaterial doesn't check texture parameters, so we should call this on each OnRender call.
+	void COpenGL3DriverBase::setTextureRenderStates(const SMaterial& material, bool resetAllRenderstates)
+	{
+		// Set textures to TU/TIU and apply filters to them
+
+		for (s32 i = Feature.MaxTextureUnits - 1; i >= 0; --i)
+		{
+			const COpenGL3Texture* tmpTexture = CacheHandler->getTextureCache()[i];
+
+			if (!tmpTexture)
+				continue;
+
+			GLenum tmpTextureType = tmpTexture->getOpenGLTextureType();
+
+			CacheHandler->setActiveTexture(GL_TEXTURE0 + i);
+
+			if (resetAllRenderstates)
+				tmpTexture->getStatesCache().IsCached = false;
+
+			if (!tmpTexture->getStatesCache().IsCached || material.TextureLayer[i].BilinearFilter != tmpTexture->getStatesCache().BilinearFilter ||
+				material.TextureLayer[i].TrilinearFilter != tmpTexture->getStatesCache().TrilinearFilter)
+			{
+				glTexParameteri(tmpTextureType, GL_TEXTURE_MAG_FILTER,
+					(material.TextureLayer[i].BilinearFilter || material.TextureLayer[i].TrilinearFilter) ? GL_LINEAR : GL_NEAREST);
+
+				tmpTexture->getStatesCache().BilinearFilter = material.TextureLayer[i].BilinearFilter;
+				tmpTexture->getStatesCache().TrilinearFilter = material.TextureLayer[i].TrilinearFilter;
+			}
+
+			if (material.UseMipMaps && tmpTexture->hasMipMaps())
+			{
+				if (!tmpTexture->getStatesCache().IsCached || material.TextureLayer[i].BilinearFilter != tmpTexture->getStatesCache().BilinearFilter ||
+					material.TextureLayer[i].TrilinearFilter != tmpTexture->getStatesCache().TrilinearFilter || !tmpTexture->getStatesCache().MipMapStatus)
+				{
+					glTexParameteri(tmpTextureType, GL_TEXTURE_MIN_FILTER,
+						material.TextureLayer[i].TrilinearFilter ? GL_LINEAR_MIPMAP_LINEAR :
+						material.TextureLayer[i].BilinearFilter ? GL_LINEAR_MIPMAP_NEAREST :
+						GL_NEAREST_MIPMAP_NEAREST);
+
+					tmpTexture->getStatesCache().BilinearFilter = material.TextureLayer[i].BilinearFilter;
+					tmpTexture->getStatesCache().TrilinearFilter = material.TextureLayer[i].TrilinearFilter;
+					tmpTexture->getStatesCache().MipMapStatus = true;
+				}
+			}
+			else
+			{
+				if (!tmpTexture->getStatesCache().IsCached || material.TextureLayer[i].BilinearFilter != tmpTexture->getStatesCache().BilinearFilter ||
+					material.TextureLayer[i].TrilinearFilter != tmpTexture->getStatesCache().TrilinearFilter || tmpTexture->getStatesCache().MipMapStatus)
+				{
+					glTexParameteri(tmpTextureType, GL_TEXTURE_MIN_FILTER,
+						(material.TextureLayer[i].BilinearFilter || material.TextureLayer[i].TrilinearFilter) ? GL_LINEAR : GL_NEAREST);
+
+					tmpTexture->getStatesCache().BilinearFilter = material.TextureLayer[i].BilinearFilter;
+					tmpTexture->getStatesCache().TrilinearFilter = material.TextureLayer[i].TrilinearFilter;
+					tmpTexture->getStatesCache().MipMapStatus = false;
+				}
+			}
+
+	#ifdef GL_EXT_texture_filter_anisotropic
+			if (FeatureAvailable[COGLESCoreExtensionHandler::IRR_GL_EXT_texture_filter_anisotropic] &&
+				(!tmpTexture->getStatesCache().IsCached || material.TextureLayer[i].AnisotropicFilter != tmpTexture->getStatesCache().AnisotropicFilter))
+			{
+				glTexParameteri(tmpTextureType, GL_TEXTURE_MAX_ANISOTROPY_EXT,
+					material.TextureLayer[i].AnisotropicFilter>1 ? core::min_(MaxAnisotropy, material.TextureLayer[i].AnisotropicFilter) : 1);
+
+				tmpTexture->getStatesCache().AnisotropicFilter = material.TextureLayer[i].AnisotropicFilter;
+			}
+	#endif
+
+			if (!tmpTexture->getStatesCache().IsCached || material.TextureLayer[i].TextureWrapU != tmpTexture->getStatesCache().WrapU)
+			{
+				glTexParameteri(tmpTextureType, GL_TEXTURE_WRAP_S, getTextureWrapMode(material.TextureLayer[i].TextureWrapU));
+				tmpTexture->getStatesCache().WrapU = material.TextureLayer[i].TextureWrapU;
+			}
+
+			if (!tmpTexture->getStatesCache().IsCached || material.TextureLayer[i].TextureWrapV != tmpTexture->getStatesCache().WrapV)
+			{
+				glTexParameteri(tmpTextureType, GL_TEXTURE_WRAP_T, getTextureWrapMode(material.TextureLayer[i].TextureWrapV));
+				tmpTexture->getStatesCache().WrapV = material.TextureLayer[i].TextureWrapV;
+			}
+
+			tmpTexture->getStatesCache().IsCached = true;
+		}
+	}
+
+
+	// Get OpenGL ES2.0 texture wrap mode from Irrlicht wrap mode.
+	GLint COpenGL3DriverBase::getTextureWrapMode(u8 clamp) const
+	{
+		switch (clamp)
+		{
+			case ETC_CLAMP:
+			case ETC_CLAMP_TO_EDGE:
+			case ETC_CLAMP_TO_BORDER:
+				return GL_CLAMP_TO_EDGE;
+			case ETC_MIRROR:
+				return GL_REPEAT;
+			default:
+				return GL_REPEAT;
+		}
+	}
+
+
+	//! sets the needed renderstates
+	void COpenGL3DriverBase::setRenderStates2DMode(bool alpha, bool texture, bool alphaChannel)
+	{
+		if ( LockRenderStateMode )
+			return;
+
+		COpenGL3Renderer2D* nextActiveRenderer = texture ? MaterialRenderer2DTexture : MaterialRenderer2DNoTexture;
+
+		if (CurrentRenderMode != ERM_2D)
+		{
+			// unset last 3d material
+			if (CurrentRenderMode == ERM_3D)
+			{
+				if (static_cast<u32>(LastMaterial.MaterialType) < MaterialRenderers.size())
+					MaterialRenderers[LastMaterial.MaterialType].Renderer->OnUnsetMaterial();
+			}
+
+			CurrentRenderMode = ERM_2D;
+		}
+		else if ( MaterialRenderer2DActive && MaterialRenderer2DActive != nextActiveRenderer)
+		{
+			MaterialRenderer2DActive->OnUnsetMaterial();
+		}
+
+		MaterialRenderer2DActive = nextActiveRenderer;
+
+		MaterialRenderer2DActive->OnSetMaterial(Material, LastMaterial, true, 0);
+		LastMaterial = Material;
+		CacheHandler->correctCacheMaterial(LastMaterial);
+
+		// no alphaChannel without texture
+		alphaChannel &= texture;
+
+		if (alphaChannel || alpha)
+		{
+			CacheHandler->setBlend(true);
+			CacheHandler->setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+			CacheHandler->setBlendEquation(GL_FUNC_ADD);
+		}
+		else
+			CacheHandler->setBlend(false);
+
+		Material.setTexture(0, const_cast<COpenGL3Texture*>(CacheHandler->getTextureCache().get(0)));
+		setTransform(ETS_TEXTURE_0, core::IdentityMatrix);
+
+		if (texture)
+		{
+			if (OverrideMaterial2DEnabled)
+				setTextureRenderStates(OverrideMaterial2D, false);
+			else
+				setTextureRenderStates(InitMaterial2D, false);
+		}
+
+		MaterialRenderer2DActive->OnRender(this, video::EVT_STANDARD);
+	}
+
+
+	void COpenGL3DriverBase::chooseMaterial2D()
+	{
+		if (!OverrideMaterial2DEnabled)
+			Material = InitMaterial2D;
+
+		if (OverrideMaterial2DEnabled)
+		{
+			OverrideMaterial2D.Lighting=false;
+			OverrideMaterial2D.ZWriteEnable=EZW_OFF;
+			OverrideMaterial2D.ZBuffer=ECFN_DISABLED; // it will be ECFN_DISABLED after merge
+			OverrideMaterial2D.Lighting=false;
+
+			Material = OverrideMaterial2D;
+		}
+	}
+
+
+	//! \return Returns the name of the video driver.
+	const wchar_t* COpenGL3DriverBase::getName() const
+	{
+		return Name.c_str();
+	}
+
+	void COpenGL3DriverBase::setViewPort(const core::rect<s32>& area)
+	{
+		core::rect<s32> vp = area;
+		core::rect<s32> rendert(0, 0, getCurrentRenderTargetSize().Width, getCurrentRenderTargetSize().Height);
+		vp.clipAgainst(rendert);
+
+		if (vp.getHeight() > 0 && vp.getWidth() > 0)
+			CacheHandler->setViewport(vp.UpperLeftCorner.X, getCurrentRenderTargetSize().Height - vp.UpperLeftCorner.Y - vp.getHeight(), vp.getWidth(), vp.getHeight());
+
+		ViewPort = vp;
+	}
+
+
+	void COpenGL3DriverBase::setViewPortRaw(u32 width, u32 height)
+	{
+		CacheHandler->setViewport(0, 0, width, height);
+		ViewPort = core::recti(0, 0, width, height);
+	}
+
+
+	//! Draws a 3d line.
+	void COpenGL3DriverBase::draw3DLine(const core::vector3df& start,
+			const core::vector3df& end, SColor color)
+	{
+		setRenderStates3DMode();
+
+		S3DVertex vertices[2];
+		vertices[0] = S3DVertex(start.X, start.Y, start.Z, 0, 0, 1, color, 0, 0);
+		vertices[1] = S3DVertex(end.X, end.Y, end.Z, 0, 0, 1, color, 0, 0);
+
+		drawArrays(GL_LINES, vtPrimitive, vertices, 2);
+	}
+
+
+	//! Only used by the internal engine. Used to notify the driver that
+	//! the window was resized.
+	void COpenGL3DriverBase::OnResize(const core::dimension2d<u32>& size)
+	{
+		CNullDriver::OnResize(size);
+		CacheHandler->setViewport(0, 0, size.Width, size.Height);
+		Transformation3DChanged = true;
+	}
+
+
+	//! Returns type of video driver
+	E_DRIVER_TYPE COpenGL3DriverBase::getDriverType() const
+	{
+		return EDT_OPENGL3;
+	}
+
+
+	//! returns color format
+	ECOLOR_FORMAT COpenGL3DriverBase::getColorFormat() const
+	{
+		return ColorFormat;
+	}
+
+
+	//! Get a vertex shader constant index.
+	s32 COpenGL3DriverBase::getVertexShaderConstantID(const c8* name)
+	{
+		return getPixelShaderConstantID(name);
+	}
+
+	//! Get a pixel shader constant index.
+	s32 COpenGL3DriverBase::getPixelShaderConstantID(const c8* name)
+	{
+		os::Printer::log("Error: Please call services->getPixelShaderConstantID(), not VideoDriver->getPixelShaderConstantID().");
+		return -1;
+	}
+
+	//! Sets a vertex shader constant.
+	void COpenGL3DriverBase::setVertexShaderConstant(const f32* data, s32 startRegister, s32 constantAmount)
+	{
+		os::Printer::log("Error: Please call services->setVertexShaderConstant(), not VideoDriver->setPixelShaderConstant().");
+	}
+
+	//! Sets a pixel shader constant.
+	void COpenGL3DriverBase::setPixelShaderConstant(const f32* data, s32 startRegister, s32 constantAmount)
+	{
+		os::Printer::log("Error: Please call services->setPixelShaderConstant(), not VideoDriver->setPixelShaderConstant().");
+	}
+
+	//! Sets a constant for the vertex shader based on an index.
+	bool COpenGL3DriverBase::setVertexShaderConstant(s32 index, const f32* floats, int count)
+	{
+		os::Printer::log("Error: Please call services->setVertexShaderConstant(), not VideoDriver->setVertexShaderConstant().");
+		return false;
+	}
+
+	//! Int interface for the above.
+	bool COpenGL3DriverBase::setVertexShaderConstant(s32 index, const s32* ints, int count)
+	{
+		os::Printer::log("Error: Please call services->setVertexShaderConstant(), not VideoDriver->setVertexShaderConstant().");
+		return false;
+	}
+
+	bool COpenGL3DriverBase::setVertexShaderConstant(s32 index, const u32* ints, int count)
+	{
+		os::Printer::log("Error: Please call services->setVertexShaderConstant(), not VideoDriver->setVertexShaderConstant().");
+		return false;
+	}
+
+	//! Sets a constant for the pixel shader based on an index.
+	bool COpenGL3DriverBase::setPixelShaderConstant(s32 index, const f32* floats, int count)
+	{
+		os::Printer::log("Error: Please call services->setPixelShaderConstant(), not VideoDriver->setPixelShaderConstant().");
+		return false;
+	}
+
+	//! Int interface for the above.
+	bool COpenGL3DriverBase::setPixelShaderConstant(s32 index, const s32* ints, int count)
+	{
+		os::Printer::log("Error: Please call services->setPixelShaderConstant(), not VideoDriver->setPixelShaderConstant().");
+		return false;
+	}
+
+	bool COpenGL3DriverBase::setPixelShaderConstant(s32 index, const u32* ints, int count)
+	{
+		os::Printer::log("Error: Please call services->setPixelShaderConstant(), not VideoDriver->setPixelShaderConstant().");
+		return false;
+	}
+
+	//! Adds a new material renderer to the VideoDriver, using pixel and/or
+	//! vertex shaders to render geometry.
+	s32 COpenGL3DriverBase::addShaderMaterial(const c8* vertexShaderProgram,
+			const c8* pixelShaderProgram,
+			IShaderConstantSetCallBack* callback,
+			E_MATERIAL_TYPE baseMaterial, s32 userData)
+	{
+		os::Printer::log("No shader support.");
+		return -1;
+	}
+
+
+	//! Adds a new material renderer to the VideoDriver, using GLSL to render geometry.
+	s32 COpenGL3DriverBase::addHighLevelShaderMaterial(
+			const c8* vertexShaderProgram,
+			const c8* vertexShaderEntryPointName,
+			E_VERTEX_SHADER_TYPE vsCompileTarget,
+			const c8* pixelShaderProgram,
+			const c8* pixelShaderEntryPointName,
+			E_PIXEL_SHADER_TYPE psCompileTarget,
+			const c8* geometryShaderProgram,
+			const c8* geometryShaderEntryPointName,
+			E_GEOMETRY_SHADER_TYPE gsCompileTarget,
+			scene::E_PRIMITIVE_TYPE inType,
+			scene::E_PRIMITIVE_TYPE outType,
+			u32 verticesOut,
+			IShaderConstantSetCallBack* callback,
+			E_MATERIAL_TYPE baseMaterial,
+			s32 userData)
+	{
+		s32 nr = -1;
+		COpenGL3MaterialRenderer* r = new COpenGL3MaterialRenderer(
+			this, nr, vertexShaderProgram,
+			pixelShaderProgram,
+			callback, baseMaterial, userData);
+
+		r->drop();
+		return nr;
+	}
+
+	//! Returns a pointer to the IVideoDriver interface. (Implementation for
+	//! IMaterialRendererServices)
+	IVideoDriver* COpenGL3DriverBase::getVideoDriver()
+	{
+		return this;
+	}
+
+
+	//! Returns pointer to the IGPUProgrammingServices interface.
+	IGPUProgrammingServices* COpenGL3DriverBase::getGPUProgrammingServices()
+	{
+		return this;
+	}
+
+	ITexture* COpenGL3DriverBase::addRenderTargetTexture(const core::dimension2d<u32>& size,
+		const io::path& name, const ECOLOR_FORMAT format)
+	{
+		//disable mip-mapping
+		bool generateMipLevels = getTextureCreationFlag(ETCF_CREATE_MIP_MAPS);
+		setTextureCreationFlag(ETCF_CREATE_MIP_MAPS, false);
+
+		COpenGL3Texture* renderTargetTexture = new COpenGL3Texture(name, size, ETT_2D, format, this);
+		addTexture(renderTargetTexture);
+		renderTargetTexture->drop();
+
+		//restore mip-mapping
+		setTextureCreationFlag(ETCF_CREATE_MIP_MAPS, generateMipLevels);
+
+		return renderTargetTexture;
+	}
+
+	ITexture* COpenGL3DriverBase::addRenderTargetTextureCubemap(const irr::u32 sideLen, const io::path& name, const ECOLOR_FORMAT format)
+	{
+		//disable mip-mapping
+		bool generateMipLevels = getTextureCreationFlag(ETCF_CREATE_MIP_MAPS);
+		setTextureCreationFlag(ETCF_CREATE_MIP_MAPS, false);
+
+		bool supportForFBO = (Feature.ColorAttachment > 0);
+
+		const core::dimension2d<u32> size(sideLen, sideLen);
+		core::dimension2du destSize(size);
+
+		if (!supportForFBO)
+		{
+			destSize = core::dimension2d<u32>(core::min_(size.Width, ScreenSize.Width), core::min_(size.Height, ScreenSize.Height));
+			destSize = destSize.getOptimalSize((size == size.getOptimalSize()), false, false);
+		}
+
+		COpenGL3Texture* renderTargetTexture = new COpenGL3Texture(name, destSize, ETT_CUBEMAP, format, this);
+		addTexture(renderTargetTexture);
+		renderTargetTexture->drop();
+
+		//restore mip-mapping
+		setTextureCreationFlag(ETCF_CREATE_MIP_MAPS, generateMipLevels);
+
+		return renderTargetTexture;
+	}
+
+
+	//! Returns the maximum amount of primitives
+	u32 COpenGL3DriverBase::getMaximalPrimitiveCount() const
+	{
+		return 65535;
+	}
+
+	bool COpenGL3DriverBase::setRenderTargetEx(IRenderTarget* target, u16 clearFlag, SColor clearColor, f32 clearDepth, u8 clearStencil)
+	{
+		if (target && target->getDriverType() != getDriverType())
+		{
+			os::Printer::log("Fatal Error: Tried to set a render target not owned by OpenGL 3 driver.", ELL_ERROR);
+			return false;
+		}
+
+		core::dimension2d<u32> destRenderTargetSize(0, 0);
+
+		if (target)
+		{
+			COpenGL3RenderTarget* renderTarget = static_cast<COpenGL3RenderTarget*>(target);
+
+			CacheHandler->setFBO(renderTarget->getBufferID());
+			renderTarget->update();
+
+			destRenderTargetSize = renderTarget->getSize();
+
+			setViewPortRaw(destRenderTargetSize.Width, destRenderTargetSize.Height);
+		}
+		else
+		{
+			CacheHandler->setFBO(0);
+
+			destRenderTargetSize = core::dimension2d<u32>(0, 0);
+
+			setViewPortRaw(ScreenSize.Width, ScreenSize.Height);
+		}
+
+		if (CurrentRenderTargetSize != destRenderTargetSize)
+		{
+			CurrentRenderTargetSize = destRenderTargetSize;
+
+			Transformation3DChanged = true;
+		}
+
+		CurrentRenderTarget = target;
+
+		clearBuffers(clearFlag, clearColor, clearDepth, clearStencil);
+
+		return true;
+	}
+
+	void COpenGL3DriverBase::clearBuffers(u16 flag, SColor color, f32 depth, u8 stencil)
+	{
+		GLbitfield mask = 0;
+		u8 colorMask = 0;
+		bool depthMask = false;
+
+		CacheHandler->getColorMask(colorMask);
+		CacheHandler->getDepthMask(depthMask);
+
+		if (flag & ECBF_COLOR)
+		{
+			CacheHandler->setColorMask(ECP_ALL);
+
+			const f32 inv = 1.0f / 255.0f;
+			glClearColor(color.getRed() * inv, color.getGreen() * inv,
+				color.getBlue() * inv, color.getAlpha() * inv);
+
+			mask |= GL_COLOR_BUFFER_BIT;
+		}
+
+		if (flag & ECBF_DEPTH)
+		{
+			CacheHandler->setDepthMask(true);
+			glClearDepthf(depth);
+			mask |= GL_DEPTH_BUFFER_BIT;
+		}
+
+		if (flag & ECBF_STENCIL)
+		{
+			glClearStencil(stencil);
+			mask |= GL_STENCIL_BUFFER_BIT;
+		}
+
+		if (mask)
+			glClear(mask);
+
+		CacheHandler->setColorMask(colorMask);
+		CacheHandler->setDepthMask(depthMask);
+	}
+
+
+	//! Returns an image created from the last rendered frame.
+	// We want to read the front buffer to get the latest render finished.
+	// This is not possible under ogl-es, though, so one has to call this method
+	// outside of the render loop only.
+	IImage* COpenGL3DriverBase::createScreenShot(video::ECOLOR_FORMAT format, video::E_RENDER_TARGET target)
+	{
+		if (target==video::ERT_MULTI_RENDER_TEXTURES || target==video::ERT_RENDER_TEXTURE || target==video::ERT_STEREO_BOTH_BUFFERS)
+			return 0;
+
+		GLint internalformat = GL_RGBA;
+		GLint type = GL_UNSIGNED_BYTE;
+		{
+//			glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &internalformat);
+//			glGetIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &type);
+			// there's a format we don't support ATM
+			if (GL_UNSIGNED_SHORT_4_4_4_4 == type)
+			{
+				internalformat = GL_RGBA;
+				type = GL_UNSIGNED_BYTE;
+			}
+		}
+
+		IImage* newImage = 0;
+		if (GL_RGBA == internalformat)
+		{
+			if (GL_UNSIGNED_BYTE == type)
+				newImage = new CImage(ECF_A8R8G8B8, ScreenSize);
+			else
+				newImage = new CImage(ECF_A1R5G5B5, ScreenSize);
+		}
+		else
+		{
+			if (GL_UNSIGNED_BYTE == type)
+				newImage = new CImage(ECF_R8G8B8, ScreenSize);
+			else
+				newImage = new CImage(ECF_R5G6B5, ScreenSize);
+		}
+
+		if (!newImage)
+			return 0;
+
+		u8* pixels = static_cast<u8*>(newImage->getData());
+		if (!pixels)
+		{
+			newImage->drop();
+			return 0;
+		}
+
+		glReadPixels(0, 0, ScreenSize.Width, ScreenSize.Height, internalformat, type, pixels);
+		testGLError(__LINE__);
+
+		// opengl images are horizontally flipped, so we have to fix that here.
+		const s32 pitch = newImage->getPitch();
+		u8* p2 = pixels + (ScreenSize.Height - 1) * pitch;
+		u8* tmpBuffer = new u8[pitch];
+		for (u32 i = 0; i < ScreenSize.Height; i += 2)
+		{
+			memcpy(tmpBuffer, pixels, pitch);
+			memcpy(pixels, p2, pitch);
+			memcpy(p2, tmpBuffer, pitch);
+			pixels += pitch;
+			p2 -= pitch;
+		}
+		delete [] tmpBuffer;
+
+		// also GL_RGBA doesn't match the internal encoding of the image (which is BGRA)
+		if (GL_RGBA == internalformat && GL_UNSIGNED_BYTE == type)
+		{
+			pixels = static_cast<u8*>(newImage->getData());
+			for (u32 i = 0; i < ScreenSize.Height; i++)
+			{
+				for (u32 j = 0; j < ScreenSize.Width; j++)
+				{
+					u32 c = *(u32*) (pixels + 4 * j);
+					*(u32*) (pixels + 4 * j) = (c & 0xFF00FF00) |
+						((c & 0x00FF0000) >> 16) | ((c & 0x000000FF) << 16);
+				}
+				pixels += pitch;
+			}
+		}
+
+		if (testGLError(__LINE__))
+		{
+			newImage->drop();
+			return 0;
+		}
+		testGLError(__LINE__);
+		return newImage;
+	}
+
+	void COpenGL3DriverBase::removeTexture(ITexture* texture)
+	{
+		CacheHandler->getTextureCache().remove(texture);
+		CNullDriver::removeTexture(texture);
+	}
+
+	//! Set/unset a clipping plane.
+	bool COpenGL3DriverBase::setClipPlane(u32 index, const core::plane3df& plane, bool enable)
+	{
+		if (index >= UserClipPlane.size())
+			UserClipPlane.push_back(SUserClipPlane());
+
+		UserClipPlane[index].Plane = plane;
+		UserClipPlane[index].Enabled = enable;
+		return true;
+	}
+
+	//! Enable/disable a clipping plane.
+	void COpenGL3DriverBase::enableClipPlane(u32 index, bool enable)
+	{
+		UserClipPlane[index].Enabled = enable;
+	}
+
+	//! Get the ClipPlane Count
+	u32 COpenGL3DriverBase::getClipPlaneCount() const
+	{
+		return UserClipPlane.size();
+	}
+
+	const core::plane3df& COpenGL3DriverBase::getClipPlane(irr::u32 index) const
+	{
+		if (index < UserClipPlane.size())
+			return UserClipPlane[index].Plane;
+		else
+		{
+			_IRR_DEBUG_BREAK_IF(true)	// invalid index
+			static const core::plane3df dummy;
+			return dummy;
+		}
+	}
+
+	core::dimension2du COpenGL3DriverBase::getMaxTextureSize() const
+	{
+		return core::dimension2du(MaxTextureSize, MaxTextureSize);
+	}
+
+	GLenum COpenGL3DriverBase::getGLBlend(E_BLEND_FACTOR factor) const
+	{
+		static GLenum const blendTable[] =
+		{
+			GL_ZERO,
+			GL_ONE,
+			GL_DST_COLOR,
+			GL_ONE_MINUS_DST_COLOR,
+			GL_SRC_COLOR,
+			GL_ONE_MINUS_SRC_COLOR,
+			GL_SRC_ALPHA,
+			GL_ONE_MINUS_SRC_ALPHA,
+			GL_DST_ALPHA,
+			GL_ONE_MINUS_DST_ALPHA,
+			GL_SRC_ALPHA_SATURATE
+		};
+
+		return blendTable[factor];
+	}
+
+	bool COpenGL3DriverBase::getColorFormatParameters(ECOLOR_FORMAT format, GLint& internalFormat, GLenum& pixelFormat,
+		GLenum& pixelType, void(**converter)(const void*, s32, void*)) const
+	{
+		bool supported = false;
+		pixelFormat = GL_RGBA;
+		pixelType = GL_UNSIGNED_BYTE;
+		*converter = 0;
+
+		switch (format)
+		{
+		case ECF_A1R5G5B5:
+			supported = true;
+			pixelFormat = GL_RGBA;
+			pixelType = GL_UNSIGNED_SHORT_5_5_5_1;
+			*converter = CColorConverter::convert_A1R5G5B5toR5G5B5A1;
+			break;
+		case ECF_R5G6B5:
+			supported = true;
+			pixelFormat = GL_RGB;
+			pixelType = GL_UNSIGNED_SHORT_5_6_5;
+			break;
+		case ECF_R8G8B8:
+			supported = true;
+			pixelFormat = GL_RGB;
+			pixelType = GL_UNSIGNED_BYTE;
+			break;
+		case ECF_A8R8G8B8:
+			supported = true;
+			if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_IMG_texture_format_BGRA8888) ||
+				queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_EXT_texture_format_BGRA8888) ||
+				queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_APPLE_texture_format_BGRA8888))
+			{
+				pixelFormat = GL_BGRA;
+			}
+			else
+			{
+				pixelFormat = GL_RGBA;
+				*converter = CColorConverter::convert_A8R8G8B8toA8B8G8R8;
+			}
+			pixelType = GL_UNSIGNED_BYTE;
+			break;
+#ifdef GL_EXT_texture_compression_s3tc
+		case ECF_DXT1:
+			supported = true;
+			pixelFormat = GL_RGBA;
+			pixelType = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+			break;
+		case ECF_DXT2:
+		case ECF_DXT3:
+			supported = true;
+			pixelFormat = GL_RGBA;
+			pixelType = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+			break;
+		case ECF_DXT4:
+		case ECF_DXT5:
+			supported = true;
+			pixelFormat = GL_RGBA;
+			pixelType = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+			break;
+#endif
+#ifdef GL_OES_compressed_ETC1_RGB8_texture
+		case ECF_ETC1:
+			supported = true;
+			pixelFormat = GL_RGB;
+			pixelType = GL_ETC1_RGB8_OES;
+			break;
+#endif
+#ifdef GL_ES_VERSION_3_0 // TO-DO - fix when extension name will be available
+		case ECF_ETC2_RGB:
+			supported = true;
+			pixelFormat = GL_RGB;
+			pixelType = GL_COMPRESSED_RGB8_ETC2;
+			break;
+#endif
+#ifdef GL_ES_VERSION_3_0 // TO-DO - fix when extension name will be available
+		case ECF_ETC2_ARGB:
+			supported = true;
+			pixelFormat = GL_RGBA;
+			pixelType = GL_COMPRESSED_RGBA8_ETC2_EAC;
+			break;
+#endif
+		case ECF_D16:
+			supported = true;
+			pixelFormat = GL_DEPTH_COMPONENT;
+			pixelType = GL_UNSIGNED_SHORT;
+			break;
+		case ECF_D32:
+#if defined(GL_OES_depth32)
+			if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_OES_depth32))
+			{
+				supported = true;
+				pixelFormat = GL_DEPTH_COMPONENT;
+				pixelType = GL_UNSIGNED_INT;
+			}
+#endif
+			break;
+		case ECF_D24S8:
+#ifdef GL_OES_packed_depth_stencil
+			if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_OES_packed_depth_stencil))
+			{
+				supported = true;
+				pixelFormat = GL_DEPTH_STENCIL_OES;
+				pixelType = GL_UNSIGNED_INT_24_8_OES;
+			}
+#endif
+			break;
+		case ECF_R8:
+#if defined(GL_EXT_texture_rg)
+			if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_EXT_texture_rg))
+			{
+				supported = true;
+				pixelFormat = GL_RED_EXT;
+				pixelType = GL_UNSIGNED_BYTE;
+			}
+#endif
+			break;
+		case ECF_R8G8:
+#if defined(GL_EXT_texture_rg)
+			if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_EXT_texture_rg))
+			{
+				supported = true;
+				pixelFormat = GL_RG_EXT;
+				pixelType = GL_UNSIGNED_BYTE;
+			}
+#endif
+			break;
+		case ECF_R16:
+			break;
+		case ECF_R16G16:
+			break;
+		case ECF_R16F:
+#if defined(GL_OES_texture_half_float) && defined(GL_EXT_texture_rg)
+			if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_EXT_texture_rg)
+				&& queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_OES_texture_half_float)
+				)
+			{
+				supported = true;
+				pixelFormat = GL_RED_EXT;
+				pixelType = GL_HALF_FLOAT_OES ;
+			}
+#endif
+			break;
+		case ECF_G16R16F:
+#if defined(GL_OES_texture_half_float) && defined(GL_EXT_texture_rg)
+			if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_EXT_texture_rg)
+				&& queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_OES_texture_half_float)
+				)
+			{
+				supported = true;
+				pixelFormat = GL_RG_EXT;
+				pixelType = GL_HALF_FLOAT_OES ;
+			}
+#endif
+			break;
+		case ECF_A16B16G16R16F:
+#if defined(GL_OES_texture_half_float)
+			if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_OES_texture_half_float))
+			{
+				supported = true;
+				pixelFormat = GL_RGBA;
+				pixelType = GL_HALF_FLOAT_OES ;
+			}
+#endif
+			break;
+		case ECF_R32F:
+#if defined(GL_OES_texture_float) && defined(GL_EXT_texture_rg)
+			if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_EXT_texture_rg)
+				&& queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_OES_texture_float)
+				)
+			{
+				supported = true;
+				pixelFormat = GL_RED_EXT;
+				pixelType = GL_FLOAT;
+			}
+#endif
+			break;
+		case ECF_G32R32F:
+#if defined(GL_OES_texture_float) && defined(GL_EXT_texture_rg)
+			if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_EXT_texture_rg)
+				&& queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_OES_texture_float)
+				)
+			{
+				supported = true;
+				pixelFormat = GL_RG_EXT;
+				pixelType = GL_FLOAT;
+			}
+#endif
+			break;
+		case ECF_A32B32G32R32F:
+#if defined(GL_OES_texture_float)
+			if (queryGLESFeature(COGLESCoreExtensionHandler::IRR_GL_OES_texture_half_float))
+			{
+				supported = true;
+				pixelFormat = GL_RGBA;
+				pixelType = GL_FLOAT ;
+			}
+#endif
+			break;
+		default:
+			break;
+		}
+
+		// ES 2.0 says internalFormat must match pixelFormat (chapter 3.7.1 in Spec).
+		// Doesn't mention if "match" means "equal" or some other way of matching, but
+		// some bug on Emscripten and browsing discussions by others lead me to believe
+		// it means they have to be equal. Note that this was different in OpenGL.
+		internalFormat = pixelFormat;
+
+#ifdef _IRR_IOS_PLATFORM_
+		if (internalFormat == GL_BGRA)
+			internalFormat = GL_RGBA;
+#endif
+
+		return supported;
+	}
+
+	bool COpenGL3DriverBase::queryTextureFormat(ECOLOR_FORMAT format) const
+	{
+		GLint dummyInternalFormat;
+		GLenum dummyPixelFormat;
+		GLenum dummyPixelType;
+		void (*dummyConverter)(const void*, s32, void*);
+		return getColorFormatParameters(format, dummyInternalFormat, dummyPixelFormat, dummyPixelType, &dummyConverter);
+	}
+
+	bool COpenGL3DriverBase::needsTransparentRenderPass(const irr::video::SMaterial& material) const
+	{
+		return CNullDriver::needsTransparentRenderPass(material) || material.isAlphaBlendOperation();
+	}
+
+	const SMaterial& COpenGL3DriverBase::getCurrentMaterial() const
+	{
+		return Material;
+	}
+
+	COpenGL3CacheHandler* COpenGL3DriverBase::getCacheHandler() const
+	{
+		return CacheHandler;
+	}
+
+} // end namespace
+} // end namespace
diff --git a/source/Irrlicht/OpenGL/Driver.h b/source/Irrlicht/OpenGL/Driver.h
new file mode 100644
index 0000000..06907b7
--- /dev/null
+++ b/source/Irrlicht/OpenGL/Driver.h
@@ -0,0 +1,395 @@
+// Copyright (C) 2023 Vitaliy Lobachevskiy
+// Copyright (C) 2014 Patryk Nadrowski
+// Copyright (C) 2009-2010 Amundis
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in Irrlicht.h
+
+#pragma once
+
+#include "SIrrCreationParameters.h"
+
+#include "Common.h"
+#include "CNullDriver.h"
+#include "IMaterialRendererServices.h"
+#include "EDriverFeatures.h"
+#include "fast_atof.h"
+#include "ExtensionHandler.h"
+#include "IContextManager.h"
+
+namespace irr
+{
+namespace video
+{
+	struct VertexType;
+
+	class COpenGL3FixedPipelineRenderer;
+	class COpenGL3Renderer2D;
+
+	class COpenGL3DriverBase : public CNullDriver, public IMaterialRendererServices, public COpenGL3ExtensionHandler
+	{
+		friend class COpenGLCoreTexture<COpenGL3DriverBase>;
+
+	protected:
+		//! constructor (use createOpenGL3Driver instead)
+		COpenGL3DriverBase(const SIrrlichtCreationParameters& params, io::IFileSystem* io, IContextManager* contextManager);
+
+	public:
+
+		//! destructor
+		virtual ~COpenGL3DriverBase();
+
+		virtual bool beginScene(u16 clearFlag, SColor clearColor = SColor(255, 0, 0, 0), f32 clearDepth = 1.f, u8 clearStencil = 0,
+			const SExposedVideoData& videoData = SExposedVideoData(), core::rect<s32>* sourceRect = 0) override;
+
+		bool endScene() override;
+
+		//! sets transformation
+		void setTransform(E_TRANSFORMATION_STATE state, const core::matrix4& mat) override;
+
+		struct SHWBufferLink_opengl : public SHWBufferLink
+		{
+			SHWBufferLink_opengl(const scene::IMeshBuffer *meshBuffer)
+			: SHWBufferLink(meshBuffer), vbo_verticesID(0), vbo_indicesID(0)
+			, vbo_verticesSize(0), vbo_indicesSize(0)
+			{}
+
+			u32 vbo_verticesID; //tmp
+			u32 vbo_indicesID; //tmp
+
+			u32 vbo_verticesSize; //tmp
+			u32 vbo_indicesSize; //tmp
+		};
+
+		bool updateVertexHardwareBuffer(SHWBufferLink_opengl *HWBuffer);
+		bool updateIndexHardwareBuffer(SHWBufferLink_opengl *HWBuffer);
+
+		//! updates hardware buffer if needed
+		bool updateHardwareBuffer(SHWBufferLink *HWBuffer) override;
+
+		//! Create hardware buffer from mesh
+		SHWBufferLink *createHardwareBuffer(const scene::IMeshBuffer* mb) override;
+
+		//! Delete hardware buffer (only some drivers can)
+		void deleteHardwareBuffer(SHWBufferLink *HWBuffer) override;
+
+		//! Draw hardware buffer
+		void drawHardwareBuffer(SHWBufferLink *HWBuffer) override;
+
+		IRenderTarget* addRenderTarget() override;
+
+		//! draws a vertex primitive list
+		virtual void drawVertexPrimitiveList(const void* vertices, u32 vertexCount,
+				const void* indexList, u32 primitiveCount,
+				E_VERTEX_TYPE vType, scene::E_PRIMITIVE_TYPE pType, E_INDEX_TYPE iType) override;
+
+		//! queries the features of the driver, returns true if feature is available
+		bool queryFeature(E_VIDEO_DRIVER_FEATURE feature) const override
+		{
+			return FeatureEnabled[feature] && COpenGL3ExtensionHandler::queryFeature(feature);
+		}
+
+		//! Sets a material.
+		void setMaterial(const SMaterial& material) override;
+
+		virtual void draw2DImage(const video::ITexture* texture,
+				const core::position2d<s32>& destPos,
+				const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect = 0,
+				SColor color = SColor(255, 255, 255, 255), bool useAlphaChannelOfTexture = false) override;
+
+		virtual void draw2DImage(const video::ITexture* texture, const core::rect<s32>& destRect,
+			const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect = 0,
+			const video::SColor* const colors = 0, bool useAlphaChannelOfTexture = false) override;
+
+		// internally used
+		virtual void draw2DImage(const video::ITexture* texture, u32 layer, bool flip);
+
+		void draw2DImageBatch(const video::ITexture* texture,
+				const core::array<core::position2d<s32> >& positions,
+				const core::array<core::rect<s32> >& sourceRects,
+				const core::rect<s32>* clipRect,
+				SColor color,
+				bool useAlphaChannelOfTexture) override;
+
+		//! draw an 2d rectangle
+		virtual void draw2DRectangle(SColor color, const core::rect<s32>& pos,
+				const core::rect<s32>* clip = 0) override;
+
+		//!Draws an 2d rectangle with a gradient.
+		virtual void draw2DRectangle(const core::rect<s32>& pos,
+				SColor colorLeftUp, SColor colorRightUp, SColor colorLeftDown, SColor colorRightDown,
+				const core::rect<s32>* clip = 0) override;
+
+		//! Draws a 2d line.
+		virtual void draw2DLine(const core::position2d<s32>& start,
+				const core::position2d<s32>& end,
+				SColor color = SColor(255, 255, 255, 255)) override;
+
+		//! Draws a single pixel
+		void drawPixel(u32 x, u32 y, const SColor & color) override;
+
+		//! Draws a 3d line.
+		virtual void draw3DLine(const core::vector3df& start,
+				const core::vector3df& end,
+				SColor color = SColor(255, 255, 255, 255)) override;
+
+		//! Draws a pixel
+//			virtual void drawPixel(u32 x, u32 y, const SColor & color);
+
+		//! Returns the name of the video driver.
+		const wchar_t* getName() const override;
+
+		//! Returns the maximum texture size supported.
+		core::dimension2du getMaxTextureSize() const override;
+
+		//! sets a viewport
+		void setViewPort(const core::rect<s32>& area) override;
+
+		//! Only used internally by the engine
+		void OnResize(const core::dimension2d<u32>& size) override;
+
+		//! Returns type of video driver
+		E_DRIVER_TYPE getDriverType() const override;
+
+		//! get color format of the current color buffer
+		ECOLOR_FORMAT getColorFormat() const override;
+
+		//! Returns the transformation set by setTransform
+		const core::matrix4& getTransform(E_TRANSFORMATION_STATE state) const override;
+
+		//! Can be called by an IMaterialRenderer to make its work easier.
+		void setBasicRenderStates(const SMaterial& material, const SMaterial& lastmaterial, bool resetAllRenderstates) override;
+
+		//! Compare in SMaterial doesn't check texture parameters, so we should call this on each OnRender call.
+		void setTextureRenderStates(const SMaterial& material, bool resetAllRenderstates);
+
+		//! Get a vertex shader constant index.
+		s32 getVertexShaderConstantID(const c8* name) override;
+
+		//! Get a pixel shader constant index.
+		s32 getPixelShaderConstantID(const c8* name) override;
+
+		//! Sets a vertex shader constant.
+		void setVertexShaderConstant(const f32* data, s32 startRegister, s32 constantAmount = 1) override;
+
+		//! Sets a pixel shader constant.
+		void setPixelShaderConstant(const f32* data, s32 startRegister, s32 constantAmount = 1) override;
+
+		//! Sets a constant for the vertex shader based on an index.
+		bool setVertexShaderConstant(s32 index, const f32* floats, int count) override;
+
+		//! Int interface for the above.
+		bool setVertexShaderConstant(s32 index, const s32* ints, int count) override;
+
+		//! Uint interface for the above.
+		bool setVertexShaderConstant(s32 index, const u32* ints, int count) override;
+
+		//! Sets a constant for the pixel shader based on an index.
+		bool setPixelShaderConstant(s32 index, const f32* floats, int count) override;
+
+		//! Int interface for the above.
+		bool setPixelShaderConstant(s32 index, const s32* ints, int count) override;
+
+		//! Uint interface for the above.
+		bool setPixelShaderConstant(s32 index, const u32* ints, int count) override;
+
+		//! Adds a new material renderer to the VideoDriver
+		virtual s32 addShaderMaterial(const c8* vertexShaderProgram, const c8* pixelShaderProgram,
+				IShaderConstantSetCallBack* callback, E_MATERIAL_TYPE baseMaterial, s32 userData) override;
+
+		//! Adds a new material renderer to the VideoDriver
+		virtual s32 addHighLevelShaderMaterial(
+				const c8* vertexShaderProgram,
+				const c8* vertexShaderEntryPointName = 0,
+				E_VERTEX_SHADER_TYPE vsCompileTarget = EVST_VS_1_1,
+				const c8* pixelShaderProgram = 0,
+				const c8* pixelShaderEntryPointName = 0,
+				E_PIXEL_SHADER_TYPE psCompileTarget = EPST_PS_1_1,
+				const c8* geometryShaderProgram = 0,
+				const c8* geometryShaderEntryPointName = "main",
+				E_GEOMETRY_SHADER_TYPE gsCompileTarget = EGST_GS_4_0,
+				scene::E_PRIMITIVE_TYPE inType = scene::EPT_TRIANGLES,
+				scene::E_PRIMITIVE_TYPE outType = scene::EPT_TRIANGLE_STRIP,
+				u32 verticesOut = 0,
+				IShaderConstantSetCallBack* callback = 0,
+				E_MATERIAL_TYPE baseMaterial = video::EMT_SOLID,
+				s32 userData=0) override;
+
+		//! Returns pointer to the IGPUProgrammingServices interface.
+		IGPUProgrammingServices* getGPUProgrammingServices() override;
+
+		//! Returns a pointer to the IVideoDriver interface.
+		IVideoDriver* getVideoDriver() override;
+
+		//! Returns the maximum amount of primitives
+		u32 getMaximalPrimitiveCount() const override;
+
+		virtual ITexture* addRenderTargetTexture(const core::dimension2d<u32>& size,
+				const io::path& name, const ECOLOR_FORMAT format = ECF_UNKNOWN) override;
+
+		//! Creates a render target texture for a cubemap
+		ITexture* addRenderTargetTextureCubemap(const irr::u32 sideLen,
+				const io::path& name, const ECOLOR_FORMAT format) override;
+
+		virtual bool setRenderTargetEx(IRenderTarget* target, u16 clearFlag, SColor clearColor = SColor(255, 0, 0, 0),
+			f32 clearDepth = 1.f, u8 clearStencil = 0) override;
+
+		void clearBuffers(u16 flag, SColor color = SColor(255, 0, 0, 0), f32 depth = 1.f, u8 stencil = 0) override;
+
+		//! Returns an image created from the last rendered frame.
+		IImage* createScreenShot(video::ECOLOR_FORMAT format=video::ECF_UNKNOWN, video::E_RENDER_TARGET target=video::ERT_FRAME_BUFFER) override;
+
+		//! checks if an OpenGL error has happened and prints it (+ some internal code which is usually the line number)
+		bool testGLError(int code=0);
+
+		//! checks if an OGLES1 error has happened and prints it
+		bool testEGLError();
+
+		//! Set/unset a clipping plane.
+		bool setClipPlane(u32 index, const core::plane3df& plane, bool enable = false) override;
+
+		//! returns the current amount of user clip planes set.
+		u32 getClipPlaneCount() const;
+
+		//! returns the 0 indexed Plane
+		const core::plane3df& getClipPlane(u32 index) const;
+
+		//! Enable/disable a clipping plane.
+		void enableClipPlane(u32 index, bool enable) override;
+
+		//! Returns the graphics card vendor name.
+		core::stringc getVendorInfo() override
+		{
+			return VendorName;
+		};
+
+		void removeTexture(ITexture* texture) override;
+
+		//! Check if the driver supports creating textures with the given color format
+		bool queryTextureFormat(ECOLOR_FORMAT format) const override;
+
+		//! Used by some SceneNodes to check if a material should be rendered in the transparent render pass
+		bool needsTransparentRenderPass(const irr::video::SMaterial& material) const override;
+
+		//! Convert E_BLEND_FACTOR to OpenGL equivalent
+		GLenum getGLBlend(E_BLEND_FACTOR factor) const;
+
+		virtual bool getColorFormatParameters(ECOLOR_FORMAT format, GLint& internalFormat, GLenum& pixelFormat,
+			GLenum& pixelType, void(**converter)(const void*, s32, void*)) const;
+
+		//! Get current material.
+		const SMaterial& getCurrentMaterial() const;
+
+		COpenGL3CacheHandler* getCacheHandler() const;
+
+	protected:
+		//! inits the opengl-es driver
+		virtual bool genericDriverInit(const core::dimension2d<u32>& screenSize, bool stencilBuffer);
+
+		void chooseMaterial2D();
+
+		ITexture* createDeviceDependentTexture(const io::path& name, IImage* image) override;
+
+		ITexture* createDeviceDependentTextureCubemap(const io::path& name, const core::array<IImage*>& image) override;
+
+		//! Map Irrlicht wrap mode to OpenGL enum
+		GLint getTextureWrapMode(u8 clamp) const;
+
+		//! sets the needed renderstates
+		void setRenderStates3DMode();
+
+		//! sets the needed renderstates
+		void setRenderStates2DMode(bool alpha, bool texture, bool alphaChannel);
+
+		//! Prevent setRenderStateMode calls to do anything.
+		// hack to allow drawing meshbuffers in 2D mode.
+		// Better solution would be passing this flag through meshbuffers,
+		// but the way this is currently implemented in Irrlicht makes this tricky to implement
+		void lockRenderStateMode()
+		{
+			LockRenderStateMode = true;
+		}
+
+		//! Allow setRenderStateMode calls to work again
+		void unlockRenderStateMode()
+		{
+			LockRenderStateMode = false;
+		}
+
+		void draw2D3DVertexPrimitiveList(const void* vertices,
+				u32 vertexCount, const void* indexList, u32 primitiveCount,
+				E_VERTEX_TYPE vType, scene::E_PRIMITIVE_TYPE pType,
+				E_INDEX_TYPE iType, bool is3D);
+
+		void createMaterialRenderers();
+
+		void loadShaderData(const io::path& vertexShaderName, const io::path& fragmentShaderName, c8** vertexShaderData, c8** fragmentShaderData);
+
+		bool setMaterialTexture(irr::u32 layerIdx, const irr::video::ITexture* texture);
+
+		//! Same as `CacheHandler->setViewport`, but also sets `ViewPort`
+		virtual void setViewPortRaw(u32 width, u32 height);
+
+		void drawQuad(const VertexType &vertexType, const S3DVertex (&vertices)[4]);
+		void drawArrays(GLenum primitiveType, const VertexType &vertexType, const void *vertices, int vertexCount);
+		void drawElements(GLenum primitiveType, const VertexType &vertexType, const void *vertices, const u16 *indices, int indexCount);
+		void drawElements(GLenum primitiveType, const VertexType &vertexType, uintptr_t vertices, uintptr_t indices, int indexCount);
+
+		void beginDraw(const VertexType &vertexType, uintptr_t verticesBase);
+		void endDraw(const VertexType &vertexType);
+
+		COpenGL3CacheHandler* CacheHandler;
+		core::stringw Name;
+		core::stringc VendorName;
+		SIrrlichtCreationParameters Params;
+
+		//! bool to make all renderstates reset if set to true.
+		bool ResetRenderStates;
+		bool LockRenderStateMode;
+		u8 AntiAlias;
+
+		struct SUserClipPlane
+		{
+			core::plane3df Plane;
+			bool Enabled;
+		};
+
+		core::array<SUserClipPlane> UserClipPlane;
+
+		core::matrix4 TextureFlipMatrix;
+
+private:
+
+		COpenGL3Renderer2D* MaterialRenderer2DActive;
+		COpenGL3Renderer2D* MaterialRenderer2DTexture;
+		COpenGL3Renderer2D* MaterialRenderer2DNoTexture;
+
+		core::matrix4 Matrices[ETS_COUNT];
+
+		//! enumeration for rendering modes such as 2d and 3d for minimizing the switching of renderStates.
+		enum E_RENDER_MODE
+		{
+			ERM_NONE = 0, // no render state has been set yet.
+			ERM_2D, // 2d drawing rendermode
+			ERM_3D // 3d rendering mode
+		};
+
+		E_RENDER_MODE CurrentRenderMode;
+		bool Transformation3DChanged;
+		irr::io::path OGLES2ShaderPath;
+
+		SMaterial Material, LastMaterial;
+
+		//! Color buffer format
+		ECOLOR_FORMAT ColorFormat;
+
+		IContextManager* ContextManager;
+
+		std::vector<u16> QuadsIndices;
+		void initQuadsIndices(int max_vertex_count = 65536);
+
+		void debugCb(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message);
+		static void APIENTRY debugCb(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam);
+	};
+
+} // end namespace video
+} // end namespace irr
diff --git a/source/Irrlicht/OpenGL/ExtensionHandler.cpp b/source/Irrlicht/OpenGL/ExtensionHandler.cpp
new file mode 100644
index 0000000..b9cb75a
--- /dev/null
+++ b/source/Irrlicht/OpenGL/ExtensionHandler.cpp
@@ -0,0 +1,66 @@
+// Copyright (C) 2015 Patryk Nadrowski
+// Copyright (C) 2009-2010 Amundis
+// 2017 modified by Michael Zeilfelder (unifying extension handlers)
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in Irrlicht.h
+
+#include "ExtensionHandler.h"
+
+#include "irrString.h"
+#include "SMaterial.h"
+#include "fast_atof.h"
+#include <mt_opengl.h>
+
+namespace irr
+{
+namespace video
+{
+	void COpenGL3ExtensionHandler::initExtensions()
+	{
+		GLint major, minor;
+		glGetIntegerv(GL_MAJOR_VERSION, &major);
+		glGetIntegerv(GL_MINOR_VERSION, &minor);
+		Version = 100 * major + 10 * minor;
+
+		GLint ext_count = 0;
+		GL.GetIntegerv(GL_NUM_EXTENSIONS, &ext_count);
+		for (int k = 0; k < ext_count; k++) {
+			auto ext_name = (char *)GL.GetStringi(GL_EXTENSIONS, k);
+			for (size_t j=0; j<IRR_OGLES_Feature_Count; ++j) {
+				if (!strcmp(getFeatureString(j), ext_name)) {
+					FeatureAvailable[j] = true;
+					break;
+				}
+			}
+		}
+
+		GLint val=0;
+		glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &val);
+		Feature.MaxTextureUnits = static_cast<u8>(val);
+
+	#ifdef GL_EXT_texture_filter_anisotropic
+		if (FeatureAvailable[IRR_GL_EXT_texture_filter_anisotropic])
+		{
+			glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &val);
+			MaxAnisotropy = static_cast<u8>(val);
+		}
+	#endif
+	#ifdef GL_MAX_ELEMENTS_INDICES
+		glGetIntegerv(GL_MAX_ELEMENTS_INDICES, &val);
+		MaxIndices=val;
+	#endif
+		glGetIntegerv(GL_MAX_TEXTURE_SIZE, &val);
+		MaxTextureSize=static_cast<u32>(val);
+	#ifdef GL_EXT_texture_lod_bias
+		if (FeatureAvailable[IRR_GL_EXT_texture_lod_bias])
+			glGetFloatv(GL_MAX_TEXTURE_LOD_BIAS_EXT, &MaxTextureLODBias);
+	#endif
+		glGetFloatv(GL_ALIASED_LINE_WIDTH_RANGE, DimAliasedLine);
+		glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, DimAliasedPoint);
+
+		Feature.MaxTextureUnits = core::min_(Feature.MaxTextureUnits, static_cast<u8>(MATERIAL_MAX_TEXTURES));
+		Feature.ColorAttachment = 1;
+	}
+
+} // end namespace video
+} // end namespace irr
diff --git a/source/Irrlicht/OpenGL/ExtensionHandler.h b/source/Irrlicht/OpenGL/ExtensionHandler.h
new file mode 100644
index 0000000..6fb47b8
--- /dev/null
+++ b/source/Irrlicht/OpenGL/ExtensionHandler.h
@@ -0,0 +1,187 @@
+// Copyright (C) 2023 Vitaliy Lobachevskiy
+// Copyright (C) 2015 Patryk Nadrowski
+// Copyright (C) 2009-2010 Amundis
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in Irrlicht.h
+
+#pragma once
+
+#include "EDriverFeatures.h"
+#include "irrTypes.h"
+#include "os.h"
+
+#include "Common.h"
+
+#include "COGLESCoreExtensionHandler.h"
+
+namespace irr
+{
+namespace video
+{
+
+	class COpenGL3ExtensionHandler : public COGLESCoreExtensionHandler
+	{
+	public:
+		COpenGL3ExtensionHandler() : COGLESCoreExtensionHandler() {}
+
+		void initExtensions();
+
+		bool queryFeature(video::E_VIDEO_DRIVER_FEATURE feature) const
+		{
+			switch (feature)
+			{
+			case EVDF_RENDER_TO_TARGET:
+			case EVDF_HARDWARE_TL:
+			case EVDF_MULTITEXTURE:
+			case EVDF_BILINEAR_FILTER:
+			case EVDF_MIP_MAP:
+			case EVDF_MIP_MAP_AUTO_UPDATE:
+			case EVDF_VERTEX_SHADER_1_1:
+			case EVDF_PIXEL_SHADER_1_1:
+			case EVDF_PIXEL_SHADER_1_2:
+			case EVDF_PIXEL_SHADER_2_0:
+			case EVDF_VERTEX_SHADER_2_0:
+			case EVDF_ARB_GLSL:
+			case EVDF_TEXTURE_NSQUARE:
+			case EVDF_TEXTURE_NPOT:
+			case EVDF_FRAMEBUFFER_OBJECT:
+			case EVDF_VERTEX_BUFFER_OBJECT:
+			case EVDF_COLOR_MASK:
+			case EVDF_ALPHA_TO_COVERAGE:
+			case EVDF_POLYGON_OFFSET:
+			case EVDF_BLEND_OPERATIONS:
+			case EVDF_BLEND_SEPARATE:
+			case EVDF_TEXTURE_MATRIX:
+			case EVDF_TEXTURE_CUBEMAP:
+				return true;
+			case EVDF_ARB_VERTEX_PROGRAM_1:
+			case EVDF_ARB_FRAGMENT_PROGRAM_1:
+			case EVDF_GEOMETRY_SHADER:
+			case EVDF_MULTIPLE_RENDER_TARGETS:
+			case EVDF_MRT_BLEND:
+			case EVDF_MRT_COLOR_MASK:
+			case EVDF_MRT_BLEND_FUNC:
+			case EVDF_OCCLUSION_QUERY:
+				return false;
+			case EVDF_TEXTURE_COMPRESSED_DXT:
+				return false; // NV Tegra need improvements here
+			case EVDF_TEXTURE_COMPRESSED_PVRTC:
+				return FeatureAvailable[IRR_GL_IMG_texture_compression_pvrtc];
+			case EVDF_TEXTURE_COMPRESSED_PVRTC2:
+				return FeatureAvailable[IRR_GL_IMG_texture_compression_pvrtc2];
+			case EVDF_TEXTURE_COMPRESSED_ETC1:
+				return FeatureAvailable[IRR_GL_OES_compressed_ETC1_RGB8_texture];
+			case EVDF_TEXTURE_COMPRESSED_ETC2:
+				return false;
+			case EVDF_STENCIL_BUFFER:
+				return StencilBuffer;
+			default:
+				return false;
+			};
+		}
+
+		inline void irrGlActiveTexture(GLenum texture)
+		{
+			glActiveTexture(texture);
+		}
+
+		inline void irrGlCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border,
+			GLsizei imageSize, const void* data)
+		{
+			glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+		}
+
+		inline void irrGlCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
+			GLenum format, GLsizei imageSize, const void* data)
+		{
+			glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+		}
+
+		inline void irrGlUseProgram(GLuint prog)
+		{
+			glUseProgram(prog);
+		}
+
+		inline void irrGlBindFramebuffer(GLenum target, GLuint framebuffer)
+		{
+			glBindFramebuffer(target, framebuffer);
+		}
+
+		inline void irrGlDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
+		{
+			glDeleteFramebuffers(n, framebuffers);
+		}
+
+		inline void irrGlGenFramebuffers(GLsizei n, GLuint *framebuffers)
+		{
+			glGenFramebuffers(n, framebuffers);
+		}
+
+		inline GLenum irrGlCheckFramebufferStatus(GLenum target)
+		{
+			return glCheckFramebufferStatus(target);
+		}
+
+		inline void irrGlFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+		{
+			glFramebufferTexture2D(target, attachment, textarget, texture, level);
+		}
+
+		inline void irrGlGenerateMipmap(GLenum target)
+		{
+			glGenerateMipmap(target);
+		}
+
+		inline void irrGlActiveStencilFace(GLenum face)
+		{
+		}
+
+		inline void irrGlDrawBuffer(GLenum mode)
+		{
+		}
+
+		inline void irrGlDrawBuffers(GLsizei n, const GLenum *bufs)
+		{
+		}
+
+		inline void irrGlBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
+		{
+			glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+		}
+
+		inline void irrGlBlendEquation(GLenum mode)
+		{
+			glBlendEquation(mode);
+		}
+
+		inline void irrGlEnableIndexed(GLenum target, GLuint index)
+		{
+		}
+
+		inline void irrGlDisableIndexed(GLenum target, GLuint index)
+		{
+		}
+
+		inline void irrGlColorMaskIndexed(GLuint buf, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
+		{
+		}
+
+		inline void irrGlBlendFuncIndexed(GLuint buf, GLenum src, GLenum dst)
+		{
+		}
+
+		inline void irrGlBlendFuncSeparateIndexed(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
+		{
+		}
+
+		inline void irrGlBlendEquationIndexed(GLuint buf, GLenum mode)
+		{
+		}
+
+		inline void irrGlBlendEquationSeparateIndexed(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
+		{
+		}
+	};
+
+}
+}
diff --git a/source/Irrlicht/OpenGL/FixedPipelineRenderer.cpp b/source/Irrlicht/OpenGL/FixedPipelineRenderer.cpp
new file mode 100644
index 0000000..2922470
--- /dev/null
+++ b/source/Irrlicht/OpenGL/FixedPipelineRenderer.cpp
@@ -0,0 +1,334 @@
+// Copyright (C) 2014 Patryk Nadrowski
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in Irrlicht.h
+
+#include "FixedPipelineRenderer.h"
+
+#include "IVideoDriver.h"
+
+namespace irr
+{
+namespace video
+{
+
+// Base callback
+
+COpenGL3MaterialBaseCB::COpenGL3MaterialBaseCB() :
+	FirstUpdateBase(true), WVPMatrixID(-1), WVMatrixID(-1), NMatrixID(-1), GlobalAmbientID(-1), MaterialAmbientID(-1), MaterialDiffuseID(-1), MaterialEmissiveID(-1), MaterialSpecularID(-1), MaterialShininessID(-1),
+	FogEnableID(-1), FogTypeID(-1), FogColorID(-1), FogStartID(-1),
+	FogEndID(-1), FogDensityID(-1), ThicknessID(-1), LightEnable(false), MaterialAmbient(SColorf(0.f, 0.f, 0.f)), MaterialDiffuse(SColorf(0.f, 0.f, 0.f)), MaterialEmissive(SColorf(0.f, 0.f, 0.f)), MaterialSpecular(SColorf(0.f, 0.f, 0.f)),
+	MaterialShininess(0.f), FogEnable(0), FogType(1), FogColor(SColorf(0.f, 0.f, 0.f, 1.f)), FogStart(0.f), FogEnd(0.f), FogDensity(0.f), Thickness(1.f)
+{
+}
+
+void COpenGL3MaterialBaseCB::OnSetMaterial(const SMaterial& material)
+{
+	LightEnable = material.Lighting;
+	MaterialAmbient = SColorf(material.AmbientColor);
+	MaterialDiffuse = SColorf(material.DiffuseColor);
+	MaterialEmissive = SColorf(material.EmissiveColor);
+	MaterialSpecular = SColorf(material.SpecularColor);
+	MaterialShininess = material.Shininess;
+
+	FogEnable = material.FogEnable ? 1 : 0;
+
+	Thickness = (material.Thickness > 0.f) ? material.Thickness : 1.f;
+}
+
+void COpenGL3MaterialBaseCB::OnSetConstants(IMaterialRendererServices* services, s32 userData)
+{
+	IVideoDriver* driver = services->getVideoDriver();
+
+	if (FirstUpdateBase)
+	{
+		WVPMatrixID = services->getVertexShaderConstantID("uWVPMatrix");
+		WVMatrixID = services->getVertexShaderConstantID("uWVMatrix");
+		NMatrixID = services->getVertexShaderConstantID("uNMatrix");
+		GlobalAmbientID = services->getVertexShaderConstantID("uGlobalAmbient");
+		MaterialAmbientID = services->getVertexShaderConstantID("uMaterialAmbient");
+		MaterialDiffuseID = services->getVertexShaderConstantID("uMaterialDiffuse");
+		MaterialEmissiveID = services->getVertexShaderConstantID("uMaterialEmissive");
+		MaterialSpecularID = services->getVertexShaderConstantID("uMaterialSpecular");
+		MaterialShininessID = services->getVertexShaderConstantID("uMaterialShininess");
+		FogEnableID = services->getVertexShaderConstantID("uFogEnable");
+		FogTypeID = services->getVertexShaderConstantID("uFogType");
+		FogColorID = services->getVertexShaderConstantID("uFogColor");
+		FogStartID = services->getVertexShaderConstantID("uFogStart");
+		FogEndID = services->getVertexShaderConstantID("uFogEnd");
+		FogDensityID = services->getVertexShaderConstantID("uFogDensity");
+		ThicknessID = services->getVertexShaderConstantID("uThickness");
+
+		FirstUpdateBase = false;
+	}
+
+	const core::matrix4 W = driver->getTransform(ETS_WORLD);
+	const core::matrix4 V = driver->getTransform(ETS_VIEW);
+	const core::matrix4 P = driver->getTransform(ETS_PROJECTION);
+
+	core::matrix4 Matrix = P * V * W;
+	services->setPixelShaderConstant(WVPMatrixID, Matrix.pointer(), 16);
+
+	Matrix = V * W;
+	services->setPixelShaderConstant(WVMatrixID, Matrix.pointer(), 16);
+
+	Matrix.makeInverse();
+	services->setPixelShaderConstant(NMatrixID, Matrix.getTransposed().pointer(), 16);
+
+	services->setPixelShaderConstant(FogEnableID, &FogEnable, 1);
+
+	if (FogEnable)
+	{
+		SColor TempColor(0);
+		E_FOG_TYPE TempType = EFT_FOG_LINEAR;
+		bool TempPerFragment = false;
+		bool TempRange = false;
+
+		driver->getFog(TempColor, TempType, FogStart, FogEnd, FogDensity, TempPerFragment, TempRange);
+
+		FogType = (s32)TempType;
+		FogColor = SColorf(TempColor);
+
+		services->setPixelShaderConstant(FogTypeID, &FogType, 1);
+		services->setPixelShaderConstant(FogColorID, reinterpret_cast<f32*>(&FogColor), 4);
+		services->setPixelShaderConstant(FogStartID, &FogStart, 1);
+		services->setPixelShaderConstant(FogEndID, &FogEnd, 1);
+		services->setPixelShaderConstant(FogDensityID, &FogDensity, 1);
+	}
+
+	services->setPixelShaderConstant(ThicknessID, &Thickness, 1);
+}
+
+// EMT_SOLID + EMT_TRANSPARENT_ADD_COLOR + EMT_TRANSPARENT_ALPHA_CHANNEL + EMT_TRANSPARENT_VERTEX_ALPHA
+
+COpenGL3MaterialSolidCB::COpenGL3MaterialSolidCB() :
+	FirstUpdate(true), TMatrix0ID(-1), AlphaRefID(-1), TextureUsage0ID(-1), TextureUnit0ID(-1), AlphaRef(0.5f), TextureUsage0(0), TextureUnit0(0)
+{
+}
+
+void COpenGL3MaterialSolidCB::OnSetMaterial(const SMaterial& material)
+{
+	COpenGL3MaterialBaseCB::OnSetMaterial(material);
+
+	AlphaRef = material.MaterialTypeParam;
+	TextureUsage0 = (material.TextureLayer[0].Texture) ? 1 : 0;
+}
+
+void COpenGL3MaterialSolidCB::OnSetConstants(IMaterialRendererServices* services, s32 userData)
+{
+	COpenGL3MaterialBaseCB::OnSetConstants(services, userData);
+
+	IVideoDriver* driver = services->getVideoDriver();
+
+	if (FirstUpdate)
+	{
+		TMatrix0ID = services->getVertexShaderConstantID("uTMatrix0");
+		AlphaRefID = services->getVertexShaderConstantID("uAlphaRef");
+		TextureUsage0ID = services->getVertexShaderConstantID("uTextureUsage0");
+		TextureUnit0ID = services->getVertexShaderConstantID("uTextureUnit0");
+
+		FirstUpdate = false;
+	}
+
+	core::matrix4 Matrix = driver->getTransform(ETS_TEXTURE_0);
+	services->setPixelShaderConstant(TMatrix0ID, Matrix.pointer(), 16);
+
+	services->setPixelShaderConstant(AlphaRefID, &AlphaRef, 1);
+	services->setPixelShaderConstant(TextureUsage0ID, &TextureUsage0, 1);
+	services->setPixelShaderConstant(TextureUnit0ID, &TextureUnit0, 1);
+}
+
+// EMT_SOLID_2_LAYER + EMT_DETAIL_MAP
+
+COpenGL3MaterialSolid2CB::COpenGL3MaterialSolid2CB() :
+	FirstUpdate(true), TMatrix0ID(-1), TMatrix1ID(-1), TextureUsage0ID(-1), TextureUsage1ID(-1), TextureUnit0ID(-1), TextureUnit1ID(-1),
+	TextureUsage0(0), TextureUsage1(0), TextureUnit0(0), TextureUnit1(1)
+{
+}
+
+void COpenGL3MaterialSolid2CB::OnSetMaterial(const SMaterial& material)
+{
+	COpenGL3MaterialBaseCB::OnSetMaterial(material);
+
+	TextureUsage0 = (material.TextureLayer[0].Texture) ? 1 : 0;
+	TextureUsage1 = (material.TextureLayer[1].Texture) ? 1 : 0;
+}
+
+void COpenGL3MaterialSolid2CB::OnSetConstants(IMaterialRendererServices* services, s32 userData)
+{
+	COpenGL3MaterialBaseCB::OnSetConstants(services, userData);
+
+	IVideoDriver* driver = services->getVideoDriver();
+
+	if (FirstUpdate)
+	{
+		TMatrix0ID = services->getVertexShaderConstantID("uTMatrix0");
+		TMatrix1ID = services->getVertexShaderConstantID("uTMatrix1");
+		TextureUsage0ID = services->getVertexShaderConstantID("uTextureUsage0");
+		TextureUsage1ID = services->getVertexShaderConstantID("uTextureUsage1");
+		TextureUnit0ID = services->getVertexShaderConstantID("uTextureUnit0");
+		TextureUnit1ID = services->getVertexShaderConstantID("uTextureUnit1");
+
+		FirstUpdate = false;
+	}
+
+	core::matrix4 Matrix = driver->getTransform(ETS_TEXTURE_0);
+	services->setPixelShaderConstant(TMatrix0ID, Matrix.pointer(), 16);
+
+	Matrix = driver->getTransform(E_TRANSFORMATION_STATE(ETS_TEXTURE_0 + 1));
+	services->setPixelShaderConstant(TMatrix1ID, Matrix.pointer(), 16);
+
+	services->setPixelShaderConstant(TextureUsage0ID, &TextureUsage0, 1);
+	services->setPixelShaderConstant(TextureUsage1ID, &TextureUsage1, 1);
+	services->setPixelShaderConstant(TextureUnit0ID, &TextureUnit0, 1);
+	services->setPixelShaderConstant(TextureUnit1ID, &TextureUnit1, 1);
+}
+
+// EMT_LIGHTMAP + EMT_LIGHTMAP_ADD + EMT_LIGHTMAP_M2 + EMT_LIGHTMAP_M4
+
+COpenGL3MaterialLightmapCB::COpenGL3MaterialLightmapCB(float modulate) :
+	FirstUpdate(true), TMatrix0ID(-1), TMatrix1ID(-1), ModulateID(-1), TextureUsage0ID(-1), TextureUsage1ID(-1), TextureUnit0ID(-1), TextureUnit1ID(-1),
+	Modulate(modulate), TextureUsage0(0), TextureUsage1(0), TextureUnit0(0), TextureUnit1(1)
+{
+}
+
+void COpenGL3MaterialLightmapCB::OnSetMaterial(const SMaterial& material)
+{
+	COpenGL3MaterialBaseCB::OnSetMaterial(material);
+
+	TextureUsage0 = (material.TextureLayer[0].Texture) ? 1 : 0;
+	TextureUsage1 = (material.TextureLayer[1].Texture) ? 1 : 0;
+}
+
+void COpenGL3MaterialLightmapCB::OnSetConstants(IMaterialRendererServices* services, s32 userData)
+{
+	COpenGL3MaterialBaseCB::OnSetConstants(services, userData);
+
+	IVideoDriver* driver = services->getVideoDriver();
+
+	if (FirstUpdate)
+	{
+		TMatrix0ID = services->getVertexShaderConstantID("uTMatrix0");
+		TMatrix1ID = services->getVertexShaderConstantID("uTMatrix1");
+		ModulateID = services->getVertexShaderConstantID("uModulate");
+		TextureUsage0ID = services->getVertexShaderConstantID("uTextureUsage0");
+		TextureUsage1ID = services->getVertexShaderConstantID("uTextureUsage1");
+		TextureUnit0ID = services->getVertexShaderConstantID("uTextureUnit0");
+		TextureUnit1ID = services->getVertexShaderConstantID("uTextureUnit1");
+
+		FirstUpdate = false;
+	}
+
+	core::matrix4 Matrix = driver->getTransform(ETS_TEXTURE_0);
+	services->setPixelShaderConstant(TMatrix0ID, Matrix.pointer(), 16);
+
+	Matrix = driver->getTransform(E_TRANSFORMATION_STATE(ETS_TEXTURE_0 + 1));
+	services->setPixelShaderConstant(TMatrix1ID, Matrix.pointer(), 16);
+
+	services->setPixelShaderConstant(ModulateID, &Modulate, 1);
+	services->setPixelShaderConstant(TextureUsage0ID, &TextureUsage0, 1);
+	services->setPixelShaderConstant(TextureUsage1ID, &TextureUsage1, 1);
+	services->setPixelShaderConstant(TextureUnit0ID, &TextureUnit0, 1);
+	services->setPixelShaderConstant(TextureUnit1ID, &TextureUnit1, 1);
+}
+
+// EMT_SPHERE_MAP + EMT_REFLECTION_2_LAYER + EMT_TRANSPARENT_REFLECTION_2_LAYER
+
+COpenGL3MaterialReflectionCB::COpenGL3MaterialReflectionCB() :
+	FirstUpdate(true), TMatrix0ID(-1), TextureUsage0ID(-1), TextureUsage1ID(-1), TextureUnit0ID(-1), TextureUnit1ID(-1),
+	TextureUsage0(0), TextureUsage1(0), TextureUnit0(0), TextureUnit1(1)
+{
+}
+
+void COpenGL3MaterialReflectionCB::OnSetMaterial(const SMaterial& material)
+{
+	COpenGL3MaterialBaseCB::OnSetMaterial(material);
+
+	TextureUsage0 = (material.TextureLayer[0].Texture) ? 1 : 0;
+	TextureUsage1 = (material.TextureLayer[1].Texture) ? 1 : 0;
+}
+
+void COpenGL3MaterialReflectionCB::OnSetConstants(IMaterialRendererServices* services, s32 userData)
+{
+	COpenGL3MaterialBaseCB::OnSetConstants(services, userData);
+
+	IVideoDriver* driver = services->getVideoDriver();
+
+	if (FirstUpdate)
+	{
+		TMatrix0ID = services->getVertexShaderConstantID("uTMatrix0");
+		TextureUsage0ID = services->getVertexShaderConstantID("uTextureUsage0");
+		TextureUsage1ID = services->getVertexShaderConstantID("uTextureUsage1");
+		TextureUnit0ID = services->getVertexShaderConstantID("uTextureUnit0");
+		TextureUnit1ID = services->getVertexShaderConstantID("uTextureUnit1");
+
+		FirstUpdate = false;
+	}
+
+	core::matrix4 Matrix = driver->getTransform(ETS_TEXTURE_0);
+	services->setPixelShaderConstant(TMatrix0ID, Matrix.pointer(), 16);
+
+	services->setPixelShaderConstant(TextureUsage0ID, &TextureUsage0, 1);
+	services->setPixelShaderConstant(TextureUsage1ID, &TextureUsage1, 1);
+	services->setPixelShaderConstant(TextureUnit0ID, &TextureUnit0, 1);
+	services->setPixelShaderConstant(TextureUnit1ID, &TextureUnit1, 1);
+}
+
+// EMT_ONETEXTURE_BLEND
+
+COpenGL3MaterialOneTextureBlendCB::COpenGL3MaterialOneTextureBlendCB() :
+	FirstUpdate(true), TMatrix0ID(-1), BlendTypeID(-1), TextureUsage0ID(-1), TextureUnit0ID(-1), BlendType(0), TextureUsage0(0), TextureUnit0(0)
+{
+}
+
+void COpenGL3MaterialOneTextureBlendCB::OnSetMaterial(const SMaterial& material)
+{
+	COpenGL3MaterialBaseCB::OnSetMaterial(material);
+
+	BlendType = 0;
+
+	E_BLEND_FACTOR srcRGBFact,dstRGBFact,srcAlphaFact,dstAlphaFact;
+	E_MODULATE_FUNC modulate;
+	u32 alphaSource;
+	unpack_textureBlendFuncSeparate(srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact, modulate, alphaSource, material.MaterialTypeParam);
+
+	if (textureBlendFunc_hasAlpha(srcRGBFact) || textureBlendFunc_hasAlpha(dstRGBFact) || textureBlendFunc_hasAlpha(srcAlphaFact) || textureBlendFunc_hasAlpha(dstAlphaFact))
+	{
+		if (alphaSource == EAS_VERTEX_COLOR)
+		{
+			BlendType = 1;
+		}
+		else if (alphaSource == EAS_TEXTURE)
+		{
+			BlendType = 2;
+		}
+	}
+
+	TextureUsage0 = (material.TextureLayer[0].Texture) ? 1 : 0;
+}
+
+void COpenGL3MaterialOneTextureBlendCB::OnSetConstants(IMaterialRendererServices* services, s32 userData)
+{
+	COpenGL3MaterialBaseCB::OnSetConstants(services, userData);
+
+	IVideoDriver* driver = services->getVideoDriver();
+
+	if (FirstUpdate)
+	{
+		TMatrix0ID = services->getVertexShaderConstantID("uTMatrix0");
+		BlendTypeID = services->getVertexShaderConstantID("uBlendType");
+		TextureUsage0ID = services->getVertexShaderConstantID("uTextureUsage0");
+		TextureUnit0ID = services->getVertexShaderConstantID("uTextureUnit0");
+
+		FirstUpdate = false;
+	}
+
+	core::matrix4 Matrix = driver->getTransform(ETS_TEXTURE_0);
+	services->setPixelShaderConstant(TMatrix0ID, Matrix.pointer(), 16);
+
+	services->setPixelShaderConstant(BlendTypeID, &BlendType, 1);
+	services->setPixelShaderConstant(TextureUsage0ID, &TextureUsage0, 1);
+	services->setPixelShaderConstant(TextureUnit0ID, &TextureUnit0, 1);
+}
+
+}
+}
diff --git a/source/Irrlicht/OpenGL/FixedPipelineRenderer.h b/source/Irrlicht/OpenGL/FixedPipelineRenderer.h
new file mode 100644
index 0000000..aea935f
--- /dev/null
+++ b/source/Irrlicht/OpenGL/FixedPipelineRenderer.h
@@ -0,0 +1,180 @@
+// Copyright (C) 2014 Patryk Nadrowski
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in Irrlicht.h
+
+#pragma once
+
+#include "IShaderConstantSetCallBack.h"
+#include "IMaterialRendererServices.h"
+
+namespace irr
+{
+namespace video
+{
+
+class COpenGL3MaterialBaseCB : public IShaderConstantSetCallBack
+{
+public:
+	COpenGL3MaterialBaseCB();
+
+	virtual void OnSetMaterial(const SMaterial& material);
+	virtual void OnSetConstants(IMaterialRendererServices* services, s32 userData);
+
+protected:
+	bool FirstUpdateBase;
+
+	s32 WVPMatrixID;
+	s32 WVMatrixID;
+	s32 NMatrixID;
+
+	s32 GlobalAmbientID;
+	s32 MaterialAmbientID;
+	s32 MaterialDiffuseID;
+	s32 MaterialEmissiveID;
+	s32 MaterialSpecularID;
+	s32 MaterialShininessID;
+
+	s32 FogEnableID;
+	s32 FogTypeID;
+	s32 FogColorID;
+	s32 FogStartID;
+	s32 FogEndID;
+	s32 FogDensityID;
+
+	s32 ThicknessID;
+
+	bool LightEnable;
+	SColorf GlobalAmbient;
+	SColorf MaterialAmbient;
+	SColorf MaterialDiffuse;
+	SColorf MaterialEmissive;
+	SColorf MaterialSpecular;
+	f32 MaterialShininess;
+
+	s32 FogEnable;
+	s32 FogType;
+	SColorf FogColor;
+	f32 FogStart;
+	f32 FogEnd;
+	f32 FogDensity;
+
+	f32 Thickness;
+};
+
+class COpenGL3MaterialSolidCB : public COpenGL3MaterialBaseCB
+{
+public:
+	COpenGL3MaterialSolidCB();
+
+	virtual void OnSetMaterial(const SMaterial& material);
+	virtual void OnSetConstants(IMaterialRendererServices* services, s32 userData);
+
+protected:
+	bool FirstUpdate;
+
+	s32 TMatrix0ID;
+	s32 AlphaRefID;
+	s32 TextureUsage0ID;
+	s32 TextureUnit0ID;
+
+	f32 AlphaRef;
+	s32 TextureUsage0;
+	s32 TextureUnit0;
+};
+
+class COpenGL3MaterialSolid2CB : public COpenGL3MaterialBaseCB
+{
+public:
+	COpenGL3MaterialSolid2CB();
+
+	virtual void OnSetMaterial(const SMaterial& material);
+	virtual void OnSetConstants(IMaterialRendererServices* services, s32 userData);
+
+protected:
+	bool FirstUpdate;
+
+	s32 TMatrix0ID;
+	s32 TMatrix1ID;
+	s32 TextureUsage0ID;
+	s32 TextureUsage1ID;
+	s32 TextureUnit0ID;
+	s32 TextureUnit1ID;
+
+	s32 TextureUsage0;
+	s32 TextureUsage1;
+	s32 TextureUnit0;
+	s32 TextureUnit1;
+};
+
+class COpenGL3MaterialLightmapCB : public COpenGL3MaterialBaseCB
+{
+public:
+	COpenGL3MaterialLightmapCB(float modulate);
+
+	virtual void OnSetMaterial(const SMaterial& material);
+	virtual void OnSetConstants(IMaterialRendererServices* services, s32 userData);
+
+protected:
+	bool FirstUpdate;
+
+	s32 TMatrix0ID;
+	s32 TMatrix1ID;
+	s32 ModulateID;
+	s32 TextureUsage0ID;
+	s32 TextureUsage1ID;
+	s32 TextureUnit0ID;
+	s32 TextureUnit1ID;
+
+	f32 Modulate;
+	s32 TextureUsage0;
+	s32 TextureUsage1;
+	s32 TextureUnit0;
+	s32 TextureUnit1;
+};
+
+class COpenGL3MaterialReflectionCB : public COpenGL3MaterialBaseCB
+{
+public:
+	COpenGL3MaterialReflectionCB();
+
+	virtual void OnSetMaterial(const SMaterial& material);
+	virtual void OnSetConstants(IMaterialRendererServices* services, s32 userData);
+
+protected:
+	bool FirstUpdate;
+
+	s32 TMatrix0ID;
+	s32 TextureUsage0ID;
+	s32 TextureUsage1ID;
+	s32 TextureUnit0ID;
+	s32 TextureUnit1ID;
+
+	s32 TextureUsage0;
+	s32 TextureUsage1;
+	s32 TextureUnit0;
+	s32 TextureUnit1;
+};
+
+class COpenGL3MaterialOneTextureBlendCB : public COpenGL3MaterialBaseCB
+{
+public:
+	COpenGL3MaterialOneTextureBlendCB();
+
+	virtual void OnSetMaterial(const SMaterial& material);
+	virtual void OnSetConstants(IMaterialRendererServices* services, s32 userData);
+
+protected:
+	bool FirstUpdate;
+
+	s32 TMatrix0ID;
+	s32 BlendTypeID;
+	s32 TextureUsage0ID;
+	s32 TextureUnit0ID;
+
+	s32 BlendType;
+	s32 TextureUsage0;
+	s32 TextureUnit0;
+};
+
+}
+}
diff --git a/source/Irrlicht/OpenGL/MaterialRenderer.cpp b/source/Irrlicht/OpenGL/MaterialRenderer.cpp
new file mode 100644
index 0000000..d7aa483
--- /dev/null
+++ b/source/Irrlicht/OpenGL/MaterialRenderer.cpp
@@ -0,0 +1,481 @@
+// Copyright (C) 2014 Patryk Nadrowski
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#include "MaterialRenderer.h"
+
+#include "EVertexAttributes.h"
+#include "IGPUProgrammingServices.h"
+#include "IShaderConstantSetCallBack.h"
+#include "IVideoDriver.h"
+#include "os.h"
+
+#include "Driver.h"
+
+#include "COpenGLCoreTexture.h"
+#include "COpenGLCoreCacheHandler.h"
+
+namespace irr
+{
+namespace video
+{
+
+
+COpenGL3MaterialRenderer::COpenGL3MaterialRenderer(COpenGL3DriverBase* driver,
+		s32& outMaterialTypeNr,
+		const c8* vertexShaderProgram,
+		const c8* pixelShaderProgram,
+		IShaderConstantSetCallBack* callback,
+		E_MATERIAL_TYPE baseMaterial,
+		s32 userData)
+	: Driver(driver), CallBack(callback), Alpha(false), Blending(false), FixedBlending(false), Program(0), UserData(userData)
+{
+#ifdef _DEBUG
+	setDebugName("MaterialRenderer");
+#endif
+
+	switch (baseMaterial)
+	{
+	case EMT_TRANSPARENT_VERTEX_ALPHA:
+	case EMT_TRANSPARENT_ALPHA_CHANNEL:
+		Alpha = true;
+		break;
+	case EMT_TRANSPARENT_ADD_COLOR:
+		FixedBlending = true;
+		break;
+	case EMT_ONETEXTURE_BLEND:
+		Blending = true;
+		break;
+	default:
+		break;
+	}
+
+	if (CallBack)
+		CallBack->grab();
+
+	init(outMaterialTypeNr, vertexShaderProgram, pixelShaderProgram);
+}
+
+
+COpenGL3MaterialRenderer::COpenGL3MaterialRenderer(COpenGL3DriverBase* driver,
+					IShaderConstantSetCallBack* callback,
+					E_MATERIAL_TYPE baseMaterial, s32 userData)
+: Driver(driver), CallBack(callback), Alpha(false), Blending(false), FixedBlending(false), Program(0), UserData(userData)
+{
+	switch (baseMaterial)
+	{
+	case EMT_TRANSPARENT_VERTEX_ALPHA:
+	case EMT_TRANSPARENT_ALPHA_CHANNEL:
+		Alpha = true;
+		break;
+	case EMT_TRANSPARENT_ADD_COLOR:
+		FixedBlending = true;
+		break;
+	case EMT_ONETEXTURE_BLEND:
+		Blending = true;
+		break;
+	default:
+		break;
+	}
+
+	if (CallBack)
+		CallBack->grab();
+}
+
+
+COpenGL3MaterialRenderer::~COpenGL3MaterialRenderer()
+{
+	if (CallBack)
+		CallBack->drop();
+
+	if (Program)
+	{
+		GLuint shaders[8];
+		GLint count;
+		glGetAttachedShaders(Program, 8, &count, shaders);
+
+		count=core::min_(count,8);
+		for (GLint i=0; i<count; ++i)
+			glDeleteShader(shaders[i]);
+		glDeleteProgram(Program);
+		Program = 0;
+	}
+
+	UniformInfo.clear();
+}
+
+GLuint COpenGL3MaterialRenderer::getProgram() const
+{
+	return Program;
+}
+
+void COpenGL3MaterialRenderer::init(s32& outMaterialTypeNr,
+		const c8* vertexShaderProgram,
+		const c8* pixelShaderProgram,
+		bool addMaterial)
+{
+	outMaterialTypeNr = -1;
+
+	Program = glCreateProgram();
+
+	if (!Program)
+		return;
+
+	if (vertexShaderProgram)
+		if (!createShader(GL_VERTEX_SHADER, vertexShaderProgram))
+			return;
+
+	if (pixelShaderProgram)
+		if (!createShader(GL_FRAGMENT_SHADER, pixelShaderProgram))
+			return;
+
+	for ( size_t i = 0; i < EVA_COUNT; ++i )
+			glBindAttribLocation( Program, i, sBuiltInVertexAttributeNames[i]);
+
+	if (!linkProgram())
+		return;
+
+	if (addMaterial)
+		outMaterialTypeNr = Driver->addMaterialRenderer(this);
+}
+
+
+bool COpenGL3MaterialRenderer::OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype)
+{
+	if (CallBack && Program)
+		CallBack->OnSetConstants(this, UserData);
+
+	return true;
+}
+
+
+void COpenGL3MaterialRenderer::OnSetMaterial(const video::SMaterial& material,
+				const video::SMaterial& lastMaterial,
+				bool resetAllRenderstates,
+				video::IMaterialRendererServices* services)
+{
+	COpenGL3CacheHandler* cacheHandler = Driver->getCacheHandler();
+
+	cacheHandler->setProgram(Program);
+
+	Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);
+
+	if (Alpha)
+	{
+		cacheHandler->setBlend(true);
+		cacheHandler->setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	}
+	else if (FixedBlending)
+	{
+		cacheHandler->setBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_COLOR);
+		cacheHandler->setBlend(true);
+	}
+	else if (Blending)
+	{
+		E_BLEND_FACTOR srcRGBFact,dstRGBFact,srcAlphaFact,dstAlphaFact;
+		E_MODULATE_FUNC modulate;
+		u32 alphaSource;
+		unpack_textureBlendFuncSeparate(srcRGBFact, dstRGBFact, srcAlphaFact, dstAlphaFact, modulate, alphaSource, material.MaterialTypeParam);
+
+		cacheHandler->setBlendFuncSeparate(Driver->getGLBlend(srcRGBFact), Driver->getGLBlend(dstRGBFact),
+			Driver->getGLBlend(srcAlphaFact), Driver->getGLBlend(dstAlphaFact));
+
+		cacheHandler->setBlend(true);
+	}
+
+	if (CallBack)
+		CallBack->OnSetMaterial(material);
+}
+
+
+void COpenGL3MaterialRenderer::OnUnsetMaterial()
+{
+}
+
+
+bool COpenGL3MaterialRenderer::isTransparent() const
+{
+	return (Alpha || Blending || FixedBlending);
+}
+
+
+s32 COpenGL3MaterialRenderer::getRenderCapability() const
+{
+	return 0;
+}
+
+
+bool COpenGL3MaterialRenderer::createShader(GLenum shaderType, const char* shader)
+{
+	if (Program)
+	{
+		GLuint shaderHandle = glCreateShader(shaderType);
+		glShaderSource(shaderHandle, 1, &shader, NULL);
+		glCompileShader(shaderHandle);
+
+		GLint status = 0;
+
+		glGetShaderiv(shaderHandle, GL_COMPILE_STATUS, &status);
+
+		if (status != GL_TRUE)
+		{
+			os::Printer::log("GLSL shader failed to compile", ELL_ERROR);
+
+			GLint maxLength=0;
+			GLint length;
+
+			glGetShaderiv(shaderHandle, GL_INFO_LOG_LENGTH,
+					&maxLength);
+
+			if (maxLength)
+			{
+				GLchar *infoLog = new GLchar[maxLength];
+				glGetShaderInfoLog(shaderHandle, maxLength, &length, infoLog);
+				os::Printer::log(reinterpret_cast<const c8*>(infoLog), ELL_ERROR);
+				delete [] infoLog;
+			}
+
+			return false;
+		}
+
+		glAttachShader(Program, shaderHandle);
+	}
+
+	return true;
+}
+
+
+bool COpenGL3MaterialRenderer::linkProgram()
+{
+	if (Program)
+	{
+		glLinkProgram(Program);
+
+		GLint status = 0;
+
+		glGetProgramiv(Program, GL_LINK_STATUS, &status);
+
+		if (!status)
+		{
+			os::Printer::log("GLSL shader program failed to link", ELL_ERROR);
+
+			GLint maxLength=0;
+			GLsizei length;
+
+			glGetProgramiv(Program, GL_INFO_LOG_LENGTH, &maxLength);
+
+			if (maxLength)
+			{
+				GLchar *infoLog = new GLchar[maxLength];
+				glGetProgramInfoLog(Program, maxLength, &length, infoLog);
+				os::Printer::log(reinterpret_cast<const c8*>(infoLog), ELL_ERROR);
+				delete [] infoLog;
+			}
+
+			return false;
+		}
+
+		GLint num = 0;
+
+		glGetProgramiv(Program, GL_ACTIVE_UNIFORMS, &num);
+
+		if (num == 0)
+			return true;
+
+		GLint maxlen = 0;
+
+		glGetProgramiv(Program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxlen);
+
+		if (maxlen == 0)
+		{
+			os::Printer::log("GLSL: failed to retrieve uniform information", ELL_ERROR);
+			return false;
+		}
+
+		// seems that some implementations use an extra null terminator.
+		++maxlen;
+		c8 *buf = new c8[maxlen];
+
+		UniformInfo.clear();
+		UniformInfo.reallocate(num);
+
+		for (GLint i=0; i < num; ++i)
+		{
+			SUniformInfo ui;
+			memset(buf, 0, maxlen);
+
+			GLint size;
+			glGetActiveUniform(Program, i, maxlen, 0, &size, &ui.type, reinterpret_cast<GLchar*>(buf));
+
+            core::stringc name = "";
+
+			// array support, workaround for some bugged drivers.
+			for (s32 i = 0; i < maxlen; ++i)
+			{
+				if (buf[i] == '[' || buf[i] == '\0')
+					break;
+
+                name += buf[i];
+			}
+
+			ui.name = name;
+			ui.location = glGetUniformLocation(Program, buf);
+
+			UniformInfo.push_back(ui);
+		}
+
+		delete [] buf;
+	}
+
+	return true;
+}
+
+
+void COpenGL3MaterialRenderer::setBasicRenderStates(const SMaterial& material,
+						const SMaterial& lastMaterial,
+						bool resetAllRenderstates)
+{
+	Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);
+}
+
+s32 COpenGL3MaterialRenderer::getVertexShaderConstantID(const c8* name)
+{
+	return getPixelShaderConstantID(name);
+}
+
+s32 COpenGL3MaterialRenderer::getPixelShaderConstantID(const c8* name)
+{
+	for (u32 i = 0; i < UniformInfo.size(); ++i)
+	{
+		if (UniformInfo[i].name == name)
+			return i;
+	}
+
+	return -1;
+}
+
+void COpenGL3MaterialRenderer::setVertexShaderConstant(const f32* data, s32 startRegister, s32 constantAmount)
+{
+	os::Printer::log("Cannot set constant, please use high level shader call instead.", ELL_WARNING);
+}
+
+void COpenGL3MaterialRenderer::setPixelShaderConstant(const f32* data, s32 startRegister, s32 constantAmount)
+{
+	os::Printer::log("Cannot set constant, use high level shader call.", ELL_WARNING);
+}
+
+bool COpenGL3MaterialRenderer::setVertexShaderConstant(s32 index, const f32* floats, int count)
+{
+	return setPixelShaderConstant(index, floats, count);
+}
+
+bool COpenGL3MaterialRenderer::setVertexShaderConstant(s32 index, const s32* ints, int count)
+{
+	return setPixelShaderConstant(index, ints, count);
+}
+
+bool COpenGL3MaterialRenderer::setVertexShaderConstant(s32 index, const u32* ints, int count)
+{
+	return setPixelShaderConstant(index, ints, count);
+}
+
+bool COpenGL3MaterialRenderer::setPixelShaderConstant(s32 index, const f32* floats, int count)
+{
+	if(index < 0 || UniformInfo[index].location < 0)
+		return false;
+
+	bool status = true;
+
+	switch (UniformInfo[index].type)
+	{
+		case GL_FLOAT:
+			glUniform1fv(UniformInfo[index].location, count, floats);
+			break;
+		case GL_FLOAT_VEC2:
+			glUniform2fv(UniformInfo[index].location, count/2, floats);
+			break;
+		case GL_FLOAT_VEC3:
+			glUniform3fv(UniformInfo[index].location, count/3, floats);
+			break;
+		case GL_FLOAT_VEC4:
+			glUniform4fv(UniformInfo[index].location, count/4, floats);
+			break;
+		case GL_FLOAT_MAT2:
+			glUniformMatrix2fv(UniformInfo[index].location, count/4, false, floats);
+			break;
+		case GL_FLOAT_MAT3:
+			glUniformMatrix3fv(UniformInfo[index].location, count/9, false, floats);
+			break;
+		case GL_FLOAT_MAT4:
+			glUniformMatrix4fv(UniformInfo[index].location, count/16, false, floats);
+			break;
+		case GL_SAMPLER_2D:
+		case GL_SAMPLER_CUBE:
+			{
+				if(floats)
+				{
+					const GLint id = (GLint)(*floats);
+					glUniform1iv(UniformInfo[index].location, 1, &id);
+				}
+				else
+					status = false;
+			}
+			break;
+		default:
+			status = false;
+			break;
+	}
+
+	return status;
+}
+
+bool COpenGL3MaterialRenderer::setPixelShaderConstant(s32 index, const s32* ints, int count)
+{
+	if(index < 0 || UniformInfo[index].location < 0)
+		return false;
+
+	bool status = true;
+
+	switch (UniformInfo[index].type)
+	{
+		case GL_INT:
+		case GL_BOOL:
+			glUniform1iv(UniformInfo[index].location, count, ints);
+			break;
+		case GL_INT_VEC2:
+		case GL_BOOL_VEC2:
+			glUniform2iv(UniformInfo[index].location, count/2, ints);
+			break;
+		case GL_INT_VEC3:
+		case GL_BOOL_VEC3:
+			glUniform3iv(UniformInfo[index].location, count/3, ints);
+			break;
+		case GL_INT_VEC4:
+		case GL_BOOL_VEC4:
+			glUniform4iv(UniformInfo[index].location, count/4, ints);
+			break;
+		case GL_SAMPLER_2D:
+		case GL_SAMPLER_CUBE:
+			glUniform1iv(UniformInfo[index].location, 1, ints);
+			break;
+		default:
+			status = false;
+			break;
+	}
+
+	return status;
+}
+
+bool COpenGL3MaterialRenderer::setPixelShaderConstant(s32 index, const u32* ints, int count)
+{
+	os::Printer::log("Unsigned int support needs at least GLES 3.0", ELL_WARNING);
+	return false;
+}
+
+IVideoDriver* COpenGL3MaterialRenderer::getVideoDriver()
+{
+	return Driver;
+}
+
+}
+}
diff --git a/source/Irrlicht/OpenGL/MaterialRenderer.h b/source/Irrlicht/OpenGL/MaterialRenderer.h
new file mode 100644
index 0000000..f9282cc
--- /dev/null
+++ b/source/Irrlicht/OpenGL/MaterialRenderer.h
@@ -0,0 +1,99 @@
+// Copyright (C) 2014 Patryk Nadrowski
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in irrlicht.h
+
+#pragma once
+
+#include "EMaterialTypes.h"
+#include "IMaterialRenderer.h"
+#include "IMaterialRendererServices.h"
+#include "IGPUProgrammingServices.h"
+#include "irrArray.h"
+#include "irrString.h"
+
+#include "Common.h"
+
+namespace irr
+{
+namespace video
+{
+
+class COpenGL3DriverBase;
+
+class COpenGL3MaterialRenderer : public IMaterialRenderer, public IMaterialRendererServices
+{
+public:
+
+	COpenGL3MaterialRenderer(
+		COpenGL3DriverBase* driver,
+		s32& outMaterialTypeNr,
+		const c8* vertexShaderProgram = 0,
+		const c8* pixelShaderProgram = 0,
+		IShaderConstantSetCallBack* callback = 0,
+		E_MATERIAL_TYPE baseMaterial = EMT_SOLID,
+		s32 userData = 0);
+
+	virtual ~COpenGL3MaterialRenderer();
+
+	GLuint getProgram() const;
+
+	virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,
+		bool resetAllRenderstates, IMaterialRendererServices* services);
+
+	virtual bool OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype);
+
+	virtual void OnUnsetMaterial();
+
+	virtual bool isTransparent() const;
+
+	virtual s32 getRenderCapability() const;
+
+	void setBasicRenderStates(const SMaterial& material, const SMaterial& lastMaterial, bool resetAllRenderstates) override;
+
+	s32 getVertexShaderConstantID(const c8* name) override;
+	s32 getPixelShaderConstantID(const c8* name) override;
+	void setVertexShaderConstant(const f32* data, s32 startRegister, s32 constantAmount=1) override;
+	void setPixelShaderConstant(const f32* data, s32 startRegister, s32 constantAmount=1) override;
+	bool setVertexShaderConstant(s32 index, const f32* floats, int count) override;
+	bool setVertexShaderConstant(s32 index, const s32* ints, int count) override;
+	bool setVertexShaderConstant(s32 index, const u32* ints, int count) override;
+	bool setPixelShaderConstant(s32 index, const f32* floats, int count) override;
+	bool setPixelShaderConstant(s32 index, const s32* ints, int count) override;
+	bool setPixelShaderConstant(s32 index, const u32* ints, int count) override;
+
+	IVideoDriver* getVideoDriver() override;
+
+protected:
+
+	COpenGL3MaterialRenderer(COpenGL3DriverBase* driver,
+					IShaderConstantSetCallBack* callback = 0,
+					E_MATERIAL_TYPE baseMaterial = EMT_SOLID,
+					s32 userData = 0);
+
+	void init(s32& outMaterialTypeNr, const c8* vertexShaderProgram, const c8* pixelShaderProgram, bool addMaterial = true);
+
+	bool createShader(GLenum shaderType, const char* shader);
+	bool linkProgram();
+
+	COpenGL3DriverBase* Driver;
+	IShaderConstantSetCallBack* CallBack;
+
+	bool Alpha;
+	bool Blending;
+	bool FixedBlending;
+
+	struct SUniformInfo
+	{
+		core::stringc name;
+		GLenum type;
+		GLint location;
+	};
+
+	GLuint Program;
+	core::array<SUniformInfo> UniformInfo;
+	s32 UserData;
+};
+
+
+}
+}
diff --git a/source/Irrlicht/OpenGL/Renderer2D.cpp b/source/Irrlicht/OpenGL/Renderer2D.cpp
new file mode 100644
index 0000000..96bdbda
--- /dev/null
+++ b/source/Irrlicht/OpenGL/Renderer2D.cpp
@@ -0,0 +1,83 @@
+// Copyright (C) 2014 Patryk Nadrowski
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in Irrlicht.h
+
+#include "Renderer2D.h"
+
+#include "IGPUProgrammingServices.h"
+#include "os.h"
+
+#include "Driver.h"
+
+#include "COpenGLCoreFeature.h"
+#include "COpenGLCoreTexture.h"
+#include "COpenGLCoreCacheHandler.h"
+
+namespace irr
+{
+namespace video
+{
+
+COpenGL3Renderer2D::COpenGL3Renderer2D(const c8* vertexShaderProgram, const c8* pixelShaderProgram, COpenGL3DriverBase* driver, bool withTexture) :
+	COpenGL3MaterialRenderer(driver, 0, EMT_SOLID),
+	WithTexture(withTexture)
+{
+#ifdef _DEBUG
+	setDebugName("Renderer2D");
+#endif
+
+	int Temp = 0;
+
+	init(Temp, vertexShaderProgram, pixelShaderProgram, false);
+
+	COpenGL3CacheHandler* cacheHandler = Driver->getCacheHandler();
+
+	cacheHandler->setProgram(Program);
+
+	// These states don't change later.
+
+	ThicknessID = getPixelShaderConstantID("uThickness");
+	if ( WithTexture )
+	{
+		TextureUsageID = getPixelShaderConstantID("uTextureUsage");
+		s32 TextureUnitID = getPixelShaderConstantID("uTextureUnit");
+
+		s32 TextureUnit = 0;
+		setPixelShaderConstant(TextureUnitID, &TextureUnit, 1);
+
+		s32 TextureUsage = 0;
+		setPixelShaderConstant(TextureUsageID, &TextureUsage, 1);
+	}
+
+	cacheHandler->setProgram(0);
+}
+
+COpenGL3Renderer2D::~COpenGL3Renderer2D()
+{
+}
+
+void COpenGL3Renderer2D::OnSetMaterial(const video::SMaterial& material,
+				const video::SMaterial& lastMaterial,
+				bool resetAllRenderstates,
+				video::IMaterialRendererServices* services)
+{
+	Driver->getCacheHandler()->setProgram(Program);
+	Driver->setBasicRenderStates(material, lastMaterial, resetAllRenderstates);
+
+	f32 Thickness = (material.Thickness > 0.f) ? material.Thickness : 1.f;
+	setPixelShaderConstant(ThicknessID, &Thickness, 1);
+
+	if ( WithTexture )
+	{
+		s32 TextureUsage = material.TextureLayer[0].Texture ? 1 : 0;
+		setPixelShaderConstant(TextureUsageID, &TextureUsage, 1);
+	}
+}
+
+bool COpenGL3Renderer2D::OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype)
+{
+	return true;
+}
+
+}
+}
diff --git a/source/Irrlicht/OpenGL/Renderer2D.h b/source/Irrlicht/OpenGL/Renderer2D.h
new file mode 100644
index 0000000..426a8b7
--- /dev/null
+++ b/source/Irrlicht/OpenGL/Renderer2D.h
@@ -0,0 +1,33 @@
+// Copyright (C) 2014 Patryk Nadrowski
+// This file is part of the "Irrlicht Engine".
+// For conditions of distribution and use, see copyright notice in Irrlicht.h
+
+#pragma once
+
+#include "MaterialRenderer.h"
+
+namespace irr
+{
+namespace video
+{
+
+class COpenGL3Renderer2D : public COpenGL3MaterialRenderer
+{
+public:
+	COpenGL3Renderer2D(const c8* vertexShaderProgram, const c8* pixelShaderProgram, COpenGL3DriverBase* driver, bool withTexture);
+	~COpenGL3Renderer2D();
+
+	virtual void OnSetMaterial(const SMaterial& material, const SMaterial& lastMaterial,
+		bool resetAllRenderstates, IMaterialRendererServices* services);
+
+	virtual bool OnRender(IMaterialRendererServices* service, E_VERTEX_TYPE vtxtype);
+
+protected:
+	bool WithTexture;
+	s32 ThicknessID;
+	s32 TextureUsageID;
+};
+
+
+}
+}
diff --git a/source/Irrlicht/OpenGL3/Driver.cpp b/source/Irrlicht/OpenGL3/Driver.cpp
new file mode 100644
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
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
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
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;
+	};
+
+}
+}
diff --git a/source/Irrlicht/mt_opengl_loader.cpp b/source/Irrlicht/mt_opengl_loader.cpp
index 96d7587..26de3d3 100755
--- a/source/Irrlicht/mt_opengl_loader.cpp
+++ b/source/Irrlicht/mt_opengl_loader.cpp
@@ -756,11 +756,22 @@ void OpenGLProcedures::LoadAllProcedures(irr::video::IContextManager *cmgr)
 	if (!NamedBufferPageCommitment) NamedBufferPageCommitment = (PFNGLNAMEDBUFFERPAGECOMMITMENTPROC_MT)cmgr->getProcAddress("glNamedBufferPageCommitmentARB");
 	if (!TexPageCommitment) TexPageCommitment = (PFNGLTEXPAGECOMMITMENTPROC_MT)cmgr->getProcAddress("glTexPageCommitmentARB");
 
+	// OpenGL 3 way to enumerate extensions
+	int ext_count = 0;
+	GetIntegerv(NUM_EXTENSIONS, &ext_count);
+	extensions.reserve(ext_count);
+	for (int k = 0; k < ext_count; k++)
+		extensions.emplace((char *)GetStringi(EXTENSIONS, k));
+	if (ext_count)
+		return;
+
+	// OpenGL 2 / ES 2 way to enumerate extensions
+	auto ext_str = GetString(EXTENSIONS);
+	if (!ext_str)
+		return;
 	// get the extension string, chop it up
-	std::string ext_string = std::string((char*)GetString(EXTENSIONS));
-	std::stringstream ext_ss(ext_string);
+	std::stringstream ext_ss((char*)ext_str);
 	std::string tmp;
 	while (std::getline(ext_ss, tmp, ' '))
 		extensions.emplace(tmp);
-
 }