Prepared OpenGL CacheHandler class for the new architecture of Irrlicht's...

Prepared OpenGL CacheHandler class for the new architecture of Irrlicht's shared OpenGL drivers code.

git-svn-id: svn://svn.code.sf.net/p/irrlicht/code/trunk@5165 dfc29bdd-3216-0410-991c-e03cc46cb475

source/Irrlicht/COGLCoreCacheHandler.h

+// 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
+
+#ifndef __C_OGLCORE_CACHE_HANDLER_H_INCLUDED__
+#define __C_OGLCORE_CACHE_HANDLER_H_INCLUDED__
+
+#include "IrrCompileConfig.h"
+
+#if defined(_IRR_COMPILE_WITH_OPENGL_) || defined(_IRR_COMPILE_WITH_OGLES1_) || defined(_IRR_COMPILE_WITH_OGLES2_)
+
+#include "EDriverTypes.h"
+#include "SMaterial.h"
+
+namespace irr
+{
+namespace video
+{
+
+template <class TOGLDriver, class TOGLTexture>
+class COGLCoreCacheHandler
+{
+	class STextureCache
+	{
+	public:
+		STextureCache(COGLCoreCacheHandler* cacheHandler, u32 textureCount) :
+			CacheHandler(cacheHandler), DriverType(cacheHandler->getDriverType()), TextureCount(textureCount)
+		{
+			for (u32 i = 0; i < MATERIAL_MAX_TEXTURES; ++i)
+			{
+				Texture[i] = 0;
+			}
+		}
+
+		~STextureCache()
+		{
+			clear();
+		}
+
+		const TOGLTexture* operator[](int index) const
+		{
+			if (static_cast<u32>(index) < MATERIAL_MAX_TEXTURES)
+				return Texture[static_cast<u32>(index)];
+
+			return 0;
+		}
+
+		const TOGLTexture* get(u32 index) const
+		{
+			if (index < MATERIAL_MAX_TEXTURES)
+				return Texture[index];
+
+			return 0;
+		}
+
+		bool set(u32 index, const ITexture* texture)
+		{
+			bool status = false;
+
+			E_DRIVER_TYPE type = DriverType;
+
+			if (index < MATERIAL_MAX_TEXTURES && index < TextureCount)
+			{
+				CacheHandler->setActiveTexture(GL_TEXTURE0 + index);
+
+				const TOGLTexture* prevTexture = Texture[index];
+
+				if (texture != prevTexture)
+				{
+					if (texture)
+					{
+						type = texture->getDriverType();
+
+						if (type == DriverType)
+						{
+							texture->grab();
+
+#if defined(IRR_OPENGL_VERSION) && IRR_OPENGL_VERSION < 20
+							if (!prevTexture)
+								glEnable(GL_TEXTURE_2D);
+#endif
+
+							glBindTexture(GL_TEXTURE_2D, static_cast<const TOGLTexture*>(texture)->getOpenGLTextureName());
+						}
+						else
+						{
+							texture = 0;
+
+							os::Printer::log("Fatal Error: Tried to set a texture not owned by this driver.", ELL_ERROR);
+						}
+					}
+
+					if (!texture)
+					{
+						glBindTexture(GL_TEXTURE_2D, 0);
+
+#if defined(IRR_OPENGL_VERSION) && IRR_OPENGL_VERSION < 20
+						if (prevTexture)
+							glDisable(GL_TEXTURE_2D);
+#endif
+					}
+
+					Texture[index] = static_cast<const TOGLTexture*>(texture);
+
+					if (prevTexture)
+						prevTexture->drop();
+				}
+
+				status = true;
+			}
+
+			return (status && type == DriverType);
+		}
+
+		void remove(ITexture* texture)
+		{
+			if (!texture)
+				return;
+
+			for (u32 i = 0; i < MATERIAL_MAX_TEXTURES; ++i)
+			{
+				if (Texture[i] == texture)
+				{
+					Texture[i] = 0;
+
+					texture->drop();
+				}
+			}
+		}
+
+		void clear()
+		{
+			for (u32 i = 0; i < MATERIAL_MAX_TEXTURES; ++i)
+			{
+				if (Texture[i])
+				{
+					const TOGLTexture* prevTexture = Texture[i];
+
+					Texture[i] = 0;
+
+					prevTexture->drop();
+				}
+			}
+		}
+
+	private:
+		COGLCoreCacheHandler* CacheHandler;
+
+		E_DRIVER_TYPE DriverType;
+
+		const TOGLTexture* Texture[MATERIAL_MAX_TEXTURES];
+		u32 TextureCount;
+	};
+
+public:
+	COGLCoreCacheHandler(TOGLDriver* driver) :
+		Driver(driver), TextureCache(STextureCache(this, Driver->getFeature().TextureUnit)), FrameBufferCount(0),
+		BlendEquation(0), BlendSourceRGB(0), BlendDestinationRGB(0), BlendSourceAlpha(0), BlendDestinationAlpha(0),
+		Blend(0), ColorMask(0), CullFaceMode(GL_BACK), CullFace(false), DepthFunc(GL_LESS), DepthMask(true),
+		FrameBufferID(0), ProgramID(0), ActiveTexture(GL_TEXTURE0), ViewportX(0), ViewportY(0)
+	{
+		const COGLCoreFeature& feature = Driver->getFeature();
+
+		FrameBufferCount = core::max_(static_cast<GLuint>(1), static_cast<GLuint>(feature.MultipleRenderTarget));
+
+		BlendEquation = new GLenum[FrameBufferCount];
+		BlendSourceRGB = new GLenum[FrameBufferCount];
+		BlendDestinationRGB = new GLenum[FrameBufferCount];
+		BlendSourceAlpha = new GLenum[FrameBufferCount];
+		BlendDestinationAlpha = new GLenum[FrameBufferCount];
+		Blend = new bool[FrameBufferCount];
+
+		ColorMask = new bool[FrameBufferCount][4];
+
+		// Initial OpenGL values from specification.
+
+		if (feature.BlendOperation)
+		{
+			Driver->irrGlBlendEquation(GL_FUNC_ADD);
+		}
+
+		for (u32 i = 0; i < FrameBufferCount; ++i)
+		{
+			BlendEquation[i] = GL_FUNC_ADD;
+
+			BlendSourceRGB[i] = GL_ONE;
+			BlendDestinationRGB[i] = GL_ZERO;
+			BlendSourceAlpha[i] = GL_ONE;
+			BlendDestinationAlpha[i] = GL_ZERO;
+
+			Blend[i] = false;
+
+			for (u32 j = 0; j < 4; ++j)
+				ColorMask[i][j] = true;
+		}
+
+		glBlendFunc(GL_ONE, GL_ZERO);
+		glDisable(GL_BLEND);
+
+		glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
+
+		glCullFace(CullFaceMode);
+		glDisable(GL_CULL_FACE);
+
+		glDepthFunc(DepthFunc);
+		glDepthMask(GL_TRUE);
+
+		Driver->irrGlActiveTexture(ActiveTexture);
+
+#if defined(IRR_OPENGL_VERSION) && IRR_OPENGL_VERSION < 20
+		glDisable(GL_TEXTURE_2D);
+#endif
+
+		const core::dimension2d<u32> ScreenSize = Driver->getScreenSize();
+		ViewportWidth = ScreenSize.Width;
+		ViewportHeight = ScreenSize.Height;
+		glViewport(ViewportX, ViewportY, ViewportWidth, ViewportHeight);
+	}
+
+	virtual ~COGLCoreCacheHandler()
+	{
+		delete[] BlendEquation;
+		delete[] BlendSourceRGB;
+		delete[] BlendDestinationRGB;
+		delete[] BlendSourceAlpha;
+		delete[] BlendDestinationAlpha;
+		delete[] Blend;
+
+		delete[] ColorMask;
+	}
+
+	E_DRIVER_TYPE getDriverType() const
+	{
+		return Driver->getDriverType();
+	}
+
+	STextureCache& getTextureCache()
+	{
+		return TextureCache;
+	}
+
+	// Blending calls.
+
+	void setBlendEquation(GLenum mode)
+	{
+		if (BlendEquation[0] != mode)
+		{
+			Driver->irrGlBlendEquation(mode);
+
+			for (GLuint i = 0; i < FrameBufferCount; ++i)
+				BlendEquation[i] = mode;
+		}
+	}
+
+	void setBlendEquationIndexed(GLuint index, GLenum mode)
+	{
+		if (index < FrameBufferCount && BlendEquation[index] != mode)
+		{
+			Driver->irrGlBlendEquationIndexed(index, mode);
+
+			BlendEquation[index] = mode;
+		}
+	}
+
+	void setBlendFunc(GLenum source, GLenum destination)
+	{
+		if (BlendSourceRGB[0] != source || BlendDestinationRGB[0] != destination ||
+			BlendSourceAlpha[0] != source || BlendDestinationAlpha[0] != destination)
+		{
+			glBlendFunc(source, destination);
+
+			for (GLuint i = 0; i < FrameBufferCount; ++i)
+			{
+				BlendSourceRGB[i] = source;
+				BlendDestinationRGB[i] = destination;
+				BlendSourceAlpha[i] = source;
+				BlendDestinationAlpha[i] = destination;
+			}
+		}
+	}
+
+	void setBlendFuncSeparate(GLenum sourceRGB, GLenum destinationRGB, GLenum sourceAlpha, GLenum destinationAlpha)
+	{
+		if (sourceRGB != sourceAlpha || destinationRGB != destinationAlpha)
+		{
+			if (BlendSourceRGB[0] != sourceRGB || BlendDestinationRGB[0] != destinationRGB ||
+				BlendSourceAlpha[0] != sourceAlpha || BlendDestinationAlpha[0] != destinationAlpha)
+			{
+				Driver->irrGlBlendFuncSeparate(sourceRGB, destinationRGB, sourceAlpha, destinationAlpha);
+
+				for (GLuint i = 0; i < FrameBufferCount; ++i)
+				{
+					BlendSourceRGB[i] = sourceRGB;
+					BlendDestinationRGB[i] = destinationRGB;
+					BlendSourceAlpha[i] = sourceAlpha;
+					BlendDestinationAlpha[i] = destinationAlpha;
+				}
+			}
+		}
+		else
+		{
+			setBlendFunc(sourceRGB, destinationRGB);
+		}
+	}
+
+	void setBlendFuncIndexed(GLuint index, GLenum source, GLenum destination)
+	{
+		if (index < FrameBufferCount && (BlendSourceRGB[index] != source || BlendDestinationRGB[index] != destination ||
+			BlendSourceAlpha[index] != source || BlendDestinationAlpha[index] != destination))
+		{
+			Driver->irrGlBlendFuncIndexed(index, source, destination);
+
+			BlendSourceRGB[index] = source;
+			BlendDestinationRGB[index] = destination;
+			BlendSourceAlpha[index] = source;
+			BlendDestinationAlpha[index] = destination;
+		}
+	}
+
+	void setBlendFuncSeparateIndexed(GLuint index, GLenum sourceRGB, GLenum destinationRGB, GLenum sourceAlpha, GLenum destinationAlpha)
+	{
+		if (sourceRGB != sourceAlpha || destinationRGB != destinationAlpha)
+		{
+			if (index < FrameBufferCount && (BlendSourceRGB[index] != sourceRGB || BlendDestinationRGB[index] != destinationRGB ||
+				BlendSourceAlpha[index] != sourceAlpha || BlendDestinationAlpha[index] != destinationAlpha))
+			{
+				Driver->irrGlBlendFuncSeparateIndexed(index, sourceRGB, destinationRGB, sourceAlpha, destinationAlpha);
+
+				BlendSourceRGB[index] = sourceRGB;
+				BlendDestinationRGB[index] = destinationRGB;
+				BlendSourceAlpha[index] = sourceAlpha;
+				BlendDestinationAlpha[index] = destinationAlpha;
+			}
+		}
+		else
+		{
+			setBlendFuncIndexed(index, sourceRGB, destinationRGB);
+		}
+	}
+
+	void setBlend(bool enable)
+	{
+		if (Blend[0] != enable)
+		{
+			if (enable)
+				glEnable(GL_BLEND);
+			else
+				glDisable(GL_BLEND);
+
+			for (GLuint i = 0; i < FrameBufferCount; ++i)
+				Blend[i] = enable;
+		}
+	}
+
+	void setBlendIndexed(GLuint index, bool enable)
+	{
+		if (index < FrameBufferCount && Blend[index] != enable)
+		{
+			if (enable)
+				Driver->irrGlEnableIndexed(GL_BLEND, index);
+			else
+				Driver->irrGlDisableIndexed(GL_BLEND, index);
+
+			Blend[index] = enable;
+		}
+	}
+
+	// Color Mask.
+
+	void setColorMask(bool red, bool green, bool blue, bool alpha)
+	{
+		if (ColorMask[0][0] != red || ColorMask[0][1] != green || ColorMask[0][2] != blue || ColorMask[0][3] != alpha)
+		{
+			glColorMask(red, green, blue, alpha);
+
+			for (GLuint i = 0; i < FrameBufferCount; ++i)
+			{
+				ColorMask[i][0] = red;
+				ColorMask[i][1] = green;
+				ColorMask[i][2] = blue;
+				ColorMask[i][3] = alpha;
+			}
+		}
+	}
+
+	void setColorMaskIndexed(GLuint index, bool red, bool green, bool blue, bool alpha)
+	{
+		if (index < FrameBufferCount && (ColorMask[index][0] != red || ColorMask[index][1] != green || ColorMask[index][2] != blue || ColorMask[index][3] != alpha))
+		{
+			Driver->irrGlColorMaskIndexed(index, red, green, blue, alpha);
+
+			ColorMask[index][0] = red;
+			ColorMask[index][1] = green;
+			ColorMask[index][2] = blue;
+			ColorMask[index][3] = alpha;
+		}
+	}
+
+	// Cull face calls.
+
+	void setCullFaceFunc(GLenum mode)
+	{
+		if (CullFaceMode != mode)
+		{
+			glCullFace(mode);
+			CullFaceMode = mode;
+		}
+	}
+
+	void setCullFace(bool enable)
+	{
+		if (CullFace != enable)
+		{
+			if (enable)
+				glEnable(GL_CULL_FACE);
+			else
+				glDisable(GL_CULL_FACE);
+			CullFace = enable;
+		}
+	}
+
+	// Depth calls.
+
+	void setDepthFunc(GLenum mode)
+	{
+		if (DepthFunc != mode)
+		{
+			glDepthFunc(mode);
+			DepthFunc = mode;
+		}
+	}
+
+	void setDepthMask(bool enable)
+	{
+		if (DepthMask != enable)
+		{
+			if (enable)
+				glDepthMask(GL_TRUE);
+			else
+				glDepthMask(GL_FALSE);
+			DepthMask = enable;
+		}
+	}
+
+	// FBO calls.
+
+	void getFBO(GLuint& frameBufferID) const
+	{
+		frameBufferID = FrameBufferID;
+	}
+
+	void setFBO(GLuint frameBufferID)
+	{
+		if (FrameBufferID != frameBufferID)
+		{
+			Driver->irrGlBindFramebuffer(GL_FRAMEBUFFER, frameBufferID);
+
+			FrameBufferID = frameBufferID;
+		}
+	}
+
+	// Shaders
+
+	void setProgram(GLuint programID)
+	{
+		if (ProgramID != programID)
+		{
+			glUseProgram(programID);
+			ProgramID = programID;
+		}
+	}
+
+	// Texture calls.
+
+	void setActiveTexture(GLenum texture)
+	{
+		if (ActiveTexture != texture)
+		{
+			Driver->irrGlActiveTexture(texture);
+			ActiveTexture = texture;
+		}
+	}
+
+	// Viewport calls.
+
+	void setViewport(GLint viewportX, GLint viewportY, GLsizei viewportWidth, GLsizei viewportHeight)
+	{
+		if (ViewportX != viewportX || ViewportY != viewportY || ViewportWidth != viewportWidth || ViewportHeight != viewportHeight)
+		{
+			glViewport(viewportX, viewportY, viewportWidth, viewportHeight);
+			ViewportX = viewportX;
+			ViewportY = viewportY;
+			ViewportWidth = viewportWidth;
+			ViewportHeight = viewportHeight;
+		}
+	}
+
+protected:
+	TOGLDriver* Driver;
+
+	STextureCache TextureCache;
+
+	GLuint FrameBufferCount;
+
+	GLenum* BlendEquation;
+	GLenum* BlendSourceRGB;
+	GLenum* BlendDestinationRGB;
+	GLenum* BlendSourceAlpha;
+	GLenum* BlendDestinationAlpha;
+	bool* Blend;
+
+	bool(*ColorMask)[4];
+
+	GLenum CullFaceMode;
+	bool CullFace;
+
+	GLenum DepthFunc;
+	bool DepthMask;
+
+	GLuint FrameBufferID;
+
+	GLuint ProgramID;
+
+	GLenum ActiveTexture;
+
+	GLint ViewportX;
+	GLint ViewportY;
+	GLsizei ViewportWidth;
+	GLsizei ViewportHeight;
+};
+
+}
+}
+
+#endif
+#endif

