Copy irrlichtmt to <root>/irr/

irr/src/OpenGL/Common.h

@@ -0,0 +1,57 @@
+// 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
+
+#include "irrTypes.h"
+// even though we have mt_opengl.h our driver code still uses GL_* constants
+#if defined(_IRR_COMPILE_WITH_SDL_DEVICE_)
+#include <SDL_video.h>
+#include <SDL_opengl.h>
+#else
+#include "vendor/gl.h"
+#endif
+
+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;
+
+enum class OpenGLSpec : u8
+{
+	Core,
+	Compat,
+	ES,
+	// WebGL, // TODO
+};
+
+struct OpenGLVersion
+{
+	OpenGLSpec Spec;
+	u8 Major;
+	u8 Minor;
+	u8 Release;
+};
+
+}
+}

irr/src/OpenGL/Driver.h

@@ -0,0 +1,399 @@
+// 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 3d line.
+	virtual void draw3DLine(const core::vector3df &start,
+			const core::vector3df &end,
+			SColor color = SColor(255, 255, 255, 255)) override;
+
+	//! Returns the name of the video driver.
+	const char *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 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 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:
+	virtual bool genericDriverInit(const core::dimension2d<u32> &screenSize, bool stencilBuffer);
+
+	void initVersion();
+	virtual OpenGLVersion getVersionFromOpenGL() const = 0;
+
+	virtual void initFeatures() = 0;
+
+	bool isVersionAtLeast(int major, int minor = 0) const noexcept;
+
+	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, int vertexCount, 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::stringc Name;
+	core::stringc VendorName;
+	SIrrlichtCreationParameters Params;
+	OpenGLVersion Version;
+
+	//! 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;
+
+	using FColorConverter = void (*)(const void *source, s32 count, void *dest);
+	struct STextureFormatInfo
+	{
+		GLenum InternalFormat;
+		GLenum PixelFormat;
+		GLenum PixelType;
+		FColorConverter Converter;
+	};
+	STextureFormatInfo TextureFormats[ECF_UNKNOWN] = {};
+
+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;
+
+	void printTextureFormats();
+
+	void addDummyMaterial(E_MATERIAL_TYPE type);
+
+	unsigned QuadIndexCount;
+	GLuint QuadIndexBuffer = 0;
+	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

irr/src/OpenGL/ExtensionHandler.cpp

@@ -0,0 +1,61 @@
+// 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 "os.h"
+#include <mt_opengl.h>
+
+// FIXME: this basically duplicates what mt_opengl.h already does
+
+namespace irr
+{
+namespace video
+{
+void COpenGL3ExtensionHandler::initExtensionsOld()
+{
+	auto extensions_string = reinterpret_cast<const char *>(GL.GetString(GL_EXTENSIONS));
+	const char *pos = extensions_string;
+	while (const char *next = strchr(pos, ' ')) {
+		addExtension(std::string{pos, next});
+		pos = next + 1;
+	}
+	addExtension(pos);
+	extensionsLoaded();
+}
+
+void COpenGL3ExtensionHandler::initExtensionsNew()
+{
+	int ext_count = GetInteger(GL_NUM_EXTENSIONS);
+	for (int k = 0; k < ext_count; k++)
+		addExtension(reinterpret_cast<const char *>(GL.GetStringi(GL_EXTENSIONS, k)));
+	extensionsLoaded();
+}
+
+void COpenGL3ExtensionHandler::addExtension(std::string &&name)
+{
+	Extensions.emplace(std::move(name));
+}
+
+bool COpenGL3ExtensionHandler::queryExtension(const std::string &name) const noexcept
+{
+	return Extensions.find(name) != Extensions.end();
+}
+
+void COpenGL3ExtensionHandler::extensionsLoaded()
+{
+	os::Printer::log((std::string("Loaded ") + std::to_string(Extensions.size()) + " extensions:").c_str(), ELL_DEBUG);
+	for (const auto &it : Extensions)
+		os::Printer::log((std::string("  ") + it).c_str(), ELL_DEBUG);
+	for (size_t j = 0; j < IRR_OGLES_Feature_Count; ++j)
+		FeatureAvailable[j] = queryExtension(getFeatureString(j));
+}
+
+} // end namespace video
+} // end namespace irr

irr/src/OpenGL/ExtensionHandler.h

@@ -0,0 +1,170 @@
+// 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 <unordered_set>
+
+#include "EDriverFeatures.h"
+#include "irrTypes.h"
+#include "os.h"
+
+#include "Common.h"
+#include <mt_opengl.h> // must be after Common.h
+
+#include "COGLESCoreExtensionHandler.h"
+
+namespace irr
+{
+namespace video
+{
+
+class COpenGL3ExtensionHandler : public COGLESCoreExtensionHandler
+{
+public:
+	COpenGL3ExtensionHandler() :
+			COGLESCoreExtensionHandler() {}
+
+	void initExtensionsOld();
+	void initExtensionsNew();
+
+	/// Checks whether a named extension is present
+	bool queryExtension(const std::string &name) const noexcept;
+
+	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_STENCIL_BUFFER:
+			return StencilBuffer;
+		default:
+			return false;
+		};
+	}
+
+	static GLint GetInteger(GLenum key)
+	{
+		GLint val = 0;
+		GL.GetIntegerv(key, &val);
+		return val;
+	};
+
+	inline void irrGlActiveTexture(GLenum texture)
+	{
+		GL.ActiveTexture(texture);
+	}
+
+	inline void irrGlCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border,
+			GLsizei imageSize, const void *data)
+	{
+		os::Printer::log("Compressed textures aren't supported", ELL_ERROR);
+	}
+
+	inline void irrGlCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
+			GLenum format, GLsizei imageSize, const void *data)
+	{
+		os::Printer::log("Compressed textures aren't supported", ELL_ERROR);
+	}
+
+	inline void irrGlUseProgram(GLuint prog)
+	{
+		GL.UseProgram(prog);
+	}
+
+	inline void irrGlBindFramebuffer(GLenum target, GLuint framebuffer)
+	{
+		GL.BindFramebuffer(target, framebuffer);
+	}
+
+	inline void irrGlDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
+	{
+		GL.DeleteFramebuffers(n, framebuffers);
+	}
+
+	inline void irrGlGenFramebuffers(GLsizei n, GLuint *framebuffers)
+	{
+		GL.GenFramebuffers(n, framebuffers);
+	}
+
+	inline GLenum irrGlCheckFramebufferStatus(GLenum target)
+	{
+		return GL.CheckFramebufferStatus(target);
+	}
+
+	inline void irrGlFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+	{
+		GL.FramebufferTexture2D(target, attachment, textarget, texture, level);
+	}
+
+	inline void irrGlGenerateMipmap(GLenum target)
+	{
+		GL.GenerateMipmap(target);
+	}
+
+	inline void irrGlDrawBuffer(GLenum mode)
+	{
+		GL.DrawBuffer(mode);
+	}
+
+	inline void irrGlDrawBuffers(GLsizei n, const GLenum *bufs)
+	{
+		GL.DrawBuffers(n, bufs);
+	}
+
+	inline void irrGlBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
+	{
+		GL.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+	}
+
+	inline void irrGlBlendEquation(GLenum mode)
+	{
+		GL.BlendEquation(mode);
+	}
+
+	bool AnisotropicFilterSupported = false;
+	bool BlendMinMaxSupported = false;
+
+private:
+	void addExtension(std::string &&name);
+	void extensionsLoaded();
+
+	std::unordered_set<std::string> Extensions;
+};
+
+}
+}

irr/src/OpenGL/FixedPipelineRenderer.cpp

@@ -0,0 +1,186 @@
+// Copyright (C) 2023 Vitaliy Lobachevskiy
+// 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),
+		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");
+
+		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_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.TextureLayers[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_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.TextureLayers[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);
+}
+
+}
+}

irr/src/OpenGL/FixedPipelineRenderer.h

@@ -0,0 +1,101 @@
+// Copyright (C) 2023 Vitaliy Lobachevskiy
+// 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 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 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;
+};
+
+}
+}

irr/src/OpenGL/MaterialRenderer.cpp