source/Irrlicht/COGLCoreFeature.h

@@ -19,16 +19,19 @@ namespace video
 class COGLCoreFeature
 {
 public:
-	COGLCoreFeature() : ColorAttachment(0), MultipleRenderTarget(0)
+	COGLCoreFeature() : BlendOperation(false), ColorAttachment(0), MultipleRenderTarget(0), TextureUnit(1)
 	{
 	}
 
 	virtual ~COGLCoreFeature()
 	{
 	}
+
+	bool BlendOperation;
 	
 	u8 ColorAttachment;
 	u8 MultipleRenderTarget;
+	u8 TextureUnit;
 };
 
 }

source/Irrlicht/COpenGLCacheHandler.cpp

@@ -14,213 +14,32 @@ namespace irr
 namespace video
 {
 
-/* COpenGLCacheHandler::STextureCache */
-
-COpenGLCacheHandler::STextureCache::STextureCache(COpenGLCacheHandler* cacheHandler, u32 textureCount) :
-	CacheHandler(cacheHandler), TextureCount(textureCount)
-{
-	for (u32 i = 0; i < MATERIAL_MAX_TEXTURES; ++i)
-	{
-		Texture[i] = 0;
-	}
-}
-
-COpenGLCacheHandler::STextureCache::~STextureCache()
-{
-	clear();
-}
-
-const COpenGLTexture* COpenGLCacheHandler::STextureCache::operator[](int index) const
-{
-	if (static_cast<u32>(index) < MATERIAL_MAX_TEXTURES)
-		return Texture[static_cast<u32>(index)];
-
-	return 0;
-}
-
-bool COpenGLCacheHandler::STextureCache::set(u32 index, const ITexture* texture)
-{
-	bool status = false;
-	
-	E_DRIVER_TYPE type = EDT_OPENGL;
-
-	if (index < MATERIAL_MAX_TEXTURES && index < TextureCount)
-	{
-		CacheHandler->setActiveTexture(GL_TEXTURE0_ARB + index);
-
-		const COpenGLTexture* prevTexture = Texture[index];
-
-		if (texture != prevTexture)
-		{
-			if (texture)
-			{
-				type = texture->getDriverType();
-
-				if (type == EDT_OPENGL)
-				{
-					texture->grab();
-
-					if (!prevTexture)
-						glEnable(GL_TEXTURE_2D);
-
-					glBindTexture(GL_TEXTURE_2D, static_cast<const COpenGLTexture*>(texture)->getOpenGLTextureName());
-				}
-				else
-				{
-					texture = 0;
-
-					os::Printer::log("Fatal Error: Tried to set a texture not owned by this driver.", ELL_ERROR);
-				}
-			}
-			
-			if (!texture)
-			{
-				glBindTexture(GL_TEXTURE_2D, 0);
-
-				if (prevTexture)
-					glDisable(GL_TEXTURE_2D);
-			}
-
-			Texture[index] = static_cast<const COpenGLTexture*>(texture);
-
-			if (prevTexture)
-				prevTexture->drop();
-		}
-
-		status = true;
-	}
-
-	return (status && type == EDT_OPENGL);
-}
-
-void COpenGLCacheHandler::STextureCache::remove(ITexture* texture)
-{
-	if (!texture)
-		return;
-
-	for (u32 i = 0; i < MATERIAL_MAX_TEXTURES; ++i)
-	{
-		if (Texture[i] == texture)
-		{
-			Texture[i] = 0;
-
-			texture->drop();
-		}
-	}
-}
-
-void COpenGLCacheHandler::STextureCache::clear()
-{
-	for (u32 i = 0; i < MATERIAL_MAX_TEXTURES; ++i)
-	{
-		if (Texture[i])
-		{
-			const COpenGLTexture* prevTexture = Texture[i];
-
-			Texture[i] = 0;
-
-			prevTexture->drop();
-		}
-	}
-}
-
 /* COpenGLCacheHandler */
 
 COpenGLCacheHandler::COpenGLCacheHandler(COpenGLDriver* driver) :
-	TextureCache(STextureCache(this, driver->MaxSupportedTextures)), Driver(driver), FrameBufferCount(0),
-	AlphaMode(GL_ALWAYS), AlphaRef(0.f), AlphaTest(false), BlendEquation(0), BlendSourceRGB(0), BlendDestinationRGB(0),
-	BlendSourceAlpha(0), BlendDestinationAlpha(0), Blend(0), ColorMask(0), CullFaceMode(GL_BACK), CullFace(false),
-	DepthFunc(GL_LESS), DepthMask(true), DepthTest(false), FrameBufferID(0), MatrixMode(GL_MODELVIEW), ActiveTexture(GL_TEXTURE0_ARB),
-	ClientActiveTexture(GL_TEXTURE0_ARB), ClientStateVertex(false), ClientStateNormal(false),ClientStateColor(false),
-	ClientStateTexCoord0(false), ViewportX(0), ViewportY(0)
+	COGLCoreCacheHandler<COpenGLDriver, COpenGLTexture>(driver), AlphaMode(GL_ALWAYS), AlphaRef(0.f), AlphaTest(false),
+	DepthTest(false), MatrixMode(GL_MODELVIEW), ClientActiveTexture(GL_TEXTURE0_ARB), ClientStateVertex(false),
+	ClientStateNormal(false), ClientStateColor(false), ClientStateTexCoord0(false)
 {
-	FrameBufferCount = core::max_(static_cast<GLuint>(1), static_cast<GLuint>(Driver->getFeature().MultipleRenderTarget));
-
-	BlendEquation = new GLenum[FrameBufferCount];
-	BlendSourceRGB = new GLenum[FrameBufferCount];
-	BlendDestinationRGB = new GLenum[FrameBufferCount];
-	BlendSourceAlpha = new GLenum[FrameBufferCount];
-	BlendDestinationAlpha = new GLenum[FrameBufferCount];
-	Blend = new bool[FrameBufferCount];
-
-	ColorMask = new bool[FrameBufferCount][4];
-
 	// Initial OpenGL values from specification.
 
 	glAlphaFunc(AlphaMode, AlphaRef);
 	glDisable(GL_ALPHA_TEST);
 
-	if (Driver->queryFeature(EVDF_BLEND_OPERATIONS))
-	{
-#if defined(GL_VERSION_1_4)
-		Driver->extGlBlendEquation(GL_FUNC_ADD);
-#elif defined(GL_EXT_blend_subtract) || defined(GL_EXT_blend_minmax) || defined(GL_EXT_blend_logic_op)
-		Driver->extGlBlendEquation(GL_FUNC_ADD_EXT);
-#endif
-	}
-
-	for (u32 i = 0; i < FrameBufferCount; ++i)
-	{
-#if defined(GL_VERSION_1_4)
-		BlendEquation[i] = GL_FUNC_ADD;
-#elif defined(GL_EXT_blend_subtract) || defined(GL_EXT_blend_minmax) || defined(GL_EXT_blend_logic_op)
-		BlendEquation[i] = GL_FUNC_ADD_EXT;
-#endif
-
-		BlendSourceRGB[i] = GL_ONE;
-		BlendDestinationRGB[i] = GL_ZERO;
-		BlendSourceAlpha[i] = GL_ONE;
-		BlendDestinationAlpha[i] = GL_ZERO;
-
-		Blend[i] = false;
-
-		for (u32 j = 0; j < 4; ++j)
-			ColorMask[i][j] = true;
-	}
-
-	glBlendFunc(GL_ONE, GL_ZERO);
-	glDisable(GL_BLEND);
-
-	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-
-	glCullFace(CullFaceMode);
-	glDisable(GL_CULL_FACE);
-
-	glDepthFunc(DepthFunc);
-	glDepthMask(GL_TRUE);
 	glDisable(GL_DEPTH_TEST);
 
 	glMatrixMode(MatrixMode);
 
-	if (Driver->MultiTextureExtension)
-	{
-		Driver->extGlActiveTexture(ActiveTexture);
-		Driver->extGlClientActiveTexture(ClientActiveTexture);
-	}
-
-	glDisable(GL_TEXTURE_2D);
+	Driver->irrGlClientActiveTexture(ClientActiveTexture);
 
 	glDisableClientState(GL_VERTEX_ARRAY);
 	glDisableClientState(GL_NORMAL_ARRAY);
 	glDisableClientState(GL_COLOR_ARRAY);
 	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-
-	const core::dimension2d<u32> ScreenSize = Driver->getScreenSize();
-	ViewportWidth = ScreenSize.Width;
-	ViewportHeight = ScreenSize.Height;
-	glViewport(ViewportX, ViewportY, ViewportWidth, ViewportHeight);
 }
 
 COpenGLCacheHandler::~COpenGLCacheHandler()
 {
-	delete[] BlendEquation;
-	delete[] BlendSourceRGB;
-	delete[] BlendDestinationRGB;
-    delete[] BlendSourceAlpha;
-	delete[] BlendDestinationAlpha;
-	delete[] Blend;
-
-	delete[] ColorMask;
 }
 
 void COpenGLCacheHandler::setAlphaFunc(GLenum mode, GLclampf ref)
@@ -246,159 +65,6 @@ void COpenGLCacheHandler::setAlphaTest(bool enable)
 	}
 }
 
-void COpenGLCacheHandler::setBlendEquation(GLenum mode)
-{
-	if (BlendEquation[0] != mode)
-	{
-		Driver->extGlBlendEquation(mode);
-
-		for (GLuint i = 0; i < FrameBufferCount; ++i)
-			BlendEquation[i] = mode;
-	}
-}
-
-void COpenGLCacheHandler::setBlendEquationIndexed(GLuint index, GLenum mode)
-{
-	if (index < FrameBufferCount && BlendEquation[index] != mode)
-	{
-		Driver->extGlBlendEquationIndexed(index, mode);
-
-		BlendEquation[index] = mode;
-	}
-}
-
-void COpenGLCacheHandler::setBlendFunc(GLenum source, GLenum destination)
-{
-	if (BlendSourceRGB[0] != source || BlendDestinationRGB[0] != destination ||
-        BlendSourceAlpha[0] != source || BlendDestinationAlpha[0] != destination)
-	{
-		glBlendFunc(source, destination);
-
-		for (GLuint i = 0; i < FrameBufferCount; ++i)
-		{
-			BlendSourceRGB[i] = source;
-			BlendDestinationRGB[i] = destination;
-			BlendSourceAlpha[i] = source;
-			BlendDestinationAlpha[i] = destination;
-		}
-	}
-}
-
-void COpenGLCacheHandler::setBlendFuncSeparate(GLenum sourceRGB, GLenum destinationRGB, GLenum sourceAlpha, GLenum destinationAlpha)
-{
-    if (sourceRGB != sourceAlpha || destinationRGB != destinationAlpha)
-    {
-        if (BlendSourceRGB[0] != sourceRGB || BlendDestinationRGB[0] != destinationRGB ||
-            BlendSourceAlpha[0] != sourceAlpha || BlendDestinationAlpha[0] != destinationAlpha)
-        {
-            Driver->extGlBlendFuncSeparate(sourceRGB, destinationRGB, sourceAlpha, destinationAlpha);
-
-            for (GLuint i = 0; i < FrameBufferCount; ++i)
-            {
-                BlendSourceRGB[i] = sourceRGB;
-                BlendDestinationRGB[i] = destinationRGB;
-                BlendSourceAlpha[i] = sourceAlpha;
-                BlendDestinationAlpha[i] = destinationAlpha;
-            }
-        }
-    }
-    else
-    {
-        setBlendFunc(sourceRGB, destinationRGB);
-    }
-}
-
-void COpenGLCacheHandler::setBlendFuncIndexed(GLuint index, GLenum source, GLenum destination)
-{
-	if (index < FrameBufferCount && (BlendSourceRGB[index] != source || BlendDestinationRGB[index] != destination ||
-        BlendSourceAlpha[index] != source || BlendDestinationAlpha[index] != destination))
-	{
-		Driver->extGlBlendFuncIndexed(index, source, destination);
-
-        BlendSourceRGB[index] = source;
-        BlendDestinationRGB[index] = destination;
-        BlendSourceAlpha[index] = source;
-        BlendDestinationAlpha[index] = destination;
-	}
-}
-
-void COpenGLCacheHandler::setBlendFuncSeparateIndexed(GLuint index, GLenum sourceRGB, GLenum destinationRGB, GLenum sourceAlpha, GLenum destinationAlpha)
-{
-    if (sourceRGB != sourceAlpha || destinationRGB != destinationAlpha)
-    {
-        if (index < FrameBufferCount && (BlendSourceRGB[index] != sourceRGB || BlendDestinationRGB[index] != destinationRGB ||
-            BlendSourceAlpha[index] != sourceAlpha || BlendDestinationAlpha[index] != destinationAlpha))
-        {
-            Driver->extGlBlendFuncSeparateIndexed(index, sourceRGB, destinationRGB, sourceAlpha, destinationAlpha);
-
-            BlendSourceRGB[index] = sourceRGB;
-            BlendDestinationRGB[index] = destinationRGB;
-            BlendSourceAlpha[index] = sourceAlpha;
-            BlendDestinationAlpha[index] = destinationAlpha;
-        }
-    }
-    else
-    {
-        setBlendFuncIndexed(index, sourceRGB, destinationRGB);
-    }
-}
-
-void COpenGLCacheHandler::setBlend(bool enable)
-{
-	if (Blend[0] != enable)
-	{
-		if (enable)
-			glEnable(GL_BLEND);
-		else
-			glDisable(GL_BLEND);
-
-		for (GLuint i = 0; i < FrameBufferCount; ++i)
-			Blend[i] = enable;
-	}
-}
-
-void COpenGLCacheHandler::setBlendIndexed(GLuint index, bool enable)
-{
-	if (index < FrameBufferCount && Blend[index] != enable)
-	{
-		if (enable)
-			Driver->extGlEnableIndexed(GL_BLEND, index);
-		else
-			Driver->extGlDisableIndexed(GL_BLEND, index);
-
-		Blend[index] = enable;
-	}
-}
-
-void COpenGLCacheHandler::setColorMask(bool red, bool green, bool blue, bool alpha)
-{
-	if (ColorMask[0][0] != red || ColorMask[0][1] != green || ColorMask[0][2] != blue || ColorMask[0][3] != alpha)
-	{
-		glColorMask(red, green, blue, alpha);
-
-		for (GLuint i = 0; i < FrameBufferCount; ++i)
-		{
-			ColorMask[i][0] = red;
-			ColorMask[i][1] = green;
-			ColorMask[i][2] = blue;
-			ColorMask[i][3] = alpha;
-		}
-	}
-}
-
-void COpenGLCacheHandler::setColorMaskIndexed(GLuint index, bool red, bool green, bool blue, bool alpha)
-{
-	if (index < FrameBufferCount && (ColorMask[index][0] != red || ColorMask[index][1] != green || ColorMask[index][2] != blue || ColorMask[index][3] != alpha))
-	{
-		Driver->extGlColorMaskIndexed(index, red, green, blue, alpha);
-
-		ColorMask[index][0] = red;
-		ColorMask[index][1] = green;
-		ColorMask[index][2] = blue;
-		ColorMask[index][3] = alpha;
-	}
-}
-
 void COpenGLCacheHandler::setClientState(bool vertex, bool normal, bool color, bool texCoord0)
 {
 	if (ClientStateVertex != vertex)
@@ -444,48 +110,6 @@ void COpenGLCacheHandler::setClientState(bool vertex, bool normal, bool color, b
 	}
 }
 