@@ -0,0 +1,429 @@
+// 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), 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_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), Program(0), UserData(userData)
+{
+	switch (baseMaterial) {
+	case EMT_TRANSPARENT_VERTEX_ALPHA:
+	case EMT_TRANSPARENT_ALPHA_CHANNEL:
+		Alpha = 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;
+		GL.GetAttachedShaders(Program, 8, &count, shaders);
+
+		count = core::min_(count, 8);
+		for (GLint i = 0; i < count; ++i)
+			GL.DeleteShader(shaders[i]);
+		GL.DeleteProgram(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 = GL.CreateProgram();
+
+	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)
+		GL.BindAttribLocation(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 (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);
+}
+
+s32 COpenGL3MaterialRenderer::getRenderCapability() const
+{
+	return 0;
+}
+
+bool COpenGL3MaterialRenderer::createShader(GLenum shaderType, const char *shader)
+{
+	if (Program) {
+		GLuint shaderHandle = GL.CreateShader(shaderType);
+		GL.ShaderSource(shaderHandle, 1, &shader, NULL);
+		GL.CompileShader(shaderHandle);
+
+		GLint status = 0;
+
+		GL.GetShaderiv(shaderHandle, GL_COMPILE_STATUS, &status);
+
+		if (status != GL_TRUE) {
+			os::Printer::log("GLSL shader failed to compile", ELL_ERROR);
+
+			GLint maxLength = 0;
+			GLint length;
+
+			GL.GetShaderiv(shaderHandle, GL_INFO_LOG_LENGTH,
+					&maxLength);
+
+			if (maxLength) {
+				GLchar *infoLog = new GLchar[maxLength];
+				GL.GetShaderInfoLog(shaderHandle, maxLength, &length, infoLog);
+				os::Printer::log(reinterpret_cast<const c8 *>(infoLog), ELL_ERROR);
+				delete[] infoLog;
+			}
+
+			return false;
+		}
+
+		GL.AttachShader(Program, shaderHandle);
+	}
+
+	return true;
+}
+
+bool COpenGL3MaterialRenderer::linkProgram()
+{
+	if (Program) {
+		GL.LinkProgram(Program);
+
+		GLint status = 0;
+
+		GL.GetProgramiv(Program, GL_LINK_STATUS, &status);
+
+		if (!status) {
+			os::Printer::log("GLSL shader program failed to link", ELL_ERROR);
+
+			GLint maxLength = 0;
+			GLsizei length;
+
+			GL.GetProgramiv(Program, GL_INFO_LOG_LENGTH, &maxLength);
+
+			if (maxLength) {
+				GLchar *infoLog = new GLchar[maxLength];
+				GL.GetProgramInfoLog(Program, maxLength, &length, infoLog);
+				os::Printer::log(reinterpret_cast<const c8 *>(infoLog), ELL_ERROR);
+				delete[] infoLog;
+			}
+
+			return false;
+		}
+
+		GLint num = 0;
+
+		GL.GetProgramiv(Program, GL_ACTIVE_UNIFORMS, &num);
+
+		if (num == 0)
+			return true;
+
+		GLint maxlen = 0;
+
+		GL.GetProgramiv(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;
+			GL.GetActiveUniform(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 = GL.GetUniformLocation(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;
+}
+
+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:
+		GL.Uniform1fv(UniformInfo[index].location, count, floats);
+		break;
+	case GL_FLOAT_VEC2:
+		GL.Uniform2fv(UniformInfo[index].location, count / 2, floats);
+		break;
+	case GL_FLOAT_VEC3:
+		GL.Uniform3fv(UniformInfo[index].location, count / 3, floats);
+		break;
+	case GL_FLOAT_VEC4:
+		GL.Uniform4fv(UniformInfo[index].location, count / 4, floats);
+		break;
+	case GL_FLOAT_MAT2:
+		GL.UniformMatrix2fv(UniformInfo[index].location, count / 4, false, floats);
+		break;
+	case GL_FLOAT_MAT3:
+		GL.UniformMatrix3fv(UniformInfo[index].location, count / 9, false, floats);
+		break;
+	case GL_FLOAT_MAT4:
+		GL.UniformMatrix4fv(UniformInfo[index].location, count / 16, false, floats);
+		break;
+	case GL_SAMPLER_2D:
+	case GL_SAMPLER_CUBE: {
+		if (floats) {
+			const GLint id = (GLint)(*floats);
+			GL.Uniform1iv(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:
+		GL.Uniform1iv(UniformInfo[index].location, count, ints);
+		break;
+	case GL_INT_VEC2:
+	case GL_BOOL_VEC2:
+		GL.Uniform2iv(UniformInfo[index].location, count / 2, ints);
+		break;
+	case GL_INT_VEC3:
+	case GL_BOOL_VEC3:
+		GL.Uniform3iv(UniformInfo[index].location, count / 3, ints);
+		break;
+	case GL_INT_VEC4:
+	case GL_BOOL_VEC4:
+		GL.Uniform4iv(UniformInfo[index].location, count / 4, ints);
+		break;
+	case GL_SAMPLER_2D:
+	case GL_SAMPLER_CUBE:
+		GL.Uniform1iv(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;
+}
+
+}
+}

irr/src/OpenGL/MaterialRenderer.h

@@ -0,0 +1,93 @@
+// 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;
+	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;
+
+	struct SUniformInfo
+	{
+		core::stringc name;
+		GLenum type;
+		GLint location;
+	};
+
+	GLuint Program;
+	core::array<SUniformInfo> UniformInfo;
+	s32 UserData;
+};
+
+}
+}

irr/src/OpenGL/Renderer2D.cpp

@@ -0,0 +1,81 @@
+// 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.TextureLayers[0].Texture ? 1 : 0;
+		setPixelShaderConstant(TextureUsageID, &TextureUsage, 1);
+	}
+}
+
+bool COpenGL3Renderer2D::OnRender(IMaterialRendererServices *service, E_VERTEX_TYPE vtxtype)
+{
+	return true;
+}
+
+}
+}

irr/src/OpenGL/Renderer2D.h

@@ -0,0 +1,32 @@
+// 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;
+};
+
+}
+}