-void COpenGLCacheHandler::setCullFaceFunc(GLenum mode)
-{
-	if (CullFaceMode != mode)
-	{
-		glCullFace(mode);
-		CullFaceMode = mode;
-	}
-}
-
-void COpenGLCacheHandler::setCullFace(bool enable)
-{
-	if (CullFace != enable)
-	{
-		if (enable)
-			glEnable(GL_CULL_FACE);
-		else
-			glDisable(GL_CULL_FACE);
-		CullFace = enable;
-	}
-}
-
-void COpenGLCacheHandler::setDepthFunc(GLenum mode)
-{
-	if (DepthFunc != mode)
-	{
-		glDepthFunc(mode);
-		DepthFunc = mode;
-	}
-}
-
-void COpenGLCacheHandler::setDepthMask(bool enable)
-{
-	if (DepthMask != enable)
-	{
-		if (enable)
-			glDepthMask(GL_TRUE);
-		else
-			glDepthMask(GL_FALSE);
-		DepthMask = enable;
-	}
-}
-
 void COpenGLCacheHandler::setDepthTest(bool enable)
 {
 	if (DepthTest != enable)
@@ -498,21 +122,6 @@ void COpenGLCacheHandler::setDepthTest(bool enable)
 	}
 }
 
-void COpenGLCacheHandler::getFBO(GLuint& id) const
-{
-	id = FrameBufferID;
-}
-
-void COpenGLCacheHandler::setFBO(GLuint id)
-{
-	if (FrameBufferID != id)
-	{
-		Driver->irrGlBindFramebuffer(GL_FRAMEBUFFER, id);
-
-		FrameBufferID = id;
-	}
-}
-
 void COpenGLCacheHandler::setMatrixMode(GLenum mode)
 {
 	if (MatrixMode != mode)
@@ -522,36 +131,15 @@ void COpenGLCacheHandler::setMatrixMode(GLenum mode)
 	}
 }
 
-void COpenGLCacheHandler::setActiveTexture(GLenum texture)
-{
-	if (Driver->MultiTextureExtension && ActiveTexture != texture)
-	{
-		Driver->extGlActiveTexture(texture);
-		ActiveTexture = texture;
-	}
-}
-
 void COpenGLCacheHandler::setClientActiveTexture(GLenum texture)
 {
-	if (Driver->MultiTextureExtension && ClientActiveTexture != texture)
+	if (ClientActiveTexture != texture)
 	{
-		Driver->extGlClientActiveTexture(texture);
+		Driver->irrGlClientActiveTexture(texture);
 		ClientActiveTexture = texture;
 	}
 }
 
-void COpenGLCacheHandler::setViewport(GLint viewportX, GLint viewportY, GLsizei viewportWidth, GLsizei viewportHeight)
-{
-	if (ViewportX != viewportX || ViewportY != viewportY || ViewportWidth != viewportWidth || ViewportHeight != viewportHeight)
-	{
-		glViewport(viewportX, viewportY, viewportWidth, viewportHeight);
-		ViewportX = viewportX;
-		ViewportY = viewportY;
-		ViewportWidth = viewportWidth;
-		ViewportHeight = viewportHeight;
-	}
-}
-
 } // end namespace
 } // end namespace
 

source/Irrlicht/COpenGLCacheHandler.h

@@ -2,49 +2,28 @@
 // This file is part of the "Irrlicht Engine".
 // For conditions of distribution and use, see copyright notice in Irrlicht.h
 
-#ifndef __C_OPEN_GL_CACHE_HANDLER_H_INCLUDED__
-#define __C_OPEN_GL_CACHE_HANDLER_H_INCLUDED__
+#ifndef __C_OPENGL_CACHE_HANDLER_H_INCLUDED__
+#define __C_OPENGL_CACHE_HANDLER_H_INCLUDED__
 
 #include "IrrCompileConfig.h"
 
 #ifdef _IRR_COMPILE_WITH_OPENGL_
 
 #include "COpenGLExtensionHandler.h"
-#include "SMaterial.h"
+#include "COGLCoreCacheHandler.h"
 
 namespace irr
 {
 namespace video
 {
-	class COpenGLDriver;
 	class COpenGLTexture;
+	class COpenGLDriver;
 
-	class COpenGLCacheHandler
+	class COpenGLCacheHandler : public COGLCoreCacheHandler<COpenGLDriver, COpenGLTexture>
 	{
-		class STextureCache
-		{
-		public:
-			STextureCache();
-			STextureCache(COpenGLCacheHandler* cacheHandler, u32 textureCount);
-			~STextureCache();
-
-			const COpenGLTexture* operator[](int index) const;
-
-			bool set(u32 index, const ITexture* texture);
-
-			void remove(ITexture* texture);
-			void clear();
-
-		private:
-			COpenGLCacheHandler* CacheHandler;
-
-			const COpenGLTexture* Texture[MATERIAL_MAX_TEXTURES];
-			u32 TextureCount;
-		};
-
 	public:
 		COpenGLCacheHandler(COpenGLDriver* driver);
-		~COpenGLCacheHandler();
+		virtual ~COpenGLCacheHandler();
 
 		// Alpha calls.
 
@@ -52,113 +31,37 @@ namespace video
 
 		void setAlphaTest(bool enable);
 
-		// Blending calls.
-
-		void setBlendEquation(GLenum mode);
-
-		void setBlendEquationIndexed(GLuint index, GLenum mode);
-
-		void setBlendFunc(GLenum source, GLenum destination);
-
-		void setBlendFuncSeparate(GLenum sourceRGB, GLenum destinationRGB, GLenum sourceAlpha, GLenum destinationAlpha);
-
-		void setBlendFuncIndexed(GLuint index, GLenum source, GLenum destination);
-
-		void setBlendFuncSeparateIndexed(GLuint index, GLenum sourceRGB, GLenum destinationRGB, GLenum sourceAlpha, GLenum destinationAlpha);
-
-		void setBlend(bool enable);
-
-		void setBlendIndexed(GLuint index, bool enable);
-
 		// Client state calls.
 
 		void setClientState(bool vertex, bool normal, bool color, bool texCoord0);
 
-		// Color Mask.
-
-		void setColorMask(bool red, bool green, bool blue, bool alpha);
-
-		void setColorMaskIndexed(GLuint index, bool red, bool green, bool blue, bool alpha);
-
-		// Cull face calls.
-
-		void setCullFaceFunc(GLenum mode);
-
-		void setCullFace(bool enable);
-
 		// Depth calls.
 
-		void setDepthFunc(GLenum mode);
-
-		void setDepthMask(bool enable);
-
 		void setDepthTest(bool enable);
 
-		// FBO calls.
-
-		void getFBO(GLuint& id) const;
-
-		void setFBO(GLuint id);
-
 		// Matrix calls.
 
 		void setMatrixMode(GLenum mode);
 
 		// Texture calls.
 
-		void setActiveTexture(GLenum texture);
-
 		void setClientActiveTexture(GLenum texture);
 
-		// Viewport calls.
-
-		void setViewport(GLint viewportX, GLint viewportY, GLsizei viewportWidth, GLsizei viewportHeight);
-
-		// Texture cache.
-
-		STextureCache TextureCache;
-
-	private:
-		COpenGLDriver* Driver;
-
-		GLuint FrameBufferCount;
-
+	protected:
 		GLenum AlphaMode;
 		GLclampf AlphaRef;
 		bool AlphaTest;
 
-		GLenum* BlendEquation;
-		GLenum* BlendSourceRGB;
-		GLenum* BlendDestinationRGB;
-		GLenum* BlendSourceAlpha;
-		GLenum* BlendDestinationAlpha;
-		bool* Blend;
-
-		bool (*ColorMask)[4];
-
-		GLenum CullFaceMode;
-		bool CullFace;
-
-		GLenum DepthFunc;
-		bool DepthMask;
 		bool DepthTest;
 
-		GLuint FrameBufferID;
-
 		GLenum MatrixMode;
 
-		GLenum ActiveTexture;
 		GLenum ClientActiveTexture;
 
 		bool ClientStateVertex;
 		bool ClientStateNormal;
 		bool ClientStateColor;
 		bool ClientStateTexCoord0;
-
-		GLint ViewportX;
-		GLint ViewportY;
-		GLsizei ViewportWidth;
-		GLsizei ViewportHeight;
 	};
 
 } // end namespace video

source/Irrlicht/COpenGLDriver.cpp

@@ -607,7 +607,7 @@ COpenGLDriver::~COpenGLDriver()
 
 	deleteMaterialRenders();
 
-	CacheHandler->TextureCache.clear();
+	CacheHandler->getTextureCache().clear();
 	// I get a blue screen on my laptop, when I do not delete the
 	// textures manually before releasing the dc. Oh how I love this.
 	removeAllRenderTargets();
@@ -676,13 +676,13 @@ bool COpenGLDriver::genericDriverInit()
 	}
 	else
 		os::Printer::log("GLSL not available.", ELL_INFORMATION);
-	DriverAttributes->setAttribute("MaxTextures", MaxTextureUnits);
-	DriverAttributes->setAttribute("MaxSupportedTextures", MaxSupportedTextures);
+	DriverAttributes->setAttribute("MaxTextures", (s32)Feature.TextureUnit);
+	DriverAttributes->setAttribute("MaxSupportedTextures", (s32)Feature.TextureUnit);
 	DriverAttributes->setAttribute("MaxLights", MaxLights);
 	DriverAttributes->setAttribute("MaxAnisotropy", MaxAnisotropy);
 	DriverAttributes->setAttribute("MaxUserClipPlanes", MaxUserClipPlanes);
 	DriverAttributes->setAttribute("MaxAuxBuffers", MaxAuxBuffers);
-	DriverAttributes->setAttribute("MaxMultipleRenderTargets", Feature.MultipleRenderTarget);
+	DriverAttributes->setAttribute("MaxMultipleRenderTargets", (s32)Feature.MultipleRenderTarget);
 	DriverAttributes->setAttribute("MaxIndices", (s32)MaxIndices);
 	DriverAttributes->setAttribute("MaxTextureSize", (s32)MaxTextureSize);
 	DriverAttributes->setAttribute("MaxGeometryVerticesOut", (s32)MaxGeometryVerticesOut);
@@ -1443,9 +1443,9 @@ void COpenGLDriver::drawVertexPrimitiveList(const void* vertices, u32 vertexCoun
 				glVertexPointer(3, GL_FLOAT, sizeof(S3DVertex), 0);
 			}
 
-			if (MultiTextureExtension && CacheHandler->TextureCache[1])
+			if (Feature.TextureUnit > 0 && CacheHandler->getTextureCache()[1])
 			{
-				CacheHandler->setClientActiveTexture(GL_TEXTURE1_ARB);
+				CacheHandler->setClientActiveTexture(GL_TEXTURE0 + 1);
 				glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 				if (vertices)
 					glTexCoordPointer(2, GL_FLOAT, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].TCoords);
@@ -1469,9 +1469,9 @@ void COpenGLDriver::drawVertexPrimitiveList(const void* vertices, u32 vertexCoun
 			}
 
 
-			if (MultiTextureExtension)
+			if (Feature.TextureUnit > 0)
 			{
-				CacheHandler->setClientActiveTexture(GL_TEXTURE1_ARB);
+				CacheHandler->setClientActiveTexture(GL_TEXTURE0 + 1);
 				glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 				if (vertices)
 					glTexCoordPointer(2, GL_FLOAT, sizeof(S3DVertex2TCoords), &(static_cast<const S3DVertex2TCoords*>(vertices))[0].TCoords2);
@@ -1494,16 +1494,16 @@ void COpenGLDriver::drawVertexPrimitiveList(const void* vertices, u32 vertexCoun
 				glVertexPointer(3, GL_FLOAT, sizeof(S3DVertexTangents), buffer_offset(0));
 			}
 
-			if (MultiTextureExtension)
+			if (Feature.TextureUnit > 0)
 			{
-				CacheHandler->setClientActiveTexture(GL_TEXTURE1_ARB);
+				CacheHandler->setClientActiveTexture(GL_TEXTURE0 + 1);
 				glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 				if (vertices)
 					glTexCoordPointer(3, GL_FLOAT, sizeof(S3DVertexTangents), &(static_cast<const S3DVertexTangents*>(vertices))[0].Tangent);
 				else
 					glTexCoordPointer(3, GL_FLOAT, sizeof(S3DVertexTangents), buffer_offset(36));
 
-				CacheHandler->setClientActiveTexture(GL_TEXTURE2_ARB);
+				CacheHandler->setClientActiveTexture(GL_TEXTURE0 + 2);
 				glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 				if (vertices)
 					glTexCoordPointer(3, GL_FLOAT, sizeof(S3DVertexTangents), &(static_cast<const S3DVertexTangents*>(vertices))[0].Binormal);
@@ -1515,19 +1515,19 @@ void COpenGLDriver::drawVertexPrimitiveList(const void* vertices, u32 vertexCoun
 
 	renderArray(indexList, primitiveCount, pType, iType);
 
-	if (MultiTextureExtension)
+	if (Feature.TextureUnit > 0)
 	{
 		if (vType==EVT_TANGENTS)
 		{
-			CacheHandler->setClientActiveTexture(GL_TEXTURE2_ARB);
+			CacheHandler->setClientActiveTexture(GL_TEXTURE0 + 2);
 			glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 		}
-		if ((vType!=EVT_STANDARD) || CacheHandler->TextureCache[1])
+		if ((vType!=EVT_STANDARD) || CacheHandler->getTextureCache()[1])
 		{
-			CacheHandler->setClientActiveTexture(GL_TEXTURE1_ARB);
+			CacheHandler->setClientActiveTexture(GL_TEXTURE0 + 1);
 			glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 		}
-		CacheHandler->setClientActiveTexture(GL_TEXTURE0_ARB);
+		CacheHandler->setClientActiveTexture(GL_TEXTURE0);
 	}
 }
 
@@ -1698,7 +1698,7 @@ void COpenGLDriver::draw2DVertexPrimitiveList(const void* vertices, u32 vertexCo
 		getColorBuffer(vertices, vertexCount, vType);
 
 	// draw everything
-	CacheHandler->TextureCache.set(0, Material.getTexture(0));
+	CacheHandler->getTextureCache().set(0, Material.getTexture(0));
 	if (Material.MaterialType==EMT_ONETEXTURE_BLEND)
 	{
 		E_BLEND_FACTOR srcFact;
@@ -1763,9 +1763,9 @@ void COpenGLDriver::draw2DVertexPrimitiveList(const void* vertices, u32 vertexCo
 				glVertexPointer(2, GL_FLOAT, sizeof(S3DVertex), 0);
 			}
 
-			if (MultiTextureExtension && CacheHandler->TextureCache[1])
+			if (Feature.TextureUnit > 0 && CacheHandler->getTextureCache()[1])
 			{
-				CacheHandler->setClientActiveTexture(GL_TEXTURE1_ARB);
+				CacheHandler->setClientActiveTexture(GL_TEXTURE0 + 1);
 				glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 				if (vertices)
 					glTexCoordPointer(2, GL_FLOAT, sizeof(S3DVertex), &(static_cast<const S3DVertex*>(vertices))[0].TCoords);
@@ -1786,9 +1786,9 @@ void COpenGLDriver::draw2DVertexPrimitiveList(const void* vertices, u32 vertexCo
 				glVertexPointer(2, GL_FLOAT, sizeof(S3DVertex2TCoords), buffer_offset(0));
 			}
 
-			if (MultiTextureExtension)
+			if (Feature.TextureUnit > 0)
 			{
-				CacheHandler->setClientActiveTexture(GL_TEXTURE1_ARB);
+				CacheHandler->setClientActiveTexture(GL_TEXTURE0 + 1);
 				glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 				if (vertices)
 					glTexCoordPointer(2, GL_FLOAT, sizeof(S3DVertex2TCoords), &(static_cast<const S3DVertex2TCoords*>(vertices))[0].TCoords2);
@@ -1814,14 +1814,14 @@ void COpenGLDriver::draw2DVertexPrimitiveList(const void* vertices, u32 vertexCo
 
 	renderArray(indexList, primitiveCount, pType, iType);
 
-	if (MultiTextureExtension)
+	if (Feature.TextureUnit > 0)
 	{
-		if ((vType!=EVT_STANDARD) || CacheHandler->TextureCache[1])
+		if ((vType!=EVT_STANDARD) || CacheHandler->getTextureCache()[1])
 		{
-			CacheHandler->setClientActiveTexture(GL_TEXTURE1_ARB);
+			CacheHandler->setClientActiveTexture(GL_TEXTURE0 + 1);
 			glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 		}
-		CacheHandler->setClientActiveTexture(GL_TEXTURE0_ARB);
+		CacheHandler->setClientActiveTexture(GL_TEXTURE0);
 	}
 }
 
@@ -1846,7 +1846,7 @@ void COpenGLDriver::draw2DImageBatch(const video::ITexture* texture,
 	const core::dimension2d<u32>& renderTargetSize = getCurrentRenderTargetSize();
 
 	disableTextures(1);
-	if (!CacheHandler->TextureCache.set(0, texture))
+	if (!CacheHandler->getTextureCache().set(0, texture))
 		return;
 	setRenderStates2DMode(color.getAlpha()<255, true, useAlphaChannelOfTexture);
 
@@ -2093,7 +2093,7 @@ void COpenGLDriver::draw2DImage(const video::ITexture* texture,
 	const core::rect<s32> poss(targetPos, sourceSize);
 
 	disableTextures(1);
-	if (!CacheHandler->TextureCache.set(0, texture))
+	if (!CacheHandler->getTextureCache().set(0, texture))
 		return;
 	setRenderStates2DMode(color.getAlpha()<255, true, useAlphaChannelOfTexture);
 
@@ -2165,7 +2165,7 @@ void COpenGLDriver::draw2DImage(const video::ITexture* texture, const core::rect
 	const video::SColor* const useColor = colors ? colors : temp;
 
 	disableTextures(1);
-	if (!CacheHandler->TextureCache.set(0, texture))
+	if (!CacheHandler->getTextureCache().set(0, texture))
 		return;
 	setRenderStates2DMode(useColor[0].getAlpha()<255 || useColor[1].getAlpha()<255 ||
 			useColor[2].getAlpha()<255 || useColor[3].getAlpha()<255,
@@ -2242,7 +2242,7 @@ void COpenGLDriver::draw2DImageBatch(const video::ITexture* texture,
 		return;
 
 	disableTextures(1);
-	if (!CacheHandler->TextureCache.set(0, texture))
+	if (!CacheHandler->getTextureCache().set(0, texture))
 		return;
 	setRenderStates2DMode(color.getAlpha()<255, true, useAlphaChannelOfTexture);
 
@@ -2480,9 +2480,9 @@ void COpenGLDriver::drawPixel(u32 x, u32 y, const SColor &color)
 bool COpenGLDriver::disableTextures(u32 fromStage)
 {
 	bool result=true;
-	for (u32 i=fromStage; i<MaxSupportedTextures; ++i)
+	for (u32 i=fromStage; i<Feature.TextureUnit; ++i)
 	{
-		result &= CacheHandler->TextureCache.set(i, 0);
+		result &= CacheHandler->getTextureCache().set(i, 0);
 	}
 	return result;
 }
@@ -2533,9 +2533,9 @@ void COpenGLDriver::setMaterial(const SMaterial& material)
 	Material = material;
 	OverrideMaterial.apply(Material);
 
-	for (u32 i = 0; i < MaxTextureUnits; ++i)
+	for (u32 i = 0; i < Feature.TextureUnit; ++i)
 	{
-		CacheHandler->TextureCache.set(i, material.getTexture(i));
+		CacheHandler->getTextureCache().set(i, material.getTexture(i));
 		setTransform((E_TRANSFORMATION_STATE)(ETS_TEXTURE_0 + i), material.getTextureMatrix(i));
 	}
 }
@@ -3185,24 +3185,19 @@ void COpenGLDriver::setTextureRenderStates(const SMaterial& material, bool reset
 {
 	// Set textures to TU/TIU and apply filters to them
 
-	for (s32 i = MaxTextureUnits-1; i>= 0; --i)
+	for (s32 i = Feature.TextureUnit - 1; i>= 0; --i)
 	{
 		bool fixedPipeline = false;
 
 		if (FixedPipelineState == EOFPS_ENABLE || FixedPipelineState == EOFPS_DISABLE_TO_ENABLE)
-		{
-			if (i > 0 && !MultiTextureExtension)
-				break;
-
 			fixedPipeline = true;
-		}
 
-		const COpenGLTexture* tmpTexture = CacheHandler->TextureCache[i];
+		const COpenGLTexture* tmpTexture = CacheHandler->getTextureCache()[i];
 
 		if (!tmpTexture)
 			continue;
 
-		CacheHandler->setActiveTexture(GL_TEXTURE0_ARB + i);
+		CacheHandler->setActiveTexture(GL_TEXTURE0 + i);
 
 		if (fixedPipeline)
 		{
@@ -3331,7 +3326,7 @@ void COpenGLDriver::setTextureRenderStates(const SMaterial& material, bool reset
 	}
 
 	// be sure to leave in texture stage 0
-	CacheHandler->setActiveTexture(GL_TEXTURE0_ARB);
+	CacheHandler->setActiveTexture(GL_TEXTURE0);
 }
 
 
@@ -3376,7 +3371,7 @@ void COpenGLDriver::setRenderStates2DMode(bool alpha, bool texture, bool alphaCh
 			glTranslatef(0.375f, 0.375f, 0.0f);
 
 			// Make sure we set first texture matrix
-			CacheHandler->setActiveTexture(GL_TEXTURE0_ARB);
+			CacheHandler->setActiveTexture(GL_TEXTURE0);
 
 			Transformation3DChanged = false;
 		}
@@ -3421,7 +3416,7 @@ void COpenGLDriver::setRenderStates2DMode(bool alpha, bool texture, bool alphaCh
 		else
 			setTextureRenderStates(InitMaterial2D, false);
 
-		Material.setTexture(0, const_cast<COpenGLTexture*>(CacheHandler->TextureCache[0]));
+		Material.setTexture(0, const_cast<COpenGLTexture*>(CacheHandler->getTextureCache()[0]));
 		setTransform(ETS_TEXTURE_0, core::IdentityMatrix);
 		// Due to the transformation change, the previous line would call a reset each frame
 		// but we can safely reset the variable as it was false before
@@ -4200,7 +4195,7 @@ bool COpenGLDriver::setRenderTarget(IRenderTarget* target, u16 clearFlag, SColor
 		return false;
 	}
 
-	bool supportForFBO = (getFeature().ColorAttachment > 0);
+	bool supportForFBO = (Feature.ColorAttachment > 0);
 
 	core::dimension2d<u32> destRenderTargetSize(0, 0);
 
@@ -4229,14 +4224,14 @@ bool COpenGLDriver::setRenderTarget(IRenderTarget* target, u16 clearFlag, SColor
 
 			if (renderTargetTexture)
 			{
-				const COpenGLTexture* prevTexture = CacheHandler->TextureCache[0];
+				const COpenGLTexture* prevTexture = CacheHandler->getTextureCache()[0];
 
-				CacheHandler->TextureCache.set(0, renderTargetTexture);
+				CacheHandler->getTextureCache().set(0, renderTargetTexture);
 
 				const core::dimension2d<u32> size = renderTargetTexture->getSize();
 				glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, size.Width, size.Height);
 
-				CacheHandler->TextureCache.set(0, prevTexture);
+				CacheHandler->getTextureCache().set(0, prevTexture);
 			}
 		}
 

source/Irrlicht/COpenGLExtensionHandler.cpp

@@ -17,9 +17,7 @@ namespace video
 {
 
 COpenGLExtensionHandler::COpenGLExtensionHandler() :
-		StencilBuffer(false), MultiTextureExtension(false),
-		TextureCompressionExtension(false),
-		MaxSupportedTextures(1), MaxTextureUnits(1), MaxLights(1),
+		StencilBuffer(false), TextureCompressionExtension(false), MaxLights(1),
 		MaxAnisotropy(1), MaxUserClipPlanes(0), MaxAuxBuffers(0), MaxIndices(65535),
 		MaxTextureSize(1), MaxGeometryVerticesOut(0),
 		MaxTextureLODBias(0.f), Version(0), ShaderLanguageVersion(0),
@@ -373,7 +371,6 @@ void COpenGLExtensionHandler::initExtensions(bool stencilBuffer)
 		delete [] str;
 	}
 
-	MultiTextureExtension = FeatureAvailable[IRR_ARB_multitexture];
 	TextureCompressionExtension = FeatureAvailable[IRR_ARB_texture_compression];
 	StencilBuffer=stencilBuffer;
 
@@ -586,7 +583,7 @@ void COpenGLExtensionHandler::initExtensions(bool stencilBuffer)
 #elif defined(GL_MAX_TEXTURE_UNITS_ARB)
 		glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &num);
 #endif
-		MaxSupportedTextures=static_cast<u8>(num);
+		Feature.TextureUnit=static_cast<u8>(num);
 	}
 #endif
 #if defined(GL_ARB_vertex_shader) || defined(GL_VERSION_2_0)
@@ -598,7 +595,7 @@ void COpenGLExtensionHandler::initExtensions(bool stencilBuffer)
 #elif defined(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB)
 		glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &num);
 #endif
-		MaxSupportedTextures=core::max_(MaxSupportedTextures,static_cast<u8>(num));
+		Feature.TextureUnit =core::max_(Feature.TextureUnit,static_cast<u8>(num));
 	}
 #endif
 	glGetIntegerv(GL_MAX_LIGHTS, &num);
@@ -698,17 +695,12 @@ void COpenGLExtensionHandler::initExtensions(bool stencilBuffer)
 #ifdef _IRR_OPENGL_USE_EXTPOINTER_
 	if (!pGlActiveTextureARB || !pGlClientActiveTextureARB)
 	{
-		MultiTextureExtension = false;
+		Feature.TextureUnit = 1;
 		os::Printer::log("Failed to load OpenGL's multitexture extension, proceeding without.", ELL_WARNING);
 	}
 	else
 #endif
-	MaxTextureUnits = core::min_(MaxSupportedTextures, static_cast<u8>(MATERIAL_MAX_TEXTURES));
-	if (MaxTextureUnits < 2)
-	{
-		MultiTextureExtension = false;
-		os::Printer::log("Warning: OpenGL device only has one texture unit. Disabling multitexturing.", ELL_WARNING);
-	}
+	Feature.TextureUnit = core::min_(Feature.TextureUnit, static_cast<u8>(MATERIAL_MAX_TEXTURES));
 
 #ifdef GL_ARB_occlusion_query
 	if (FeatureAvailable[IRR_ARB_occlusion_query])
@@ -729,6 +721,9 @@ void COpenGLExtensionHandler::initExtensions(bool stencilBuffer)
 #endif
 		OcclusionQuerySupport=false;
 
+		Feature.BlendOperation = (Version >= 140) || FeatureAvailable[IRR_EXT_blend_minmax] || FeatureAvailable[IRR_EXT_blend_subtract] ||
+		FeatureAvailable[IRR_EXT_blend_logic_op];
+
 #ifdef _DEBUG
 	if (FeatureAvailable[IRR_NVX_gpu_memory_info])
 	{
@@ -770,7 +765,7 @@ bool COpenGLExtensionHandler::queryFeature(E_VIDEO_DRIVER_FEATURE feature) const
 	case EVDF_HARDWARE_TL:
 		return true; // we cannot tell other things
 	case EVDF_MULTITEXTURE:
-		return MultiTextureExtension;
+		return Feature.TextureUnit > 1;
 	case EVDF_BILINEAR_FILTER:
 		return true;
 	case EVDF_MIP_MAP:
@@ -821,8 +816,7 @@ bool COpenGLExtensionHandler::queryFeature(E_VIDEO_DRIVER_FEATURE feature) const
 		// both features supported with OpenGL 1.1
 		return Version>=110;
 	case EVDF_BLEND_OPERATIONS:
-		return (Version>=140) || FeatureAvailable[IRR_EXT_blend_minmax] ||
-			FeatureAvailable[IRR_EXT_blend_subtract] || FeatureAvailable[IRR_EXT_blend_logic_op];
+		return Feature.BlendOperation;
 	case EVDF_BLEND_SEPARATE:
 		return (Version>=140) || FeatureAvailable[IRR_EXT_blend_func_separate];
 	case EVDF_TEXTURE_MATRIX:

source/Irrlicht/COpenGLExtensionHandler.h

@@ -77,6 +77,16 @@ typedef unsigned int GLhandleARB;
 typedef char GLchar;
 #endif
 
+// Blending definitions.
+
+#if !defined(GL_VERSION_1_4)
+#if defined(GL_EXT_blend_subtract) || defined(GL_EXT_blend_minmax) || defined(GL_EXT_blend_logic_op)
+#define GL_FUNC_ADD GL_FUNC_ADD_EXT
+#else
+#define GL_FUNC_ADD 0
+#endif
+#endif
+
 // FBO definitions.
 
 #if !defined(GL_VERSION_3_0) && !defined(GL_ARB_framebuffer_object)
@@ -115,6 +125,20 @@ typedef char GLchar;
 #define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS 7
 #endif
 
+// Texture definitions.
+
+#if !defined(GL_VERSION_1_3)
+#ifdef GL_ARB_multitexture
+#define GL_TEXTURE0 GL_TEXTURE0_ARB
+#else
+#define GL_TEXTURE0 0
+#endif
+#endif
+
+// Irrlicht's OpenGL version.
+
+#define IRR_OPENGL_VERSION 14
+
 #include "COGLCoreFeature.h"
 
 namespace irr
@@ -1115,14 +1139,9 @@ class COpenGLExtensionHandler
 
 	// Some variables for properties
 	bool StencilBuffer;
-	bool MultiTextureExtension;
 	bool TextureCompressionExtension;
 
 	// Some non-boolean properties
-	//! Maxmimum texture layers supported by the fixed pipeline
-	u8 MaxSupportedTextures;
-	//! Maxmimum texture layers supported by the engine
-	u8 MaxTextureUnits;
 	//! Maximum hardware lights supported
 	u8 MaxLights;
 	//! Maximal Anisotropy
@@ -1157,8 +1176,8 @@ class COpenGLExtensionHandler
 
 	// public access to the (loaded) extensions.
 	// general functions
-	void extGlActiveTexture(GLenum texture);
-	void extGlClientActiveTexture(GLenum texture);
+	void irrGlActiveTexture(GLenum texture);
+	void irrGlClientActiveTexture(GLenum texture);
 	void extGlPointParameterf(GLint loc, GLfloat f);
 	void extGlPointParameterfv(GLint loc, const GLfloat *v);
 	void extGlStencilFuncSeparate (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask);
@@ -1272,17 +1291,17 @@ class COpenGLExtensionHandler
 	void extGlGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
 
 	// blend
-	void extGlBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-	void extGlBlendEquation(GLenum mode);
+	void irrGlBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+	void irrGlBlendEquation(GLenum mode);
 
 	// indexed
-	void extGlEnableIndexed(GLenum target, GLuint index);
-	void extGlDisableIndexed(GLenum target, GLuint index);
-	void extGlColorMaskIndexed(GLuint buf, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-	void extGlBlendFuncIndexed(GLuint buf, GLenum src, GLenum dst);
-	void extGlBlendFuncSeparateIndexed(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-	void extGlBlendEquationIndexed(GLuint buf, GLenum mode);
-	void extGlBlendEquationSeparateIndexed(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
+	void irrGlEnableIndexed(GLenum target, GLuint index);
+	void irrGlDisableIndexed(GLenum target, GLuint index);
+	void irrGlColorMaskIndexed(GLuint buf, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
+	void irrGlBlendFuncIndexed(GLuint buf, GLenum src, GLenum dst);
+	void irrGlBlendFuncSeparateIndexed(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
+	void irrGlBlendEquationIndexed(GLuint buf, GLenum mode);
+	void irrGlBlendEquationSeparateIndexed(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
 
 	// generic vsync setting method for several extensions
 	void extGlSwapInterval(int interval);
@@ -1444,13 +1463,12 @@ class COpenGLExtensionHandler
 	#endif
 };
 
-inline void COpenGLExtensionHandler::extGlActiveTexture(GLenum texture)
+inline void COpenGLExtensionHandler::irrGlActiveTexture(GLenum texture)
 {
 #ifdef _IRR_OPENGL_USE_EXTPOINTER_
-	if (MultiTextureExtension && pGlActiveTextureARB)
+	if (pGlActiveTextureARB)
 		pGlActiveTextureARB(texture);
 #else
-	if (MultiTextureExtension)
 #ifdef GL_ARB_multitexture
 		glActiveTextureARB(texture);
 #else
@@ -1459,14 +1477,13 @@ inline void COpenGLExtensionHandler::extGlActiveTexture(GLenum texture)
 #endif
 }
 
-inline void COpenGLExtensionHandler::extGlClientActiveTexture(GLenum texture)
+inline void COpenGLExtensionHandler::irrGlClientActiveTexture(GLenum texture)
 {
 #ifdef _IRR_OPENGL_USE_EXTPOINTER_
-	if (MultiTextureExtension && pGlClientActiveTextureARB)
+	if (pGlClientActiveTextureARB)
 		pGlClientActiveTextureARB(texture);
 #else
-	if (MultiTextureExtension)
-		glClientActiveTextureARB(texture);
+	glClientActiveTextureARB(texture);
 #endif
 }
 
@@ -2657,7 +2674,7 @@ inline void COpenGLExtensionHandler::extGlGetQueryObjectuiv(GLuint id, GLenum pn
 #endif
 }
 
-inline void COpenGLExtensionHandler::extGlBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
+inline void COpenGLExtensionHandler::irrGlBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
 #ifdef _IRR_OPENGL_USE_EXTPOINTER_
 	if (pGlBlendFuncSeparate)
@@ -2673,7 +2690,7 @@ inline void COpenGLExtensionHandler::extGlBlendFuncSeparate(GLenum sfactorRGB, G
 #endif
 }
 
-inline void COpenGLExtensionHandler::extGlBlendEquation(GLenum mode)
+inline void COpenGLExtensionHandler::irrGlBlendEquation(GLenum mode)
 {
 #ifdef _IRR_OPENGL_USE_EXTPOINTER_
 	if (pGlBlendEquation)
@@ -2689,7 +2706,7 @@ inline void COpenGLExtensionHandler::extGlBlendEquation(GLenum mode)
 #endif
 }
 
-inline void COpenGLExtensionHandler::extGlEnableIndexed(GLenum target, GLuint index)
+inline void COpenGLExtensionHandler::irrGlEnableIndexed(GLenum target, GLuint index)
 {
 #ifdef _IRR_OPENGL_USE_EXTPOINTER_
 	if (FeatureAvailable[IRR_EXT_draw_buffers2] && pGlEnableIndexedEXT)
@@ -2701,7 +2718,7 @@ inline void COpenGLExtensionHandler::extGlEnableIndexed(GLenum target, GLuint in
 #endif
 }
 
-inline void COpenGLExtensionHandler::extGlDisableIndexed(GLenum target, GLuint index)
+inline void COpenGLExtensionHandler::irrGlDisableIndexed(GLenum target, GLuint index)
 {
 #ifdef _IRR_OPENGL_USE_EXTPOINTER_
 	if (FeatureAvailable[IRR_EXT_draw_buffers2] && pGlDisableIndexedEXT)
@@ -2713,7 +2730,7 @@ inline void COpenGLExtensionHandler::extGlDisableIndexed(GLenum target, GLuint i
 #endif
 }
 
-inline void COpenGLExtensionHandler::extGlColorMaskIndexed(GLuint buf, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
+inline void COpenGLExtensionHandler::irrGlColorMaskIndexed(GLuint buf, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
 #ifdef _IRR_OPENGL_USE_EXTPOINTER_
 	if (FeatureAvailable[IRR_EXT_draw_buffers2] && pGlColorMaskIndexedEXT)
@@ -2725,7 +2742,7 @@ inline void COpenGLExtensionHandler::extGlColorMaskIndexed(GLuint buf, GLboolean
 #endif
 }
 
-inline void COpenGLExtensionHandler::extGlBlendFuncIndexed(GLuint buf, GLenum src, GLenum dst)
+inline void COpenGLExtensionHandler::irrGlBlendFuncIndexed(GLuint buf, GLenum src, GLenum dst)
 {
 #ifdef _IRR_OPENGL_USE_EXTPOINTER_
 	if (FeatureAvailable[IRR_ARB_draw_buffers_blend] && pGlBlendFunciARB)
@@ -2741,7 +2758,7 @@ inline void COpenGLExtensionHandler::extGlBlendFuncIndexed(GLuint buf, GLenum sr
 #endif
 }
 
-inline void COpenGLExtensionHandler::extGlBlendFuncSeparateIndexed(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
+inline void COpenGLExtensionHandler::irrGlBlendFuncSeparateIndexed(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
 #ifdef _IRR_OPENGL_USE_EXTPOINTER_
 	if (FeatureAvailable[IRR_ARB_draw_buffers_blend] && pGlBlendFuncSeparateiARB)
@@ -2757,7 +2774,7 @@ inline void COpenGLExtensionHandler::extGlBlendFuncSeparateIndexed(GLuint buf, G
 #endif
 }
 
-inline void COpenGLExtensionHandler::extGlBlendEquationIndexed(GLuint buf, GLenum mode)
+inline void COpenGLExtensionHandler::irrGlBlendEquationIndexed(GLuint buf, GLenum mode)
 {
 #ifdef _IRR_OPENGL_USE_EXTPOINTER_
 	if (FeatureAvailable[IRR_ARB_draw_buffers_blend] && pGlBlendEquationiARB)
@@ -2773,7 +2790,7 @@ inline void COpenGLExtensionHandler::extGlBlendEquationIndexed(GLuint buf, GLenu
 #endif
 }
 
-inline void COpenGLExtensionHandler::extGlBlendEquationSeparateIndexed(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
+inline void COpenGLExtensionHandler::irrGlBlendEquationSeparateIndexed(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
 {
 #ifdef _IRR_OPENGL_USE_EXTPOINTER_
 	if (FeatureAvailable[IRR_ARB_draw_buffers_blend] && pGlBlendEquationSeparateiARB)

source/Irrlicht/COpenGLSLMaterialRenderer.cpp

@@ -20,6 +20,7 @@
 #include "IVideoDriver.h"
 #include "os.h"
 #include "COpenGLDriver.h"
+#include "COpenGLTexture.h"
 #include "COpenGLCacheHandler.h"
 #include "COpenGLMaterialRenderer.h"
 

source/Irrlicht/COpenGLShaderMaterialRenderer.cpp

@@ -11,6 +11,7 @@
 #include "IVideoDriver.h"
 #include "os.h"
 #include "COpenGLDriver.h"
+#include "COpenGLTexture.h"
 #include "COpenGLCacheHandler.h"
 #include "COpenGLMaterialRenderer.h"
 

source/Irrlicht/COpenGLTexture.cpp

@@ -110,7 +110,7 @@ COpenGLTexture::COpenGLTexture(const io::path& name, const core::dimension2d<u32
 #endif
 
 	COpenGLCacheHandler* cacheHandler = Driver->getCacheHandler();
-	const COpenGLTexture* prevTexture = cacheHandler->TextureCache[0];
+	const COpenGLTexture* prevTexture = cacheHandler->getTextureCache()[0];
 
 	DriverType = EDT_OPENGL;
 
@@ -141,7 +141,7 @@ COpenGLTexture::COpenGLTexture(const io::path& name, const core::dimension2d<u32
 
 	glGenTextures(1, &TextureName);
 
-	cacheHandler->TextureCache.set(0, this);
+	cacheHandler->getTextureCache().set(0, this);
 
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, FilteringType);
 	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
@@ -157,14 +157,14 @@ COpenGLTexture::COpenGLTexture(const io::path& name, const core::dimension2d<u32
 
 	glTexImage2D(GL_TEXTURE_2D, 0, InternalFormat, OriginalSize.Width, OriginalSize.Height, 0, PixelFormat, PixelType, 0);
 
-	cacheHandler->TextureCache.set(0, prevTexture);
+	cacheHandler->getTextureCache().set(0, prevTexture);
 }
 
 
 //! destructor
 COpenGLTexture::~COpenGLTexture()
 {
-	Driver->getCacheHandler()->TextureCache.remove(this);
+	Driver->getCacheHandler()->getTextureCache().remove(this);
 
 	if (TextureName)
 		glDeleteTextures(1, &TextureName);
@@ -480,7 +480,7 @@ void COpenGLTexture::uploadTexture(bool newTexture, void* mipmapData, u32 level)
 	}
 
 	COpenGLCacheHandler* cacheHandler = Driver->getCacheHandler();
-	const COpenGLTexture* prevTexture = cacheHandler->TextureCache[0];
+	const COpenGLTexture* prevTexture = cacheHandler->getTextureCache()[0];
 
 	// get correct opengl color data values
 	GLenum oldInternalFormat = InternalFormat;
@@ -490,7 +490,7 @@ void COpenGLTexture::uploadTexture(bool newTexture, void* mipmapData, u32 level)
 	if (!newTexture)
 		InternalFormat=oldInternalFormat;
 
-	cacheHandler->TextureCache.set(0, this);
+	cacheHandler->getTextureCache().set(0, this);
 
 	if (Driver->testGLError())
 		os::Printer::log("Could not bind Texture", ELL_ERROR);
@@ -604,7 +604,7 @@ void COpenGLTexture::uploadTexture(bool newTexture, void* mipmapData, u32 level)
 	if (Driver->testGLError())
 		os::Printer::log("Could not glTexImage2D", ELL_ERROR);
 
-	cacheHandler->TextureCache.set(0, prevTexture);
+	cacheHandler->getTextureCache().set(0, prevTexture);
 }
 
 
@@ -615,9 +615,9 @@ void* COpenGLTexture::lock(E_TEXTURE_LOCK_MODE mode, u32 mipmapLevel)
 		return 0;
 
 	COpenGLCacheHandler* cacheHandler = Driver->getCacheHandler();
-	const COpenGLTexture* prevTexture = cacheHandler->TextureCache[0];
+	const COpenGLTexture* prevTexture = cacheHandler->getTextureCache()[0];
 
-	cacheHandler->TextureCache.set(0, this);
+	cacheHandler->getTextureCache().set(0, this);
 
 	// store info about which image is locked
 	IImage* image = (mipmapLevel==0)?Image:MipImage;
@@ -663,7 +663,7 @@ void* COpenGLTexture::lock(E_TEXTURE_LOCK_MODE mode, u32 mipmapLevel)
 		}
 		if (!image)
 		{
-			cacheHandler->TextureCache.set(0, prevTexture);
+			cacheHandler->getTextureCache().set(0, prevTexture);
 
 			return 0;
 		}
@@ -673,7 +673,7 @@ void* COpenGLTexture::lock(E_TEXTURE_LOCK_MODE mode, u32 mipmapLevel)
 			u8* pixels = static_cast<u8*>(image->lock());
 			if (!pixels)
 			{
-				cacheHandler->TextureCache.set(0, prevTexture);
+				cacheHandler->getTextureCache().set(0, prevTexture);
 
 				return 0;
 			}
@@ -718,7 +718,7 @@ void* COpenGLTexture::lock(E_TEXTURE_LOCK_MODE mode, u32 mipmapLevel)
 		}
 	}
 
-	cacheHandler->TextureCache.set(0, prevTexture);
+	cacheHandler->getTextureCache().set(0, prevTexture);
 
 	return image->lock();
 }
@@ -791,16 +791,16 @@ void COpenGLTexture::regenerateMipMapLevels(void* mipmapData)
 	}
 
 	COpenGLCacheHandler* cacheHandler = Driver->getCacheHandler();
-	const COpenGLTexture* prevTexture = cacheHandler->TextureCache[0];
+	const COpenGLTexture* prevTexture = cacheHandler->getTextureCache()[0];
 
-	cacheHandler->TextureCache.set(0, this);
+	cacheHandler->getTextureCache().set(0, this);
 
 	// hardware moethods for generate mipmaps.
 	if (!mipmapData && AutomaticMipmapUpdate && !MipmapLegacyMode)
 	{
 		Driver->irrGlGenerateMipmap(GL_TEXTURE_2D);
 
-		cacheHandler->TextureCache.set(0, prevTexture);
+		cacheHandler->getTextureCache().set(0, prevTexture);
 
 		return;
 	}
@@ -857,7 +857,7 @@ void COpenGLTexture::regenerateMipMapLevels(void* mipmapData)
 	if (!mipmapData)
 		delete [] target;
 
-	cacheHandler->TextureCache.set(0, prevTexture);
+	cacheHandler->getTextureCache().set(0, prevTexture);
 }
 
 COpenGLTexture::SStatesCache& COpenGLTexture::getStatesCache() const

source/Irrlicht/Irrlicht10.0.vcxproj

@@ -1008,6 +1008,7 @@
     <ClInclude Include="CGeometryCreator.h" />
     <ClInclude Include="CMeshCache.h" />
     <ClInclude Include="CMeshManipulator.h" />
+    <ClInclude Include="COGLCoreCacheHandler.h" />
     <ClInclude Include="COGLCoreFeature.h" />
     <ClInclude Include="COGLCoreRenderTarget.h" />
     <ClInclude Include="COpenGLCacheHandler.h" />

source/Irrlicht/Irrlicht10.0.vcxproj.filters

@@ -1312,6 +1312,9 @@
     <ClInclude Include="COpenGLTexture.h">
       <Filter>Irrlicht\video\OpenGL</Filter>
     </ClInclude>
+    <ClInclude Include="COGLCoreCacheHandler.h">
+      <Filter>Irrlicht\video\OpenGL Core</Filter>
+    </ClInclude>
     <ClInclude Include="COGLCoreFeature.h">
       <Filter>Irrlicht\video\OpenGL Core</Filter>
     </ClInclude>

source/Irrlicht/Irrlicht11.0.vcxproj

@@ -1008,6 +1008,7 @@
     <ClInclude Include="CGeometryCreator.h" />
     <ClInclude Include="CMeshCache.h" />
     <ClInclude Include="CMeshManipulator.h" />
+    <ClInclude Include="COGLCoreCacheHandler.h" />
     <ClInclude Include="COGLCoreFeature.h" />
     <ClInclude Include="COGLCoreRenderTarget.h" />
     <ClInclude Include="COpenGLCacheHandler.h" />

source/Irrlicht/Irrlicht11.0.vcxproj.filters

@@ -1312,6 +1312,9 @@
     <ClInclude Include="COpenGLTexture.h">
       <Filter>Irrlicht\video\OpenGL</Filter>
     </ClInclude>
+    <ClInclude Include="COGLCoreCacheHandler.h">
+      <Filter>Irrlicht\video\OpenGL Core</Filter>
+    </ClInclude>
     <ClInclude Include="COGLCoreFeature.h">
       <Filter>Irrlicht\video\OpenGL Core</Filter>
     </ClInclude>

source/Irrlicht/Irrlicht12.0.vcxproj

@@ -1008,6 +1008,7 @@
     <ClInclude Include="CGeometryCreator.h" />
     <ClInclude Include="CMeshCache.h" />
     <ClInclude Include="CMeshManipulator.h" />
+    <ClInclude Include="COGLCoreCacheHandler.h" />
     <ClInclude Include="COGLCoreFeature.h" />
     <ClInclude Include="COGLCoreRenderTarget.h" />
     <ClInclude Include="COpenGLCacheHandler.h" />

source/Irrlicht/Irrlicht12.0.vcxproj.filters

@@ -1312,6 +1312,9 @@
     <ClInclude Include="COpenGLTexture.h">
       <Filter>Irrlicht\video\OpenGL</Filter>
     </ClInclude>
+    <ClInclude Include="COGLCoreCacheHandler.h">
+      <Filter>Irrlicht\video\OpenGL Core</Filter>
+    </ClInclude>
     <ClInclude Include="COGLCoreFeature.h">
       <Filter>Irrlicht\video\OpenGL Core</Filter>
     </ClInclude>

source/Irrlicht/Irrlicht14.0.vcxproj

@@ -1018,6 +1018,7 @@
     <ClInclude Include="CGeometryCreator.h" />
     <ClInclude Include="CMeshCache.h" />
     <ClInclude Include="CMeshManipulator.h" />
+    <ClInclude Include="COGLCoreCacheHandler.h" />
     <ClInclude Include="COGLCoreFeature.h" />
     <ClInclude Include="COGLCoreRenderTarget.h" />
     <ClInclude Include="COpenGLCacheHandler.h" />

source/Irrlicht/Irrlicht14.0.vcxproj.filters

@@ -1312,6 +1312,9 @@
     <ClInclude Include="COpenGLTexture.h">
       <Filter>Irrlicht\video\OpenGL</Filter>
     </ClInclude>
+    <ClInclude Include="COGLCoreCacheHandler.h">
+      <Filter>Irrlicht\video\OpenGL Core</Filter>
+    </ClInclude>
     <ClInclude Include="COGLCoreFeature.h">
       <Filter>Irrlicht\video\OpenGL Core</Filter>
     </ClInclude>