+Unity Runtime codeHEADmaster

1 files changed, 3079 insertions, 0 deletions

diff --git a/Runtime/GfxDevice/opengl/GfxDeviceGL.cpp b/Runtime/GfxDevice/opengl/GfxDeviceGL.cpp
new file mode 100644
index 0000000..dfc2926
--- /dev/null
+++ b/Runtime/GfxDevice/opengl/GfxDeviceGL.cpp
@@ -0,0 +1,3079 @@
+#include "UnityPrefix.h"
+#include "Runtime/GfxDevice/GfxDevice.h"
+#include "Runtime/Shaders/GraphicsCaps.h"
+#include "Runtime/Shaders/MaterialProperties.h"
+#include "UnityGL.h"
+#include "GLContext.h"
+#include "TexturesGL.h"
+#include "TimerQueryGL.h"
+#include "ARBVBO.h"
+#include "NullVBO.h"
+#include "CombinerGL.h"
+#include "External/shaderlab/Library/program.h"
+#include "External/shaderlab/Library/texenv.h"
+#include "External/shaderlab/Library/TextureBinding.h"
+#include "ChannelsGL.h"
+#include "Runtime/Threads/AtomicOps.h"
+#include "Runtime/Allocator/LinearAllocator.h"
+#include "GpuProgramsGL.h"
+#include "ArbGpuProgamGL.h"
+#include "TextureIdMapGL.h"
+#include "Runtime/Graphics/GraphicsHelper.h"
+#include "Runtime/GfxDevice/GpuProgramParamsApply.h"
+#if UNITY_EDITOR && UNITY_WIN
+#include "GLWindow.h"
+#endif
+#include "Runtime/Misc/Plugins.h"
+
+
+void InvalidateChannelStateGL(); // ChannelsGL.cpp
+void InvalidateFPParamCacheGL(); // GpuProgramsGL.cpp
+bool IsActiveRenderTargetWithColorGL(); // RenderTextureGL.cpp
+
+namespace ShaderLab {
+	TexEnv* GetTexEnvForBinding( const TextureBinding& binding, const PropertySheet* props ); // pass.cpp
+}
+
+static const unsigned int kBlendModeGL[] = {
+	GL_ZERO, GL_ONE, GL_DST_COLOR, GL_SRC_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_COLOR,
+	GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA_SATURATE, GL_ONE_MINUS_SRC_ALPHA,
+};
+
+static const unsigned int kBlendFuncGL[] = {
+	GL_FUNC_ADD, GL_FUNC_SUBTRACT,
+	GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX,
+};
+
+static const unsigned int kCmpFuncGL[] = {
+	GL_NEVER, GL_NEVER, GL_LESS, GL_EQUAL, GL_LEQUAL, GL_GREATER, GL_NOTEQUAL, GL_GEQUAL, GL_ALWAYS
+};
+
+static const unsigned int kStencilOpGL[] = {
+	GL_KEEP, GL_ZERO, GL_REPLACE, GL_INCR,
+	GL_DECR, GL_INVERT, GL_INCR_WRAP, GL_DECR_WRAP
+};
+
+static const GLenum kColorMatModeGL[kColorMatTypeCount] = { 0, GL_EMISSION, GL_AMBIENT_AND_DIFFUSE };
+
+static const unsigned long kTexDimTableGL[kTexDimCount] = {0, GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP_ARB, 0};
+
+static GLenum kWrapModeGL[kTexWrapCount] = { GL_REPEAT, GL_CLAMP_TO_EDGE };
+
+static const GLint kMinFilterGL[kTexFilterCount] = { GL_NEAREST_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR };
+
+static const unsigned int kFogModeGL[kFogModeCount] = { GL_LINEAR, GL_LINEAR, GL_EXP, GL_EXP2 };
+
+GLenum kTopologyGL[kPrimitiveTypeCount] = { GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_QUADS, GL_LINES, GL_LINE_STRIP, GL_POINTS };
+
+
+GfxThreadableDevice* CreateGLGfxDevice();
+const unsigned long* GetGLTextureDimensionTable();
+unsigned int GetGLShaderImplTarget( ShaderImplType implType );
+void InvalidateActiveShaderStateGL( ShaderType type );
+
+#if SUPPORT_REPRODUCE_LOG_GFX_TRACE
+#include "Runtime/Misc/ReproductionLog.h"
+#define GFX_LOG(pattern) LogToScreenshotLog(__FUNCTION__+(" "+Format pattern))
+#else
+#define GFX_LOG(pattern)
+#endif
+
+
+static inline void ActivateTextureUnitGL (int unit)
+{
+	// When using the fixed-function texture, the correct assert is:
+	//Assert(unit >= 0 && unit < gGraphicsCaps.maxTexUnits);
+	
+	Assert(unit >= 0 && unit < gGraphicsCaps.maxTexImageUnits);
+	
+	GFX_LOG(("%d", unit));
+	if (gGraphicsCaps.maxTexImageUnits > 1)
+		OGL_CALL(glActiveTextureARB(GL_TEXTURE0_ARB + unit));
+}
+
+
+// --------------------------------------------------------------------------
+
+struct DeviceBlendStateGL : public DeviceBlendState
+{
+	UInt32	alphaFunc;
+};
+
+
+struct DeviceDepthStateGL : public DeviceDepthState
+{
+	UInt32		depthFunc;
+};
+
+struct DeviceStencilStateGL : public DeviceStencilState
+{
+	GLenum	stencilFuncFront;
+	GLenum	stencilFailOpFront;
+	GLenum	depthFailOpFront;
+	GLenum	depthPassOpFront;
+	GLenum	stencilFuncBack;
+	GLenum	stencilFailOpBack;
+	GLenum	depthFailOpBack;
+	GLenum	depthPassOpBack;
+};
+
+
+
+typedef std::map< GfxBlendState, DeviceBlendStateGL,  memcmp_less<GfxBlendState> > CachedBlendStates;
+typedef std::map< GfxDepthState, DeviceDepthStateGL,  memcmp_less<GfxDepthState> > CachedDepthStates;
+typedef std::map< GfxStencilState, DeviceStencilStateGL,  memcmp_less<GfxStencilState> > CachedStencilStates;
+typedef std::map< GfxRasterState, DeviceRasterState,  memcmp_less<GfxRasterState> > CachedRasterStates;
+
+
+// --------------------------------------------------------------------------
+
+
+struct TextureUnitStateGL
+{
+	GLuint				texID;
+	TextureDimension	texDim;
+	unsigned int		combColor, combAlpha;
+	Vector4f			color;
+	TexGenMode			texGen;
+	float				bias;
+
+	void	Invalidate();
+	void	Verify( int unit );
+};
+
+void TextureUnitStateGL::Invalidate()
+{
+	texID = -1;
+	texDim = kTexDimUnknown;
+	combColor = combAlpha = 0xFFFFFFFF;
+	color.Set( -1, -1, -1, -1 );
+	texGen = kTexGenUnknown;
+	bias = 1.0e6f;
+}
+
+// --------------------------------------------------------------------------
+
+
+struct VertexLightStateGL
+{
+	int		enabled; // 0/1 or -1 if unknown
+	float	attenQuad;
+	float	spotAngle;
+
+	void	Invalidate();
+	void	Verify( int unit );
+};
+
+void VertexLightStateGL::Invalidate()
+{
+	enabled = -1;
+	attenQuad = -1.0f;
+	spotAngle = -1000.0f; // -1.0f is used to flag non-spot lights, so it would be a valid value
+}
+
+// --------------------------------------------------------------------------
+
+
+struct DeviceStateGL
+{
+	GLuint			m_SharedFBO;
+	GLuint			m_HelperFBO;
+	int				m_TextureIDGenerator;
+
+	int				depthFunc;
+	int				depthWrite; // 0/1 or -1
+
+	int				blending;
+	int				srcBlend, destBlend, srcBlendAlpha, destBlendAlpha; // GL modes
+	int				blendOp, blendOpAlpha; // GL modes
+	CompareFunction alphaFunc;
+	float			alphaValue;
+	int				alphaToMask;
+
+	CullMode		culling;
+	bool			appBackfaceMode, userBackfaceMode;
+	bool			wireframe;
+	NormalizationMode	normalization;
+	int				scissor;
+
+
+	int				lighting;
+	Vector4f		matDiffuse, matAmbient, matSpecular, matEmissive;
+	Vector4f		ambient;
+	float			matShininess;
+	ColorMaterialMode	colorMaterial;
+
+	float offsetFactor, offsetUnits;
+
+	GpuProgram* activeGpuProgram[kShaderTypeCount];
+	const GpuProgramParameters* activeGpuProgramParams[kShaderTypeCount];
+	ShaderImplType shaderEnabledImpl[kShaderTypeCount];
+	int	shaderEnabledID[kShaderTypeCount];
+
+	int separateSpecular;
+
+	int				colorWriteMask; // ColorWriteMask combinations
+
+	TextureUnitStateGL	textures[kMaxSupportedTextureUnits];
+	VertexLightStateGL	vertexLights[kMaxSupportedVertexLights];
+
+	DynamicVBO*	m_DynamicVBO;
+
+	int			viewport[4];
+	int			scissorRect[4];
+
+	GfxPrimitiveType	m_ImmediateMode;
+	dynamic_array<UInt8>	m_ImmediateVertices;
+
+	#if GFX_USES_VIEWPORT_OFFSET
+	float	viewportOffsetX, viewportOffsetY;
+	#endif
+
+	CachedBlendStates			m_CachedBlendStates;
+	CachedDepthStates			m_CachedDepthStates;
+	CachedStencilStates			m_CachedStencilStates;
+	CachedRasterStates			m_CachedRasterStates;
+
+	DeviceBlendStateGL*			m_CurrBlendState;
+	DeviceDepthStateGL*			m_CurrDepthState;
+	const DeviceStencilStateGL*	m_CurrStencilState;
+	int							m_StencilRef;
+	DeviceRasterState*			m_CurrRasterState;
+	Matrix4x4f					m_WorldMatrix;
+
+	void	Invalidate(BuiltinShaderParamValues& builtins);
+	void	Verify();
+};
+
+static void ApplyBackfaceMode( const DeviceStateGL& state );
+
+
+void DeviceStateGL::Invalidate (BuiltinShaderParamValues& builtins)
+{
+	int i;
+
+	depthFunc = kFuncUnknown;
+	depthWrite = -1;
+
+	blending = -1; // unknown
+	srcBlend = destBlend = srcBlendAlpha = destBlendAlpha = -1; // won't match any GL mode
+	blendOp = blendOpAlpha = -1; // won't match any GL mode
+	alphaFunc = kFuncUnknown;
+	alphaValue = -1.0f;
+	alphaToMask = -1; // unknown
+
+	culling = kCullUnknown;
+	normalization = kNormalizationUnknown;
+	scissor = -1;
+
+	lighting = -1;
+	matDiffuse.Set( -1, -1, -1, -1 );
+	matAmbient.Set( -1, -1, -1, -1 );
+	matSpecular.Set( -1, -1, -1, -1 );
+	matEmissive.Set( -1, -1, -1, -1 );
+	ambient.Set( -1, -1, -1, -1 );
+	matShininess = -1.0f;
+	colorMaterial = kColorMatUnknown;
+
+	offsetFactor = offsetUnits = -1000.0f;
+	for( i = 0; i < kShaderTypeCount; ++i )
+	{
+		activeGpuProgram[i] = NULL;
+		activeGpuProgramParams[i] = NULL;
+		shaderEnabledImpl[i] = kShaderImplUndefined;
+		shaderEnabledID[i] = -1;
+	}
+
+	separateSpecular = -1;
+
+	colorWriteMask = -1; // TBD ?
+
+	m_StencilRef = -1;
+
+	for( i = 0; i < kMaxSupportedTextureUnits; ++i )
+		textures[i].Invalidate();
+	for( i = 0; i < kMaxSupportedVertexLights; ++i )
+		vertexLights[i].Invalidate();
+	InvalidateChannelStateGL();
+	InvalidateFPParamCacheGL();
+
+	// make sure we aren't using any programs
+	if( gGraphicsCaps.gl.hasGLSL )
+		glUseProgramObjectARB( 0 );
+	glDisable( GL_VERTEX_PROGRAM_ARB );
+	glDisable( GL_FRAGMENT_PROGRAM_ARB );
+
+	// misc. state
+	glHint (GL_FOG_HINT, GL_NICEST);
+	glLightModelf (GL_LIGHT_MODEL_LOCAL_VIEWER, 1.0F);
+
+	// Setup GL_EYE_PLANE for R coordinate to reasonable value. This has to be done initially,
+	// and NOT when some arbitrary matrix is already set up. So it's important
+	// to load identity matrix here and only then setup GL_EYE_PLANE value.
+	glLoadIdentity();
+	m_WorldMatrix.SetIdentity();
+	builtins.GetWritableMatrixParam(kShaderMatView).SetIdentity();
+	builtins.GetWritableMatrixParam(kShaderMatProj).SetIdentity();
+	builtins.GetWritableMatrixParam(kShaderMatViewProj).SetIdentity();
+	const float zplane[4] = {0.0f,0.0f,1.0f,0.0f};
+	for( i = 0; i < gGraphicsCaps.maxTexUnits; ++i )
+	{
+		ActivateTextureUnitGL (i);
+		glTexGenfv (GL_R, GL_EYE_PLANE, zplane);
+	}
+
+	// make sure backface mode is in synch
+	ApplyBackfaceMode( *this );
+
+	// make sure no vertex buffers are bound
+	UnbindVertexBuffersGL();
+
+	m_ImmediateMode = kPrimitiveTriangles;
+	m_ImmediateVertices.clear();
+
+	#if GFX_DEVICE_VERIFY_ENABLE
+	Verify();
+	#endif
+}
+
+#include "GfxDeviceGL.h"
+
+// GLContext.cpp
+#if UNITY_WIN
+bool CreateMasterGraphicsContext();
+#endif
+void CleanupMasterContext();
+
+
+GfxThreadableDevice* CreateGLGfxDevice()
+{
+	#if UNITY_WIN
+	SetMasterContextClassName(L"WindowGLClassName");
+	if( !CreateMasterGraphicsContext() )
+		return NULL;
+	#endif
+	GraphicsContextHandle context = GetMasterGraphicsContext();
+	if( !context.IsValid() )
+		return NULL;
+
+	SetMainGraphicsContext( context );
+	ActivateGraphicsContext (context, true);
+
+	InitGLExtensions();
+	gGraphicsCaps.InitGL();
+	GLAssert();
+
+	return UNITY_NEW_AS_ROOT(GFX_GL_IMPL(), kMemGfxDevice, "GLGfxDevice", "");
+}
+
+
+GFX_GL_IMPL::GFX_GL_IMPL()
+{
+	#if !GFX_DEVICE_VIRTUAL
+	impl = new GfxDeviceImpl();
+	#endif
+	STATE.m_SharedFBO = 0;
+	STATE.m_HelperFBO = 0;
+	STATE.m_TextureIDGenerator = 0;
+	STATE.appBackfaceMode = false;
+	STATE.userBackfaceMode = false;
+	STATE.m_DynamicVBO = NULL;
+	STATE.wireframe = false;
+	#if GFX_USES_VIEWPORT_OFFSET
+	STATE.viewportOffsetX = 0;
+	STATE.viewportOffsetY = 0;
+	#endif
+
+	OnCreate();
+	InvalidateState();
+
+	m_Renderer = kGfxRendererOpenGL;
+	m_UsesOpenGLTextureCoords = true;
+	m_UsesHalfTexelOffset = false;
+	// Should be safe to assume we can get 24 bits for the framebuffer on desktop.
+	m_FramebufferDepthFormat = kDepthFormat24;
+	m_IsThreadable = true;
+
+	STATE.m_CurrBlendState = NULL;
+	STATE.m_CurrDepthState = NULL;
+	STATE.m_CurrStencilState = NULL;
+	STATE.m_CurrRasterState = NULL;
+
+	STATE.m_WorldMatrix.SetIdentity();
+
+	m_MaxBufferedFrames = -1; // no limiting
+
+	STATE.viewport[0] = STATE.viewport[1] = STATE.viewport[2] = STATE.viewport[3] = 0;
+	STATE.scissorRect[0] = STATE.scissorRect[1] = STATE.scissorRect[2] = STATE.scissorRect[3] = 0;
+
+	extern RenderSurfaceBase* CreateBackBufferColorSurfaceGL();
+	SetBackBufferColorSurface(CreateBackBufferColorSurfaceGL());
+
+	extern RenderSurfaceBase* CreateBackBufferDepthSurfaceGL();
+	SetBackBufferDepthSurface(CreateBackBufferDepthSurfaceGL());
+}
+
+GFX_GL_IMPL::~GFX_GL_IMPL()
+{
+#if !ENABLE_GFXDEVICE_REMOTE_PROCESS_WORKER
+	PluginsSetGraphicsDevice (NULL, kGfxRendererOpenGL, kGfxDeviceEventShutdown);
+#endif
+	if (STATE.m_SharedFBO)
+		glDeleteFramebuffersEXT (1, &STATE.m_SharedFBO);
+	if (STATE.m_HelperFBO)
+		glDeleteFramebuffersEXT (1, &STATE.m_HelperFBO);
+	delete STATE.m_DynamicVBO;
+
+	#if !GFX_DEVICE_VIRTUAL
+	delete impl;
+	#endif
+
+	#if UNITY_WIN
+	CleanupMasterContext();
+	#endif
+	CleanupGLExtensions();
+}
+
+void GFX_GL_IMPL::OnDeviceCreated (bool callingFromRenderThread)
+{
+	// needs to activate graphics context on both main & render threads
+	ActivateGraphicsContext (GetMainGraphicsContext(), true);
+}
+
+void GFX_GL_IMPL::InvalidateState()
+{
+	m_FogParams.Invalidate();
+	STATE.Invalidate(m_BuiltinParamValues);
+
+	// Disable fog initially. At least on Mac/Intel, initial state seems to be off
+	// for fixed function (correct), but on for fragment/vertex programs (incorrect).
+	glFogf( GL_FOG_DENSITY, 0.0f );
+	glDisable( GL_FOG );
+	m_FogParams.mode = kFogDisabled;
+	m_FogParams.density = 0.0f;
+}
+
+
+const int kFPParamCacheSize = 32; // don't make this larger than 32 (won't fit into s_FPParamCacheValid mask)
+extern UInt32 s_FPParamCacheValid;
+extern Vector4f s_FPParamCache[kFPParamCacheSize];
+
+
+#define SET_LOCAL_MATRIX_PARAM( type, index, ptr )												\
+	OGL_CALL(glProgramLocalParameter4fARB( type, index+0, ptr[0], ptr[4], ptr[8], ptr[12] ));	\
+	OGL_CALL(glProgramLocalParameter4fARB( type, index+1, ptr[1], ptr[5], ptr[9], ptr[13] ));	\
+	OGL_CALL(glProgramLocalParameter4fARB( type, index+2, ptr[2], ptr[6], ptr[10], ptr[14] ));	\
+	OGL_CALL(glProgramLocalParameter4fARB( type, index+3, ptr[3], ptr[7], ptr[11], ptr[15] ));	\
+
+
+#define SET_ENV_MATRIX_PARAM( type, index, ptr )												\
+	OGL_CALL(glProgramEnvParameter4fARB( type, index+0, ptr[0], ptr[4], ptr[8], ptr[12] ));		\
+	OGL_CALL(glProgramEnvParameter4fARB( type, index+1, ptr[1], ptr[5], ptr[9], ptr[13] ));		\
+	OGL_CALL(glProgramEnvParameter4fARB( type, index+2, ptr[2], ptr[6], ptr[10], ptr[14] ));	\
+	OGL_CALL(glProgramEnvParameter4fARB( type, index+3, ptr[3], ptr[7], ptr[11], ptr[15] ));	\
+
+
+static void GLSetShaderMatrixConstant (ShaderImplType type, int index, int rows, int cols, const float* ptr)
+{
+	if (type == kShaderImplVertex)
+	{
+		SET_LOCAL_MATRIX_PARAM(GL_VERTEX_PROGRAM_ARB, index, ptr);
+	}
+	else if (type == kShaderImplFragment)
+	{
+		if (gGraphicsCaps.gl.cacheFPParamsWithEnvs)
+		{
+			// don't care here about cache
+			UInt32 mask0 = index+0 < kFPParamCacheSize ? 1 << (index+0) : 0;
+			UInt32 mask1 = index+1 < kFPParamCacheSize ? 1 << (index+1) : 0;
+			UInt32 mask2 = index+2 < kFPParamCacheSize ? 1 << (index+2) : 0;
+			UInt32 mask3 = index+3 < kFPParamCacheSize ? 1 << (index+3) : 0;
+
+			s_FPParamCacheValid &= ~mask0;
+			s_FPParamCacheValid &= ~mask1;
+			s_FPParamCacheValid &= ~mask2;
+			s_FPParamCacheValid &= ~mask3;
+
+			SET_ENV_MATRIX_PARAM(GL_FRAGMENT_PROGRAM_ARB, index, ptr);
+		}
+		else
+		{
+			SET_LOCAL_MATRIX_PARAM(GL_FRAGMENT_PROGRAM_ARB, index, ptr);
+		}
+	}
+	else if (type == kShaderImplBoth)
+	{
+		Assert(rows == 4 && cols == 4);
+		OGL_CALL(glUniformMatrix4fvARB(index, 1, false, ptr));
+	}
+	else
+	{
+		AssertString("unknown shader type");
+	}
+}
+
+
+#undef SET_ENV_MATRIX_PARAM
+#undef SET_LOCAL_MATRIX_PARAM
+
+static void GLSetShaderVectorConstant (ShaderImplType shaderType, ShaderParamType type, int index, int dim, const Vector4f& val)
+{
+	if (shaderType == kShaderImplVertex)
+	{
+		OGL_CALL(glProgramLocalParameter4fvARB(GL_VERTEX_PROGRAM_ARB, index, val.GetPtr()));
+	}
+	else if (shaderType == kShaderImplFragment)
+	{
+		if (gGraphicsCaps.gl.cacheFPParamsWithEnvs)
+		{
+			UInt32 mask = 1 << index;
+			if (index >= kFPParamCacheSize)
+			{
+				OGL_CALL(glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, index, val.GetPtr()));
+			}
+			else
+			{
+				if( !(s_FPParamCacheValid & mask) || s_FPParamCache[index] != val )
+				{
+					OGL_CALL(glProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, index, val.GetPtr()));
+					s_FPParamCache[index] = val;
+				}
+				s_FPParamCacheValid |= mask;
+			}
+		}
+		else
+			OGL_CALL(glProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, index, val.GetPtr()));
+	}
+	else if (shaderType == kShaderImplBoth)
+	{
+		if (type == kShaderParamFloat)
+		{
+			switch (dim) {
+			case 1: OGL_CALL(glUniform1fvARB(index, 1, val.GetPtr())); break;
+			case 2: OGL_CALL(glUniform2fvARB(index, 1, val.GetPtr())); break;
+			case 3: OGL_CALL(glUniform3fvARB(index, 1, val.GetPtr())); break;
+			case 4: OGL_CALL(glUniform4fvARB(index, 1, val.GetPtr())); break;
+			default: AssertString ("unknown uniform dimension"); break;
+			}
+		}
+		else
+		{
+			// In theory Uniform*f can also be used to load bool uniforms, in practice
+			// some drivers don't like that. So load both integers and bools via *i functions.
+			int ival[4] = {val.x, val.y, val.z, val.w};
+			switch (dim) {
+			case 1: OGL_CALL(glUniform1ivARB(index, 1, ival)); break;
+			case 2: OGL_CALL(glUniform2ivARB(index, 1, ival)); break;
+			case 3: OGL_CALL(glUniform3ivARB(index, 1, ival)); break;
+			case 4: OGL_CALL(glUniform4ivARB(index, 1, ival)); break;
+			default: AssertString ("unknown uniform dimension"); break;
+			}
+		}
+	}
+	else
+	{
+		AssertString("unknown shader type");
+	}
+}
+
+
+struct SetValuesFunctorGL
+{
+	SetValuesFunctorGL(GfxDevice& device, const ShaderImplType* shaderEnabledImpl) : m_Device(device), m_ShaderEnabledImpl(shaderEnabledImpl) { }
+	GfxDevice& m_Device;
+	const ShaderImplType* m_ShaderEnabledImpl;
+	void SetVectorVal (ShaderType shaderType, ShaderParamType type, int index, const float* ptr, int cols, const GpuProgramParameters& params, int cbIndex)
+	{
+		GLSetShaderVectorConstant (m_ShaderEnabledImpl[shaderType], type, index, cols, *(const Vector4f*)ptr);
+	}
+	void SetMatrixVal (ShaderType shaderType, int index, const Matrix4x4f* ptr, int rows, const GpuProgramParameters& params, int cbIndex)
+	{
+		GLSetShaderMatrixConstant (m_ShaderEnabledImpl[shaderType], index, rows, 4, (const float*)ptr);
+	}
+	void SetTextureVal (ShaderType shaderType, int index, int samplerIndex, TextureDimension dim, TextureID texID)
+	{
+		UInt32 texIndex = UInt32(index) >> 24;
+		m_Device.SetTexture (shaderType, texIndex, samplerIndex, texID, dim, std::numeric_limits<float>::infinity());
+	}
+};
+
+
+void GFX_GL_IMPL::BeforeDrawCall( bool immediateMode )
+{
+	GFX_LOG(("%d",immediateMode));
+
+	// Special Matrix parameters (defined by Unity as built-ins
+	// but not present in GL default state)
+	const BuiltinShaderParamIndices& paramsVS = *m_BuiltinParamIndices[kShaderVertex];
+	const BuiltinShaderParamIndices& paramsFS = *m_BuiltinParamIndices[kShaderFragment];
+
+	// M matrix
+	if (paramsVS.mat[kShaderInstanceMatM].gpuIndex >= 0)
+	{
+		BuiltinShaderParamIndices::MatrixParamData matParam = paramsVS.mat[kShaderInstanceMatM];
+		const Matrix4x4f& mat = STATE.m_WorldMatrix;
+		Assert(matParam.rows == 4 && matParam.cols == 4);
+		GLSetShaderMatrixConstant (STATE.shaderEnabledImpl[kShaderVertex], matParam.gpuIndex, matParam.rows, matParam.cols, mat.GetPtr());
+	}
+	if (paramsFS.mat[kShaderInstanceMatM].gpuIndex >= 0)
+	{
+		BuiltinShaderParamIndices::MatrixParamData matParam = paramsFS.mat[kShaderInstanceMatM];
+		const Matrix4x4f& mat = STATE.m_WorldMatrix;
+		Assert(matParam.rows == 4 && matParam.cols == 4);
+		GLSetShaderMatrixConstant (STATE.shaderEnabledImpl[kShaderFragment], matParam.gpuIndex, matParam.rows, matParam.cols, mat.GetPtr());
+	}
+	// Inverse M matrix
+	if (paramsVS.mat[kShaderInstanceMatInvM].gpuIndex >= 0 || paramsFS.mat[kShaderInstanceMatInvM].gpuIndex >= 0)
+	{
+		Matrix4x4f mat = STATE.m_WorldMatrix;
+		if (STATE.normalization == kNormalizationScale)
+		{
+			// Kill scale in the world matrix before inverse
+			float invScale = m_BuiltinParamValues.GetInstanceVectorParam(kShaderInstanceVecScale).w;
+			mat.Get (0, 0) *= invScale;
+			mat.Get (1, 0) *= invScale;
+			mat.Get (2, 0) *= invScale;
+			mat.Get (0, 1) *= invScale;
+			mat.Get (1, 1) *= invScale;
+			mat.Get (2, 1) *= invScale;
+			mat.Get (0, 2) *= invScale;
+			mat.Get (1, 2) *= invScale;
+			mat.Get (2, 2) *= invScale;
+		}
+		Matrix4x4f inverseMat;
+		Matrix4x4f::Invert_General3D (mat, inverseMat);
+		if (paramsVS.mat[kShaderInstanceMatInvM].gpuIndex >= 0)
+		{
+			BuiltinShaderParamIndices::MatrixParamData matParam = paramsVS.mat[kShaderInstanceMatInvM];
+			Assert(matParam.rows == 4 && matParam.cols == 4);
+			GLSetShaderMatrixConstant (STATE.shaderEnabledImpl[kShaderVertex], matParam.gpuIndex, matParam.rows, matParam.cols, inverseMat.GetPtr());
+		}
+		if (paramsFS.mat[kShaderInstanceMatInvM].gpuIndex >= 0)
+		{
+			BuiltinShaderParamIndices::MatrixParamData matParam = paramsFS.mat[kShaderInstanceMatInvM];
+			Assert(matParam.rows == 4 && matParam.cols == 4);
+			GLSetShaderMatrixConstant (STATE.shaderEnabledImpl[kShaderFragment], matParam.gpuIndex, matParam.rows, matParam.cols, inverseMat.GetPtr());
+		}
+	}
+
+	// Set instance vector parameters
+	for (int i = 0; i < kShaderInstanceVecCount; ++i)
+	{
+		const BuiltinShaderParamIndices::VectorParamData& parVS = paramsVS.vec[i];
+		if (parVS.gpuIndex >= 0)
+			GLSetShaderVectorConstant (STATE.shaderEnabledImpl[kShaderVertex], kShaderParamFloat, parVS.gpuIndex, parVS.dim, m_BuiltinParamValues.GetInstanceVectorParam((ShaderBuiltinInstanceVectorParam)i));
+		const BuiltinShaderParamIndices::VectorParamData& parFS = paramsFS.vec[i];
+		if (parFS.gpuIndex >= 0)
+			GLSetShaderVectorConstant (STATE.shaderEnabledImpl[kShaderFragment], kShaderParamFloat, parFS.gpuIndex, parFS.dim, m_BuiltinParamValues.GetInstanceVectorParam((ShaderBuiltinInstanceVectorParam)i));
+	}
+
+	SetValuesFunctorGL setValuesFunc(*this, STATE.shaderEnabledImpl);
+	ApplyMaterialPropertyBlockValues(m_MaterialProperties, STATE.activeGpuProgram, STATE.activeGpuProgramParams, setValuesFunc);
+}
+
+
+DeviceBlendState* GFX_GL_IMPL::CreateBlendState(const GfxBlendState& state)
+{
+
+	std::pair<CachedBlendStates::iterator, bool> result = STATE.m_CachedBlendStates.insert(std::make_pair(state, DeviceBlendStateGL()));
+	if (!result.second)
+		return &result.first->second;
+
+	DeviceBlendStateGL& glstate = result.first->second;
+	memcpy(&glstate.sourceState, &state, sizeof(GfxBlendState));
+	DebugAssertIf(kFuncUnknown==state.alphaTest);
+	glstate.alphaFunc = kCmpFuncGL[state.alphaTest];
+
+	return &result.first->second;
+}
+
+
+DeviceDepthState* GFX_GL_IMPL::CreateDepthState(const GfxDepthState& state)
+{
+	std::pair<CachedDepthStates::iterator, bool> result = STATE.m_CachedDepthStates.insert(std::make_pair(state, DeviceDepthStateGL()));
+	if (!result.second)
+		return &result.first->second;
+
+	DeviceDepthStateGL& glstate = result.first->second;
+	memcpy(&glstate.sourceState, &state, sizeof(GfxDepthState));
+	glstate.depthFunc = kCmpFuncGL[state.depthFunc];
+	return &result.first->second;
+}
+
+DeviceStencilState* GFX_GL_IMPL::CreateStencilState(const GfxStencilState& state)
+{
+	std::pair<CachedStencilStates::iterator, bool> result = STATE.m_CachedStencilStates.insert(std::make_pair(state, DeviceStencilStateGL()));
+	if (!result.second)
+		return &result.first->second;
+
+	DeviceStencilStateGL& st = result.first->second;
+	memcpy (&st.sourceState, &state, sizeof(state));
+	st.stencilFuncFront = kCmpFuncGL[state.stencilFuncFront];
+	st.stencilFailOpFront = kStencilOpGL[state.stencilFailOpFront];
+	st.depthFailOpFront = kStencilOpGL[state.stencilZFailOpFront];
+	st.depthPassOpFront = kStencilOpGL[state.stencilPassOpFront];
+	st.stencilFuncBack = kCmpFuncGL[state.stencilFuncBack];
+	st.stencilFailOpBack = kStencilOpGL[state.stencilFailOpBack];
+	st.depthFailOpBack = kStencilOpGL[state.stencilZFailOpBack];
+	st.depthPassOpBack = kStencilOpGL[state.stencilPassOpBack];
+	return &result.first->second;
+}
+
+
+DeviceRasterState* GFX_GL_IMPL::CreateRasterState(const GfxRasterState& state)
+{
+	std::pair<CachedRasterStates::iterator, bool> result = STATE.m_CachedRasterStates.insert(std::make_pair(state, DeviceRasterState()));
+	if (!result.second)
+		return &result.first->second;
+
+	DeviceRasterState& glstate = result.first->second;
+	memcpy(&glstate.sourceState, &state, sizeof(DeviceRasterState));
+
+	return &result.first->second;
+}
+
+void GFX_GL_IMPL::SetBlendState(const DeviceBlendState* state, float alphaRef)
+{
+	DeviceBlendStateGL* devstate = (DeviceBlendStateGL*)state;
+
+	if (STATE.m_CurrBlendState == devstate && alphaRef == STATE.alphaValue)
+		return;
+
+	STATE.m_CurrBlendState = devstate;
+	if (!STATE.m_CurrBlendState)
+		return;
+
+	int mask = devstate->sourceState.renderTargetWriteMask;
+	if (!IsActiveRenderTargetWithColorGL())
+		mask = 0;
+	if( mask != STATE.colorWriteMask ) {
+		OGL_CALL(glColorMask( (mask & kColorWriteR) != 0, (mask & kColorWriteG) != 0, (mask & kColorWriteB) != 0, (mask & kColorWriteA) != 0 ));
+		STATE.colorWriteMask = mask;
+	}
+
+	const GfxBlendState& desc = state->sourceState;
+	const CompareFunction mode = state->sourceState.alphaTest;
+	const GLenum glsrc = kBlendModeGL[desc.srcBlend];
+	const GLenum gldst = kBlendModeGL[desc.dstBlend];
+	const GLenum glsrca = kBlendModeGL[desc.srcBlendAlpha];
+	const GLenum gldsta = kBlendModeGL[desc.dstBlendAlpha];
+	const GLenum glfunc = kBlendFuncGL[desc.blendOp];
+	const GLenum glfunca = kBlendFuncGL[desc.blendOpAlpha];
+	const bool blendDisabled = (glsrc == GL_ONE && gldst == GL_ZERO && glsrca == GL_ONE && gldsta == GL_ZERO);
+
+	GFX_LOG(("%d, %d, %d, %f", desc.srcBlend, desc.dstBlend, mode, alphaRef));
+
+	// alpha blending states
+
+	if( blendDisabled )
+	{
+		if( STATE.blending != 0 )
+		{
+			OGL_CALL(glDisable (GL_BLEND));
+			STATE.blending = 0;
+		}
+	}
+	else
+	{
+		if( glsrc != STATE.srcBlend || gldst != STATE.destBlend || glsrca != STATE.srcBlendAlpha || gldsta != STATE.destBlendAlpha )
+		{
+			if (gGraphicsCaps.hasSeparateAlphaBlend)
+				OGL_CALL(glBlendFuncSeparateEXT (glsrc, gldst, glsrca, gldsta));
+			else
+				OGL_CALL(glBlendFunc( glsrc, gldst ));
+			STATE.srcBlend = glsrc;
+			STATE.destBlend = gldst;
+			STATE.srcBlendAlpha = glsrca;
+			STATE.destBlendAlpha = gldsta;
+		}
+		if (glfunc != STATE.blendOp || glfunca != STATE.blendOpAlpha)
+		{
+			bool supports = true;
+			if( (glfunc == GL_FUNC_SUBTRACT || glfunc == GL_FUNC_REVERSE_SUBTRACT) && !gGraphicsCaps.hasBlendSub )
+				supports = false;
+			if( (glfunca == GL_FUNC_SUBTRACT || glfunca == GL_FUNC_REVERSE_SUBTRACT) && !gGraphicsCaps.hasBlendSub )
+				supports = false;
+			if( (glfunc == GL_MIN || glfunc == GL_MAX) && !gGraphicsCaps.hasBlendMinMax )
+				supports = false;
+			if( (glfunca == GL_MIN || glfunca == GL_MAX) && !gGraphicsCaps.hasBlendMinMax )
+				supports = false;
+
+			if(supports)
+			{
+			if (gGraphicsCaps.hasSeparateAlphaBlend)
+				OGL_CALL(glBlendEquationSeparateEXT (glfunc, glfunca));
+			else
+				OGL_CALL(glBlendEquation (glfunc));
+			STATE.blendOp = glfunc;
+			STATE.blendOpAlpha = glfunca;
+		}
+		}
+		if( STATE.blending != 1 )
+		{
+			OGL_CALL(glEnable( GL_BLEND ));
+			STATE.blending = 1;
+		}
+	}
+
+	// alpha testing states
+#if UNITY_EDITOR // gles2.0 doesn't have FF alpha testing(only discard/clip on shader side), so disable on editor while emulating
+	bool skipAlphaTestFF = (gGraphicsCaps.IsEmulatingGLES20() && IsShaderActive(kShaderFragment));
+	// possible that vertex shader will be used with FF "frag shader" (like Transparent/vertexlit.shader),
+	// which will change alphatesting. So later on when real frag shaders come, we need to force disable alpha
+	// testing or enjoy nasty artefacts (like active alpha testing messing up the whole scene).
+	if ( skipAlphaTestFF && STATE.alphaFunc!=kFuncDisabled )
+	{
+		OGL_CALL(glDisable (GL_ALPHA_TEST));
+		STATE.alphaFunc = kFuncDisabled;
+	}
+
+	if ( !skipAlphaTestFF )
+	{
+#endif
+		if( mode != STATE.alphaFunc || alphaRef != STATE.alphaValue )
+		{
+			if( mode != kFuncDisabled )
+			{
+				OGL_CALL(glAlphaFunc( kCmpFuncGL[mode], alphaRef ));
+				OGL_CALL(glEnable( GL_ALPHA_TEST ));
+			}
+			else
+			{
+				OGL_CALL(glDisable (GL_ALPHA_TEST));
+			}
+
+			STATE.alphaFunc = mode;
+			STATE.alphaValue = alphaRef;
+		}
+#if UNITY_EDITOR
+	}
+#endif
+
+#if 0
+	int atomask = alphaToMask ? 1 : 0;
+	if( atomask != STATE.alphaToMask && gGraphicsCaps.hasMultiSample )
+	{
+		if( atomask )
+			OGL_CALL(glEnable( GL_SAMPLE_ALPHA_TO_COVERAGE ));
+		else
+			OGL_CALL(glDisable( GL_SAMPLE_ALPHA_TO_COVERAGE ));
+		STATE.alphaToMask = atomask;
+	}
+#endif
+}
+
+
+void GFX_GL_IMPL::SetRasterState(const DeviceRasterState* state)
+{
+	DeviceRasterState* devstate = (DeviceRasterState*)state;
+	if(!devstate)
+	{
+		STATE.m_CurrRasterState = NULL;
+		return;
+	}
+
+	STATE.m_CurrRasterState = devstate;
+
+	CullMode cull = devstate->sourceState.cullMode;
+	if( cull != STATE.culling )
+	{
+		switch (cull) {
+		case kCullOff:
+			OGL_CALL(glDisable (GL_CULL_FACE));
+			break;
+		case kCullFront:
+			OGL_CALL(glCullFace (GL_FRONT));
+			OGL_CALL(glEnable (GL_CULL_FACE));
+			break;
+		case kCullBack:
+			OGL_CALL(glCullFace (GL_BACK));
+			OGL_CALL(glEnable (GL_CULL_FACE));
+			break;
+		}
+		STATE.culling = cull;
+	}
+
+	float zFactor = devstate->sourceState.slopeScaledDepthBias;
+	float zUnits  = devstate->sourceState.depthBias;
+	if( zFactor != STATE.offsetFactor || zUnits != STATE.offsetUnits )
+	{
+		OGL_CALL(glPolygonOffset( zFactor, zUnits ));
+		if( zFactor || zUnits )
+			OGL_CALL(glEnable (GL_POLYGON_OFFSET_FILL));
+		else
+			OGL_CALL(glDisable (GL_POLYGON_OFFSET_FILL));
+
+		STATE.offsetFactor = zFactor;
+		STATE.offsetUnits = zUnits;
+	}
+}
+
+
+void GFX_GL_IMPL::SetDepthState(const DeviceDepthState* state)
+{
+	DeviceDepthStateGL* devstate = (DeviceDepthStateGL*)state;
+	if (STATE.m_CurrDepthState == devstate)
+		return;
+
+	STATE.m_CurrDepthState = devstate;
+
+	if (!STATE.m_CurrDepthState)
+		return;
+
+	const CompareFunction testFunc = devstate->sourceState.depthFunc;
+	if( testFunc != STATE.depthFunc )
+	{
+		if( testFunc != kFuncDisabled ) {
+			OGL_CALL(glDepthFunc (kCmpFuncGL[testFunc]));
+			OGL_CALL(glEnable (GL_DEPTH_TEST));
+		} else {
+			OGL_CALL(glDisable (GL_DEPTH_TEST));
+		}
+
+		STATE.depthFunc = testFunc;
+	}
+
+	const int writeMode = devstate->sourceState.depthWrite ? GL_TRUE : GL_FALSE;
+	if( writeMode != STATE.depthWrite )
+	{
+		OGL_CALL(glDepthMask (writeMode));
+		STATE.depthWrite = writeMode;
+	}
+}
+
+void GFX_GL_IMPL::SetStencilState (const DeviceStencilState* state, int stencilRef)
+{
+	if (STATE.m_CurrStencilState == state && STATE.m_StencilRef == stencilRef)
+		return;
+	const DeviceStencilStateGL* st = static_cast<const DeviceStencilStateGL*>(state);
+	STATE.m_CurrStencilState = st;
+	if (!st)
+		return;
+
+	if (st->sourceState.stencilEnable)
+		glEnable (GL_STENCIL_TEST);
+	else
+		glDisable (GL_STENCIL_TEST);
+	if (gGraphicsCaps.hasTwoSidedStencil)
+	{
+		glStencilFuncSeparate (GL_FRONT, st->stencilFuncFront, stencilRef, st->sourceState.readMask);
+		glStencilOpSeparate (GL_FRONT, st->stencilFailOpFront, st->depthFailOpFront, st->depthPassOpFront);
+		glStencilFuncSeparate (GL_BACK, st->stencilFuncBack, stencilRef, st->sourceState.readMask);
+		glStencilOpSeparate (GL_BACK, st->stencilFailOpBack, st->depthFailOpBack, st->depthPassOpBack);
+	}
+	else
+	{
+		glStencilFunc (st->stencilFuncFront, stencilRef, st->sourceState.readMask);
+		glStencilOp (st->stencilFailOpFront, st->depthFailOpFront, st->depthPassOpFront);
+	}
+	glStencilMask (st->sourceState.writeMask);
+
+	STATE.m_StencilRef = stencilRef;
+}
+
+
+void GFX_GL_IMPL::SetSRGBWrite (bool enable)
+{
+	if (!gGraphicsCaps.hasSRGBReadWrite)
+		return;
+
+	if (enable)
+		OGL_CALL(glEnable(GL_FRAMEBUFFER_SRGB_EXT));
+	else
+		OGL_CALL(glDisable(GL_FRAMEBUFFER_SRGB_EXT));
+}
+
+bool GFX_GL_IMPL::GetSRGBWrite ()
+{
+	return gGraphicsCaps.hasSRGBReadWrite ?
+		glIsEnabled(GL_FRAMEBUFFER_SRGB_EXT):
+		false;
+}
+
+void GFX_GL_IMPL::Clear (UInt32 clearFlags, const float color[4], float depth, int stencil)
+{
+	GFX_LOG(("%d, {%f, %f, %f, %f}, %f, %d", clearFlags, color[0], color[1], color[2], color[3], depth, stencil));
+
+	if (!IsActiveRenderTargetWithColorGL())
+		clearFlags &= ~kGfxClearColor;
+
+	// In OpenGL, clears are affected by color write mask and depth writing parameters.
+	// So make sure to set them!
+	GLbitfield flags = 0;
+	if (clearFlags & kGfxClearColor)
+	{
+		if (STATE.colorWriteMask != 15)
+		{
+			OGL_CALL(glColorMask( true, true, true, true ));
+			STATE.colorWriteMask = 15;
+			STATE.m_CurrBlendState = NULL;
+		}
+		flags |= GL_COLOR_BUFFER_BIT;
+		glClearColor (color[0], color[1], color[2], color[3]);
+	}
+	if (clearFlags & kGfxClearDepth)
+	{
+		OGL_CALL(glDepthMask (GL_TRUE));
+		STATE.depthWrite = GL_TRUE;
+		STATE.m_CurrDepthState = NULL;
+		flags |= GL_DEPTH_BUFFER_BIT;
+		glClearDepth (depth);
+	}
+	if (clearFlags & kGfxClearStencil)
+	{
+		//@TODO: need to set stencil writes on?
+		flags |= GL_STENCIL_BUFFER_BIT;
+		glClearStencil (stencil);
+	}
+	glClear (flags);
+}
+
+
+static void ApplyBackfaceMode( const DeviceStateGL& state )
+{
+	const bool bFlip = (state.appBackfaceMode != state.userBackfaceMode);
+
+	if( bFlip )
+		OGL_CALL(glFrontFace( GL_CCW ));
+	else
+		OGL_CALL(glFrontFace( GL_CW ));
+
+	if(state.culling == kCullUnknown || state.culling == kCullOff)
+		return;
+
+	DeviceRasterState* devstate = state.m_CurrRasterState;
+	if(!devstate)
+		return;
+
+	GfxDevice &device = GetRealGfxDevice();
+	device.SetRasterState(0);
+	device.SetRasterState(devstate);
+}
+
+
+void GFX_GL_IMPL::SetUserBackfaceMode( bool enable )
+{
+	GFX_LOG(("%d", enable));
+	if( STATE.userBackfaceMode == enable )
+		return;
+	STATE.userBackfaceMode = enable;
+	ApplyBackfaceMode( STATE );
+}
+
+
+void GFX_GL_IMPL::SetWireframe( bool wire )
+{
+	if( wire )
+	{
+		OGL_CALL(glEnable (GL_POLYGON_OFFSET_LINE));
+		OGL_CALL(glPolygonMode (GL_FRONT_AND_BACK, GL_LINE));
+		STATE.wireframe = true;
+	}
+	else
+	{
+		OGL_CALL(glDisable (GL_POLYGON_OFFSET_LINE));
+		OGL_CALL(glPolygonMode (GL_FRONT_AND_BACK, GL_FILL));
+		STATE.wireframe = false;
+	}
+}
+
+bool GFX_GL_IMPL::GetWireframe() const
+{
+	return STATE.wireframe;
+}
+
+
+
+void GFX_GL_IMPL::SetInvertProjectionMatrix (bool enable)
+{
+	Assert (!enable); // projection should never be flipped upside down on OpenGL
+}
+
+bool GFX_GL_IMPL::GetInvertProjectionMatrix() const
+{
+	return false;
+}
+
+#if GFX_USES_VIEWPORT_OFFSET
+void GFX_GL_IMPL::SetViewportOffset( float x, float y )
+{
+	GFX_LOG(("%f, %f", x, y));
+	STATE.viewportOffsetX = x;
+	STATE.viewportOffsetY = y;
+}
+
+void GFX_GL_IMPL::GetViewportOffset( float &x, float &y ) const
+{
+	x = STATE.viewportOffsetX;
+	y = STATE.viewportOffsetY;
+}
+#endif
+
+void GFX_GL_IMPL::SetProjectionMatrix (const Matrix4x4f& matrix)
+{
+	GFX_LOG(("{%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f}",
+		matrix[0],	matrix[1],	matrix[2],	matrix[3],
+		matrix[4],	matrix[5],	matrix[6],	matrix[7],
+		matrix[8],	matrix[9],	matrix[10],	matrix[11],
+		matrix[12],	matrix[13],	matrix[14],	matrix[15]));
+
+	Matrix4x4f& projMat = m_BuiltinParamValues.GetWritableMatrixParam(kShaderMatProj);
+	CopyMatrix (matrix.GetPtr(), projMat.GetPtr());
+	OGL_CALL(glMatrixMode( GL_PROJECTION ));
+	OGL_CALL(glLoadMatrixf (matrix.GetPtr()));
+	OGL_CALL(glMatrixMode( GL_MODELVIEW ));
+}
+
+void GFX_GL_IMPL::SetWorldMatrix( const float matrix[16] )
+{
+	GFX_LOG(("{%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f}",
+		matrix[0],	matrix[1],	matrix[2],	matrix[3],
+		matrix[4],	matrix[5],	matrix[6],	matrix[7],
+		matrix[8],	matrix[9],	matrix[10],	matrix[11],
+		matrix[12],	matrix[13],	matrix[14],	matrix[15]));
+
+	CopyMatrix(matrix, STATE.m_WorldMatrix.GetPtr());
+
+	OGL_CALL(glLoadMatrixf(m_BuiltinParamValues.GetMatrixParam(kShaderMatView).GetPtr()));
+	OGL_CALL(glMultMatrixf(matrix));
+}
+
+void GFX_GL_IMPL::SetViewMatrix( const float matrix[16] )
+{
+	glMatrixMode(GL_MODELVIEW);
+	glLoadMatrixf(matrix);
+
+	const Matrix4x4f& projMat = m_BuiltinParamValues.GetMatrixParam(kShaderMatProj);
+	Matrix4x4f& viewMat = m_BuiltinParamValues.GetWritableMatrixParam(kShaderMatView);
+	Matrix4x4f& viewProjMat = m_BuiltinParamValues.GetWritableMatrixParam(kShaderMatViewProj);
+	CopyMatrix (matrix, viewMat.GetPtr());
+	MultiplyMatrices4x4 (&projMat, &viewMat, &viewProjMat);
+	STATE.m_WorldMatrix.SetIdentity();
+}
+
+
+void GFX_GL_IMPL::GetMatrix( float outMatrix[16] ) const
+{
+	OGL_CALL(glGetFloatv( GL_MODELVIEW_MATRIX, outMatrix ));
+}
+
+
+const float* GFX_GL_IMPL::GetWorldMatrix() const
+{
+	return STATE.m_WorldMatrix.GetPtr();
+}
+
+const float* GFX_GL_IMPL::GetViewMatrix() const
+{
+	return m_BuiltinParamValues.GetMatrixParam(kShaderMatView).GetPtr();
+}
+
+const float* GFX_GL_IMPL::GetProjectionMatrix() const
+{
+	return m_BuiltinParamValues.GetMatrixParam(kShaderMatProj).GetPtr();
+}
+
+const float* GFX_GL_IMPL::GetDeviceProjectionMatrix() const
+{
+	return GetProjectionMatrix();
+}
+
+
+
+void GFX_GL_IMPL::SetNormalizationBackface( NormalizationMode mode, bool backface )
+{
+	GFX_LOG(("%d, %d", mode, backface));
+
+	if( mode != STATE.normalization )
+	{
+		if( mode == kNormalizationDisabled )
+		{
+			OGL_CALL(glDisable (GL_NORMALIZE));
+			OGL_CALL(glDisable (GL_RESCALE_NORMAL));
+		}
+		else if( mode == kNormalizationScale )
+		{
+			OGL_CALL(glDisable (GL_NORMALIZE));
+			OGL_CALL(glEnable (GL_RESCALE_NORMAL));
+		}
+		else
+		{
+			OGL_CALL(glEnable (GL_NORMALIZE));
+			OGL_CALL(glDisable (GL_RESCALE_NORMAL));
+		}
+
+		STATE.normalization = mode;
+	}
+	if( STATE.appBackfaceMode != backface )
+	{
+		STATE.appBackfaceMode = backface;
+		ApplyBackfaceMode( STATE );
+	}
+}
+
+void GFX_GL_IMPL::SetFFLighting( bool on, bool separateSpecular, ColorMaterialMode colorMaterial )
+{
+	GFX_LOG(("%d, %d, %d", on, separateSpecular, colorMaterial));
+
+	int lighting = on ? 1 : 0;
+	if( lighting != STATE.lighting )
+	{
+		if( lighting )
+			OGL_CALL(glEnable( GL_LIGHTING ));
+		else
+			OGL_CALL(glDisable( GL_LIGHTING ));
+		STATE.lighting = lighting;
+	}
+
+	int sepSpec = separateSpecular ? 1 : 0;
+
+	if (STATE.separateSpecular != sepSpec)
+	{
+		// Never set separate specular and color sum to different values.
+		// Otherwise SIS 76x on OpenGL will hang up the machine.
+		// And we probably never need them to be different anyway :)
+		if( separateSpecular )
+		{
+			OGL_CALL(glLightModeli( GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR ));
+			OGL_CALL(glEnable( GL_COLOR_SUM_EXT ));
+		}
+		else
+		{
+			OGL_CALL(glLightModeli( GL_LIGHT_MODEL_COLOR_CONTROL, GL_SINGLE_COLOR ));
+			OGL_CALL(glDisable( GL_COLOR_SUM_EXT ));
+		}
+		STATE.separateSpecular = sepSpec;
+	}
+
+	if( colorMaterial != STATE.colorMaterial )
+	{
+		if( colorMaterial != kColorMatDisabled )
+		{
+			OGL_CALL(glColorMaterial( GL_FRONT_AND_BACK, kColorMatModeGL[colorMaterial] ));
+			OGL_CALL(glEnable( GL_COLOR_MATERIAL ));
+		}
+		else
+		{
+			OGL_CALL(glDisable( GL_COLOR_MATERIAL ));
+
+			// looks like by disabling ColorMaterial OpenGL driver will reset material props
+			// therefore we invalidate materials cache
+			STATE.matAmbient.Set(-1, -1, -1, -1);
+			STATE.matDiffuse.Set(-1, -1, -1, -1);
+			STATE.matSpecular.Set(-1, -1, -1, -1);
+			STATE.matEmissive.Set(-1, -1, -1, -1);
+		}
+
+		STATE.colorMaterial = colorMaterial;
+	}
+}
+
+void GFX_GL_IMPL::SetMaterial( const float ambient[4], const float diffuse[4], const float specular[4], const float emissive[4], const float shininess )
+{
+	GFX_LOG(("{%f, %f, %f, %f}, {%f, %f, %f, %f}, {%f, %f, %f, %f}, {%f, %f, %f, %f}, %f",
+		ambient[0],	ambient[1],	ambient[2],	ambient[3],
+		diffuse[0],	diffuse[1],	diffuse[2],	diffuse[3],
+		specular[0],	specular[1],	specular[2],	specular[3],
+		emissive[0],	emissive[1],	emissive[2],	emissive[3],
+		shininess));
+	if (STATE.matAmbient != ambient) {
+		OGL_CALL(glMaterialfv (GL_FRONT, GL_AMBIENT, ambient));
+		STATE.matAmbient.Set (ambient);
+	}
+
+	if (STATE.matDiffuse != diffuse) {
+		OGL_CALL(glMaterialfv (GL_FRONT, GL_DIFFUSE, diffuse));
+		STATE.matDiffuse.Set (diffuse);
+	}
+
+	if (STATE.matSpecular != specular) {
+		OGL_CALL(glMaterialfv (GL_FRONT, GL_SPECULAR, specular));
+		STATE.matSpecular.Set (specular);
+	}
+
+	if (STATE.matEmissive != emissive) {
+		OGL_CALL(glMaterialfv (GL_FRONT, GL_EMISSION, emissive));
+		STATE.matEmissive.Set (emissive);
+	}
+
+	if( STATE.matShininess != shininess ) {
+		float glshine = std::max<float>( std::min<float>(shininess,1.0f), 0.0f) * 128.0f;
+		OGL_CALL(glMaterialf (GL_FRONT, GL_SHININESS, glshine));
+		STATE.matShininess = shininess;
+	}
+
+	// From shaderstate, the material is set after the ColorMaterial.
+	// So here if color material is used, setup invalid values to material
+	// cache; otherwise they would get out of sync.
+
+	switch( STATE.colorMaterial ) {
+	case kColorMatEmission: STATE.matEmissive.Set(-1, -1, -1, -1); break;
+	case kColorMatAmbientAndDiffuse:
+		STATE.matAmbient.Set(-1, -1, -1, -1);
+		STATE.matDiffuse.Set(-1, -1, -1, -1);
+		break;
+	}
+}
+
+
+void GFX_GL_IMPL::SetColor( const float color[4] )
+{
+	GFX_LOG(("{%f, %f, %f, %f}", color[0], color[1], color[2], color[3]));
+	OGL_CALL(glColor4fv( color ));
+}
+
+
+void GFX_GL_IMPL::SetViewport( int x, int y, int width, int height )
+{
+	GFX_LOG(("{%d, %d, %d, %d}", x, y, width, height));
+	STATE.viewport[0] = x;
+	STATE.viewport[1] = y;
+	STATE.viewport[2] = width;
+	STATE.viewport[3] = height;
+	OGL_CALL(glViewport( x, y, width, height ));
+}
+
+void GFX_GL_IMPL::GetViewport( int* port ) const
+{
+	port[0] = STATE.viewport[0];
+	port[1] = STATE.viewport[1];
+	port[2] = STATE.viewport[2];
+	port[3] = STATE.viewport[3];
+}
+
+void GFX_GL_IMPL::SetScissorRect( int x, int y, int width, int height )
+{
+	GFX_LOG(("{%d, %d, %d, %d}", x, y, width, height));
+	if (STATE.scissor != 1)
+	{
+		OGL_CALL(glEnable( GL_SCISSOR_TEST ));
+		STATE.scissor = 1;
+	}
+
+	STATE.scissorRect[0] = x;
+	STATE.scissorRect[1] = y;
+	STATE.scissorRect[2] = width;
+	STATE.scissorRect[3] = height;
+	OGL_CALL(glScissor( x, y, width, height ));
+
+}
+
+void GFX_GL_IMPL::DisableScissor()
+{
+	GFX_LOG((""));
+	if (STATE.scissor != 0)
+	{
+		OGL_CALL(glDisable( GL_SCISSOR_TEST ));
+		STATE.scissor = 0;
+	}
+}
+
+bool GFX_GL_IMPL::IsScissorEnabled() const
+{
+	return STATE.scissor == 1;
+}
+
+void GFX_GL_IMPL::GetScissorRect( int scissor[4] ) const
+{
+	scissor[0] = STATE.scissorRect[0];
+	scissor[1] = STATE.scissorRect[1];
+	scissor[2] = STATE.scissorRect[2];
+	scissor[3] = STATE.scissorRect[3];
+}
+
+bool GFX_GL_IMPL::IsCombineModeSupported( unsigned int combiner )
+{
+	return TextureCombinersGL::IsCombineModeSupported( combiner );
+}
+
+TextureCombinersHandle GFX_GL_IMPL::CreateTextureCombiners( int count, const ShaderLab::TextureBinding* texEnvs, const ShaderLab::PropertySheet* props, bool hasVertexColorOrLighting, bool usesAddSpecular )
+{
+	GFX_LOG(("%d, %d, %d", count, hasVertexColorOrLighting, usesAddSpecular));
+	TextureCombinersGL* implGL = TextureCombinersGL::Create( count, texEnvs, props );
+	return TextureCombinersHandle( implGL );
+}
+
+void GFX_GL_IMPL::DeleteTextureCombiners( TextureCombinersHandle& textureCombiners )
+{
+	GFX_LOG((""));
+	TextureCombinersGL* implGL = OBJECT_FROM_HANDLE(textureCombiners,TextureCombinersGL);
+	delete implGL;
+	textureCombiners.Reset();
+}
+
+static void ClearTextureUnitGL (DeviceStateGL& state, int unit)
+{
+	GFX_LOG(("%d", unit));
+	DebugAssert (unit >= 0 && unit < gGraphicsCaps.maxTexUnits);
+	
+	TextureUnitStateGL& currTex = state.textures[unit];
+	if (currTex.texDim == kTexDimNone)
+		return;
+
+	if (state.shaderEnabledImpl[kShaderFragment] == kShaderImplUndefined)
+	{
+		ActivateTextureUnitGL (unit);
+
+		if( currTex.texDim != kTexDimUnknown )
+		{
+			OGL_CALL(glDisable( kTexDimTableGL[currTex.texDim] ));
+		}
+		else
+		{
+			OGL_CALL(glDisable( GL_TEXTURE_2D ));
+			OGL_CALL(glDisable( GL_TEXTURE_1D ));
+			OGL_CALL(glDisable( GL_TEXTURE_CUBE_MAP_ARB ));
+			if( gGraphicsCaps.has3DTexture )
+				OGL_CALL(glDisable( GL_TEXTURE_3D ));
+		}
+		currTex.texDim = kTexDimNone;
+	}
+	else
+	{
+		currTex.texDim = kTexDimUnknown;
+	}
+}
+
+
+void GFX_GL_IMPL::SetTextureCombinersThreadable( TextureCombinersHandle textureCombiners, const TexEnvData* texEnvData, const Vector4f* texColors )
+{
+	TextureCombinersGL* implGL = OBJECT_FROM_HANDLE(textureCombiners,TextureCombinersGL);
+	AssertIf( !implGL );
+	AssertIf (IsShaderActive( kShaderFragment ));
+
+	int i = 0;
+	for( ; i < gGraphicsCaps.maxTexUnits && i < implGL->count; ++i )
+	{
+		const ShaderLab::TextureBinding& binding = implGL->texEnvs[i];
+
+		// set the texture
+		ApplyTexEnvData (i, i, texEnvData[i]);
+		// apply the combiner
+		Vector4f texcolorVal = texColors[i];
+		TextureUnitStateGL& unitState = STATE.textures[i];
+
+		// TODO: on Joe's machine this is sometimes failing (FPS tutorial, rotate scene view).
+		// So we just don't check, which disables the cache.
+		//if (current.texColor != texcolorVal) {
+		unitState.color = texcolorVal;
+		OGL_CALL(glTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, texcolorVal.GetPtr() ));
+		//}
+
+		// setup combine modes
+		ApplyCombinerGL( unitState.combColor, unitState.combAlpha, binding.m_CombColor, binding.m_CombAlpha );
+	}
+
+	// clear unused textures
+	for (; i < gGraphicsCaps.maxTexUnits; ++i)
+		ClearTextureUnitGL (STATE, i);
+
+	// Get us back to TU 0, so we know where we stand
+	ActivateTextureUnitGL (0);
+}
+
+void GFX_GL_IMPL::SetTextureCombiners( TextureCombinersHandle textureCombiners, const ShaderLab::PropertySheet* props )
+{
+	TextureCombinersGL* implGL = OBJECT_FROM_HANDLE(textureCombiners,TextureCombinersGL);
+	AssertIf( !implGL );
+
+	int count = std::min(implGL->count, gGraphicsCaps.maxTexUnits);
+
+	// Fill in arrays
+	TexEnvData* texEnvData;
+	ALLOC_TEMP (texEnvData, TexEnvData, count);
+	for( int i = 0; i < count; ++i )
+	{
+		ShaderLab::TexEnv *te = ShaderLab::GetTexEnvForBinding( implGL->texEnvs[i], props );
+		Assert( te != NULL );
+		te->PrepareData (implGL->texEnvs[i].m_TextureName.index, implGL->texEnvs[i].m_MatrixName, props, &texEnvData[i]);
+	}
+
+	Vector4f* texColors;
+	ALLOC_TEMP (texColors, Vector4f, count);
+	for( int i = 0; i < count; ++i )
+	{
+		const ShaderLab::TextureBinding& binding = implGL->texEnvs[i];
+		texColors[i] = binding.GetTexColor().Get (props);
+	}
+	GFX_GL_IMPL::SetTextureCombinersThreadable(textureCombiners, texEnvData, texColors);
+}
+
+const unsigned long* GetGLTextureDimensionTable() { return kTexDimTableGL; }
+
+void GFX_GL_IMPL::SetTexture (ShaderType shaderType, int unit, int samplerUnit, TextureID texture, TextureDimension dim, float bias)
+{
+	GFX_LOG(("%d, %d, %d", unit, texture.m_ID, dim));
+	DebugAssertIf( dim < kTexDim2D || dim > kTexDimCUBE );
+
+	GLuint targetTex = (GLuint)TextureIdMap::QueryNativeTexture(texture);
+	if(targetTex == 0)
+		return;
+
+	TextureUnitStateGL& currTex = STATE.textures[unit];
+
+	DebugAssertIf( unit < 0 || unit >= gGraphicsCaps.maxTexImageUnits );
+	ActivateTextureUnitGL (unit);
+
+	int dimGLTarget = kTexDimTableGL[dim];
+
+
+	if (!IsShaderActive(kShaderFragment))
+	{
+		switch( currTex.texDim ) {
+		case kTexDimUnknown:
+			// We don't know which target is enabled, so disable all but the one we
+			// want to set, and enable only that one
+			if( dim != kTexDimDeprecated1D ) OGL_CALL(glDisable( GL_TEXTURE_1D ));
+			if( dim != kTexDim2D ) OGL_CALL(glDisable( GL_TEXTURE_2D ));
+			if( dim != kTexDimCUBE ) OGL_CALL(glDisable( GL_TEXTURE_CUBE_MAP_ARB ));
+			if( dim != kTexDim3D && gGraphicsCaps.has3DTexture ) OGL_CALL(glDisable( GL_TEXTURE_3D ));
+			OGL_CALL(glEnable( dimGLTarget ));
+			break;
+		case kTexDimNone:
+			// Texture unit was disabled. So simply enable our target.
+			OGL_CALL(glEnable( dimGLTarget ));
+			break;
+		default:
+			// Disable current and enable ours if they're different.
+			if( currTex.texDim != dim ) {
+				OGL_CALL(glDisable( kTexDimTableGL[currTex.texDim] ));
+				OGL_CALL(glEnable( dimGLTarget ));
+			}
+			break;
+		}
+		currTex.texDim = dim;
+	}
+	else
+	{
+		currTex.texDim = kTexDimUnknown;
+	}
+
+	if( targetTex != currTex.texID )
+	{
+		OGL_CALL(glBindTexture(dimGLTarget, targetTex));
+		currTex.texID = targetTex;
+	}
+	m_Stats.AddUsedTexture(texture);
+	if (gGraphicsCaps.hasMipLevelBias && bias != currTex.bias && bias != std::numeric_limits<float>::infinity())
+	{
+		OGL_CALL(glTexEnvf( GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, bias ));
+		currTex.bias = bias;
+	}
+}
+
+
+void GFX_GL_IMPL::SetTextureTransform( int unit, TextureDimension dim, TexGenMode texGen, bool identity, const float matrix[16])
+{
+	GFX_LOG(("%d, %d, %d, %d, {%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f}",
+		unit, dim, texGen, identity,
+		matrix[0],	matrix[1],	matrix[2],	matrix[3],
+		matrix[4],	matrix[5],	matrix[6],	matrix[7],
+		matrix[8],	matrix[9],	matrix[10],	matrix[11],
+		matrix[12],	matrix[13],	matrix[14],	matrix[15]
+		));
+
+	Assert (unit >= 0 && unit < kMaxSupportedTextureCoords);
+
+	// This assumes the current texture unit is already set!!!
+	TextureUnitStateGL& unitState = STATE.textures[unit];
+
+	// -------- texture matrix
+
+	if (unit < gGraphicsCaps.maxTexUnits)
+	{
+		OGL_CALL(glMatrixMode( GL_TEXTURE ));
+		OGL_CALL(glLoadMatrixf( matrix ));
+		OGL_CALL(glMatrixMode( GL_MODELVIEW ));
+	}
+
+	// -------- texture coordinate generation
+
+	if( IsShaderActive(kShaderVertex) )
+	{
+		// Ok, in theory we could just return here, as texgen is completely ignored
+		// with vertex shaders. However, on Mac OS X 10.4.10, Radeon X1600 and GeForce 8600M,
+		// there seems to be a bug. Repro case: shader that uses a single cubemap texture and
+		// CubeReflect texgen, and use glow on the camera = glow is wrong.
+		//
+		// On Windows / GeForce 7600 on OpenGL (93.71) the behaviour is correct. But I feel safer
+		// just using the workaround everywhere...
+		//
+		// So: with vertex shaders, force texgen to be disabled. The redundant change check below
+		// will catch most of the cases cheaply anyway.
+		texGen = kTexGenDisabled;
+	}
+
+	if( texGen == unitState.texGen )
+		return;
+
+	switch( texGen )
+	{
+	case kTexGenDisabled:
+		OGL_CALL(glDisable (GL_TEXTURE_GEN_S));
+		OGL_CALL(glDisable (GL_TEXTURE_GEN_T));
+		OGL_CALL(glDisable (GL_TEXTURE_GEN_R));
+		break;
+	case kTexGenSphereMap:
+		OGL_CALL(glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP));
+		OGL_CALL(glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP));
+		OGL_CALL(glEnable(GL_TEXTURE_GEN_S));
+		OGL_CALL(glEnable(GL_TEXTURE_GEN_T));
+		OGL_CALL(glDisable(GL_TEXTURE_GEN_R));
+		break;
+	case kTexGenObject: {
+		float zplane[4] = {0,0,1,0};
+		OGL_CALL(glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR));
+		OGL_CALL(glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR));
+		OGL_CALL(glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR));
+		OGL_CALL(glTexGenfv (GL_R, GL_OBJECT_PLANE, zplane));
+		OGL_CALL(glEnable(GL_TEXTURE_GEN_S));
+		OGL_CALL(glEnable(GL_TEXTURE_GEN_T));
+		OGL_CALL(glEnable(GL_TEXTURE_GEN_R));
+		break;
+		}
+	case kTexGenEyeLinear: {
+		OGL_CALL(glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR));
+		OGL_CALL(glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR));
+		OGL_CALL(glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR));
+		OGL_CALL(glEnable(GL_TEXTURE_GEN_S));
+		OGL_CALL(glEnable(GL_TEXTURE_GEN_T));
+		OGL_CALL(glEnable(GL_TEXTURE_GEN_R));
+		break;
+		}
+	case kTexGenCubeReflect:
+		OGL_CALL(glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB));
+		OGL_CALL(glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB));
+		OGL_CALL(glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB));
+		OGL_CALL(glEnable(GL_TEXTURE_GEN_S));
+		OGL_CALL(glEnable(GL_TEXTURE_GEN_T));
+		OGL_CALL(glEnable(GL_TEXTURE_GEN_R));
+		break;
+	case kTexGenCubeNormal:
+		OGL_CALL(glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_ARB));
+		OGL_CALL(glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_ARB));
+		OGL_CALL(glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_ARB));
+		OGL_CALL(glEnable(GL_TEXTURE_GEN_S));
+		OGL_CALL(glEnable(GL_TEXTURE_GEN_T));
+		OGL_CALL(glEnable(GL_TEXTURE_GEN_R));
+		break;
+	}
+
+	unitState.texGen = texGen;
+}
+
+void GFX_GL_IMPL::SetTextureParams( TextureID texture, TextureDimension texDim, TextureFilterMode filter, TextureWrapMode wrap, int anisoLevel, bool hasMipMap, TextureColorSpace colorSpace )
+{
+	GFX_LOG(("%d, %d, %d, %d, %d, %d, %d", texture.m_ID, texDim, filter, wrap, anisoLevel, hasMipMap, colorSpace));
+
+	TextureIdMapGL_QueryOrCreate(texture);
+
+	GLuint target = GetGLTextureDimensionTable()[texDim];
+	SetTexture (kShaderFragment, 0, 0, texture, texDim, std::numeric_limits<float>::infinity());
+
+	// Anisotropic texturing...
+	if( gGraphicsCaps.hasAnisoFilter && target != GL_TEXTURE_3D )
+	{
+		anisoLevel = std::min( anisoLevel, gGraphicsCaps.maxAnisoLevel );
+		OGL_CALL(glTexParameteri( target, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisoLevel ));
+	}
+
+	OGL_CALL(glTexParameteri( target, GL_TEXTURE_WRAP_S, kWrapModeGL[wrap] ));
+	OGL_CALL(glTexParameteri( target, GL_TEXTURE_WRAP_T, kWrapModeGL[wrap] ));
+	if( target == GL_TEXTURE_3D || target == GL_TEXTURE_CUBE_MAP_ARB )
+		OGL_CALL(glTexParameteri( target, GL_TEXTURE_WRAP_R, kWrapModeGL[wrap] ));
+
+	if( !hasMipMap && filter == kTexFilterTrilinear )
+		filter = kTexFilterBilinear;
+
+	OGL_CALL(glTexParameteri( target, GL_TEXTURE_MAG_FILTER, filter != kTexFilterNearest ? GL_LINEAR : GL_NEAREST ));
+	if( hasMipMap )
+		OGL_CALL(glTexParameteri( target, GL_TEXTURE_MIN_FILTER, kMinFilterGL[filter] ));
+	else
+		OGL_CALL(glTexParameteri (target, GL_TEXTURE_MIN_FILTER, filter != kTexFilterNearest ? GL_LINEAR : GL_NEAREST));
+}
+
+
+
+
+// Dark corner of OpenGL:
+//  (this is at least on OS X 10.4.9, MacBook Pro)
+// Before switching to new context, unbind any textures/shaders/whatever in the previous one!
+//
+// Otherwise is some _rare_ cases the textures will leak VRAM. Cases like this:
+// 1) create a depth render texture (this creates actual GL texture; as copy is required)
+// 2) create another render texture, render into it using the depth texture
+// 3) release both depth RT and this other RT
+// 4) the memory used by GL texture from step 1 is leaked!
+//
+// It seems like OS X is refcounting resources between contexts, yet when
+// a context is destroyed the refcounts are not released. Or something like that.
+//
+// The texture leak also happens if shader programs are not unbound (hard to correlate why, but...)!
+void GFX_GL_IMPL::UnbindObjects()
+{
+	GFX_GL_IMPL& device = static_cast<GFX_GL_IMPL&>(GetRealGfxDevice());
+
+	// unbind textures
+	int texUnits = gGraphicsCaps.maxTexUnits;
+	for( int i = 0; i < texUnits; ++i )
+		ClearTextureUnitGL (GetGLDeviceState(device), i);
+	// unbind shaders
+	ShaderLab::SubProgram* programs[kShaderTypeCount] = {0};
+	GraphicsHelper::SetShaders (*this, programs, NULL);
+	// unbind VBOs
+	UnbindVertexBuffersGL();
+}
+
+
+
+unsigned int GetGLShaderImplTarget( ShaderImplType implType )
+{
+	switch( implType )
+	{
+	case kShaderImplVertex: return GL_VERTEX_PROGRAM_ARB;
+	case kShaderImplFragment: return GL_FRAGMENT_PROGRAM_ARB;
+	}
+	DebugAssertIf( true );
+	return 0;
+}
+
+void InvalidateActiveShaderStateGL( ShaderType type )
+{
+	GfxDevice& device = GetRealGfxDevice();
+	AssertIf( device.GetRenderer() != kGfxRendererOpenGL );
+	GFX_GL_IMPL& deviceGL = static_cast<GFX_GL_IMPL&>( device );
+
+	DeviceStateGL& state = GetGLDeviceState(deviceGL);
+	state.activeGpuProgram[type] = NULL;
+	state.activeGpuProgramParams[type] = NULL;
+	state.shaderEnabledImpl[type] = kShaderImplUndefined;
+	state.shaderEnabledID[type] = -1;
+}
+
+
+static void InternalSetShader( DeviceStateGL& state, GfxDeviceStats& stats, FogMode fog, ShaderType type, GpuProgram* program, const GpuProgramParameters* params )
+{
+	if( program )
+	{
+		GpuProgramGL& shaderGL = static_cast<GpuProgramGL&>(*program);
+		ShaderImplType implType = shaderGL.GetImplType();
+		GLShaderID id = 0;
+		if (implType == kShaderImplBoth) {
+			id = static_cast<GlslGpuProgram&>(shaderGL).GetGLProgram(fog, const_cast<GpuProgramParameters&>(*params));
+		} else {
+			id = static_cast<ArbGpuProgram&>(shaderGL).GetGLProgram(fog);
+		}
+		// set the shader
+		DebugAssert (id > 0);
+
+		ShaderImplType oldType = state.shaderEnabledImpl[type];
+		if( oldType != implType )
+		{
+			// impl type is different, disable old one and enable new one
+			if( oldType == kShaderImplBoth )
+				OGL_CALL(glUseProgramObjectARB( 0 ));
+			else if( oldType != kShaderImplUndefined )
+				OGL_CALL(glDisable( GetGLShaderImplTarget(oldType) ));
+			else {
+				// we don't know which one is currently enabled, so disable everything we have!
+				if (type == kShaderVertex)
+					OGL_CALL(glDisable(GL_VERTEX_PROGRAM_ARB));
+				if (type == kShaderFragment)
+					OGL_CALL(glDisable(GL_FRAGMENT_PROGRAM_ARB));
+			}
+
+			if( implType == kShaderImplBoth )
+			{
+				Assert (type == kShaderVertex);
+				OGL_CALL(glUseProgramObjectARB( id ));
+			}
+			else
+			{
+				GLenum gltarget = GetGLShaderImplTarget( implType );
+				OGL_CALL(glEnable( gltarget ));
+				OGL_CALL(glBindProgramARB( gltarget, id ));
+			}
+
+			state.shaderEnabledImpl[type] = implType;
+			state.shaderEnabledID[type] = id;
+		}
+		else
+		{
+			// impl type is the same, just use new shader (if different)
+
+			if( state.shaderEnabledID[type] != id )
+			{
+				if( implType == kShaderImplBoth )
+				{
+					OGL_CALL(glUseProgramObjectARB( id ));
+				}
+				else
+				{
+					OGL_CALL(glBindProgramARB( GetGLShaderImplTarget(implType), id ));
+				}
+				state.shaderEnabledID[type] = id;
+			}
+		}
+	}
+	else
+	{
+		// clear the shader
+		if( state.shaderEnabledID[type] == 0 )
+		{
+			// shader disabled, do nothing
+			DebugAssertIf( state.shaderEnabledImpl[type] != kShaderImplUndefined );
+		}
+		else if( state.shaderEnabledID[type] == -1 )
+		{
+			// shader state unknown, disable everything
+			DebugAssertIf( state.shaderEnabledImpl[type] != kShaderImplUndefined );
+			if( gGraphicsCaps.gl.hasGLSL )
+				OGL_CALL(glUseProgramObjectARB( 0 ));
+			if( type == kShaderVertex )
+			{
+				OGL_CALL(glDisable( GL_VERTEX_PROGRAM_ARB ));
+			}
+			else if( type == kShaderFragment )
+			{
+				OGL_CALL(glDisable( GL_FRAGMENT_PROGRAM_ARB ));
+			}
+			else
+			{
+				AssertIf( true );
+			}
+			state.shaderEnabledID[type] = 0;
+		}
+		else
+		{
+			// some shader enabled, disable just that one
+			ShaderImplType oldType = state.shaderEnabledImpl[type];
+			DebugAssertIf( oldType == kShaderImplUndefined );
+			if( oldType == kShaderImplBoth )
+			{
+				OGL_CALL(glUseProgramObjectARB( 0 ));
+			}
+			else
+				OGL_CALL(glDisable( GetGLShaderImplTarget(oldType) ));
+			state.shaderEnabledImpl[type] = kShaderImplUndefined;
+			state.shaderEnabledID[type] = 0;
+		}
+	}
+
+	// Note: set activeGpuProgram after doing everything above. Above code might be
+	// creating shader combinations for Fog on demand, which can reset activeGpuProgram to NULL.
+	state.activeGpuProgram[type] = program;
+	state.activeGpuProgramParams[type] = params;
+}
+
+void GFX_GL_IMPL::SetShadersThreadable(GpuProgram* programs[kShaderTypeCount], const GpuProgramParameters* params[kShaderTypeCount], UInt8 const * const paramsBuffer[kShaderTypeCount])
+{
+	GpuProgram* vertexProgram = programs[kShaderVertex];
+	GpuProgram* fragmentProgram = programs[kShaderFragment];
+
+	GFX_LOG(("%d, %d",
+			 (vertexProgram? vertexProgram->GetImplType() : kShaderImplUndefined),
+			 (fragmentProgram? fragmentProgram->GetImplType() : kShaderImplUndefined)));
+
+	// GLSL is only supported like this:
+	// vertex shader actually is both vertex & fragment linked program
+	// fragment shader is unused
+
+	FogMode fogMode = m_FogParams.mode;
+	if (vertexProgram && vertexProgram->GetImplType() == kShaderImplBoth)
+	{
+		Assert (fragmentProgram == 0 || fragmentProgram->GetImplType() == kShaderImplBoth);
+
+		InternalSetShader( STATE, m_Stats, m_FogParams.mode, kShaderVertex, vertexProgram, params[kShaderVertex] );
+	}
+	else
+	{
+		Assert ((fragmentProgram ? fragmentProgram->GetImplType() != kShaderImplBoth : true));
+
+		InternalSetShader( STATE, m_Stats, fogMode, kShaderVertex, vertexProgram, params[kShaderVertex] );
+		InternalSetShader( STATE, m_Stats, fogMode, kShaderFragment, fragmentProgram, params[kShaderFragment] );
+	}
+
+	for (int pt = 0; pt < kShaderTypeCount; ++pt)
+	{
+		if (programs[pt])
+		{
+			programs[pt]->ApplyGpuProgram (*params[pt], paramsBuffer[pt]);
+			m_BuiltinParamIndices[pt] = &params[pt]->GetBuiltinParams();
+		}
+		else
+		{
+			m_BuiltinParamIndices[pt] = &m_NullParamIndices;
+		}
+	}
+}
+
+
+void GFX_GL_IMPL::CreateShaderParameters( ShaderLab::SubProgram* program, FogMode fogMode )
+{
+	GpuProgramGL& shaderGL = static_cast<GpuProgramGL&>(program->GetGpuProgram());
+	ShaderImplType implType = shaderGL.GetImplType();
+	if (implType == kShaderImplBoth) {
+		static_cast<GlslGpuProgram&>(shaderGL).GetGLProgram(fogMode, program->GetParams(fogMode));
+	} else {
+		static_cast<ArbGpuProgram&>(shaderGL).GetGLProgram(fogMode);
+	}
+}
+
+bool GFX_GL_IMPL::IsShaderActive( ShaderType type ) const
+{
+	return STATE.shaderEnabledImpl[type] != kShaderImplUndefined;
+}
+
+void GFX_GL_IMPL::DestroySubProgram( ShaderLab::SubProgram* subprogram )
+{
+	GpuProgram& program = subprogram->GetGpuProgram();
+	GpuProgramGL& shaderGL = static_cast<GpuProgramGL&>(program);
+	ShaderType lastType = kShaderFragment;
+	if (shaderGL.GetImplType() == kShaderImplBoth)
+		lastType = kShaderVertex;
+
+	for (int i = 0; i < kFogModeCount; ++i)
+	{
+		GLShaderID id = shaderGL.GetGLProgramIfCreated(FogMode(i));
+		for (int j = kShaderVertex; j <= lastType; ++j)
+		{
+			if (id && STATE.shaderEnabledID[j] == id)
+			{
+				STATE.activeGpuProgram[j] = NULL;
+				STATE.activeGpuProgramParams[j] = NULL;
+				STATE.shaderEnabledID[j] = -1;
+				STATE.shaderEnabledImpl[j] = kShaderImplUndefined;
+			}
+		}
+	}
+	delete subprogram;
+}
+
+void GFX_GL_IMPL::DisableLights( int startLight )
+{
+	GFX_LOG(("%d", startLight));
+
+	DebugAssertIf( startLight < 0 || startLight > kMaxSupportedVertexLights );
+	const Vector4f black(0.0F, 0.0F, 0.0F, 0.0F);
+
+	const int maxLights = gGraphicsCaps.maxLights;
+	for (int i = startLight; i < maxLights; ++i)
+	{
+		if( STATE.vertexLights[i].enabled != 0 )
+		{
+			OGL_CALL(glLightfv (GL_LIGHT0 + i, GL_DIFFUSE, black.GetPtr()));
+			OGL_CALL(glDisable( GL_LIGHT0 + i ));
+
+			STATE.vertexLights[i].enabled = 0;
+		}
+	}
+
+	for (int i = startLight; i < gGraphicsCaps.maxLights; ++i)
+	{
+		m_BuiltinParamValues.SetVectorParam(BuiltinShaderVectorParam(kShaderVecLight0Diffuse + i), black);
+	}
+}
+
+void GFX_GL_IMPL::SetLight( int light, const GfxVertexLight& data)
+{
+	GFX_LOG(("%d, [{%f, %f, %f, %f}, {%f, %f, %f, %f}, {%f, %f, %f, %f}, %f, %f, %f, %d]",
+		light,
+		data.position.x, data.position.y, data.position.z, data.position.w,
+		data.spotDirection.x, data.spotDirection.y, data.spotDirection.z, data.spotDirection.w,
+		data.color.x, data.color.y, data.color.z, data.color.w,
+		data.range, data.quadAtten, data.spotAngle, data.type));
+
+	DebugAssert(light >= 0 && light < kMaxSupportedVertexLights);
+
+	VertexLightStateGL& state = STATE.vertexLights[light];
+
+	if (state.enabled != 1)
+	{
+		OGL_CALL(glEnable( GL_LIGHT0 + light ));
+		state.enabled = 1;
+	}
+
+	float dir[4];
+
+	// position
+	if( data.position.w == 0.0f )
+	{
+		// negate directional light for OpenGL
+		dir[0] = -data.position.x;
+		dir[1] = -data.position.y;
+		dir[2] = -data.position.z;
+		dir[3] = 0.0f;
+		OGL_CALL(glLightfv( GL_LIGHT0 + light, GL_POSITION, dir ));
+	}
+	else
+	{
+		OGL_CALL(glLightfv( GL_LIGHT0 + light, GL_POSITION, data.position.GetPtr() ));
+	}
+
+	// spot direction
+	if( data.spotAngle != -1.0f )
+		OGL_CALL(glLightfv( GL_LIGHT0 + light, GL_SPOT_DIRECTION, data.spotDirection.GetPtr() ));
+
+	// colors
+	OGL_CALL(glLightfv( GL_LIGHT0 + light, GL_DIFFUSE, data.color.GetPtr() ));
+	OGL_CALL(glLightfv( GL_LIGHT0 + light, GL_SPECULAR, data.color.GetPtr() ));
+	static float zeroColor[4] = { 0, 0, 0, 0 };
+	OGL_CALL(glLightfv( GL_LIGHT0 + light, GL_AMBIENT, zeroColor ));
+
+	// attenuation
+	if( state.attenQuad != data.quadAtten ) {
+		OGL_CALL(glLightf( GL_LIGHT0 + light, GL_CONSTANT_ATTENUATION, 1.0f ));
+		OGL_CALL(glLightf( GL_LIGHT0 + light, GL_QUADRATIC_ATTENUATION, data.quadAtten ));
+		state.attenQuad = data.quadAtten;
+	}
+
+	// angles
+	if( state.spotAngle != data.spotAngle )
+	{
+		if( data.spotAngle == -1.0f )
+		{
+			// non-spot light
+			OGL_CALL(glLightf( GL_LIGHT0 + light, GL_SPOT_CUTOFF, 180.0f ));
+		}
+		else
+		{
+			// spot light
+			OGL_CALL(glLightf( GL_LIGHT0 + light, GL_SPOT_CUTOFF, data.spotAngle * 0.5f ));
+			OGL_CALL(glLightf( GL_LIGHT0 + light, GL_SPOT_EXPONENT, 18.0f - data.spotAngle * 0.1f ));
+		}
+		state.spotAngle = data.spotAngle;
+	}
+
+	SetupVertexLightParams (light, data);
+}
+
+
+void GFX_GL_IMPL::SetAmbient( const float ambient[4] )
+{
+	GFX_LOG(("{%f, %f, %f, %f}", ambient[0], ambient[1], ambient[2], ambient[3]));
+	if( STATE.ambient != ambient )
+	{
+		OGL_CALL(glLightModelfv( GL_LIGHT_MODEL_AMBIENT, ambient ));
+		STATE.ambient.Set( ambient );
+	}
+}
+
+void GFX_GL_IMPL::EnableFog (const GfxFogParams& fog)
+{
+	GFX_LOG(("%d, %f, %f, %f, {%f, %f, %f, %f}", fog.mode, fog.start, fog.end, fog.density, fog.color.x, fog.color.y, fog.color.z, fog.color.w));
+
+	DebugAssertIf( fog.mode <= kFogDisabled );
+	if( m_FogParams.mode != fog.mode )
+	{
+		OGL_CALL(glFogi( GL_FOG_MODE, kFogModeGL[fog.mode] ));
+		OGL_CALL(glEnable( GL_FOG ));
+		m_FogParams.mode = fog.mode;
+	}
+	if( m_FogParams.start != fog.start )
+	{
+		OGL_CALL(glFogf( GL_FOG_START, fog.start ));
+		m_FogParams.start = fog.start;
+	}
+	if( m_FogParams.end != fog.end )
+	{
+		OGL_CALL(glFogf( GL_FOG_END, fog.end ));
+		m_FogParams.end = fog.end;
+	}
+	if( m_FogParams.density != fog.density )
+	{
+		OGL_CALL(glFogf( GL_FOG_DENSITY, fog.density ));
+		m_FogParams.density = fog.density;
+	}
+	if( m_FogParams.color != fog.color )
+	{
+		OGL_CALL(glFogfv( GL_FOG_COLOR, fog.color.GetPtr() ));
+		m_FogParams.color = fog.color;
+	}
+}
+
+void GFX_GL_IMPL::DisableFog()
+{
+	GFX_LOG((""));
+
+	if( m_FogParams.mode != kFogDisabled )
+	{
+		OGL_CALL(glFogf( GL_FOG_DENSITY, 0.0f ));
+		OGL_CALL(glDisable( GL_FOG ));
+
+		m_FogParams.mode = kFogDisabled;
+		m_FogParams.density = 0.0f;
+	}
+}
+
+
+VBO* GFX_GL_IMPL::CreateVBO()
+{
+	VBO* vbo = new ARBVBO();
+	OnCreateVBO(vbo);
+	return vbo;
+}
+
+void GFX_GL_IMPL::DeleteVBO( VBO* vbo )
+{
+	OnDeleteVBO(vbo);
+	delete vbo;
+}
+
+DynamicVBO& GFX_GL_IMPL::GetDynamicVBO()
+{
+	if( STATE.m_DynamicVBO == NULL )
+	{
+		// DynamicARBVBO is slower! Just don't use it for now.
+		//	STATE.m_DynamicVBO = new DynamicARBVBO( 1024 * 1024 ); // initial size: 1MiB VB
+		STATE.m_DynamicVBO = new DynamicNullVBO();
+	}
+	return *STATE.m_DynamicVBO;
+}
+
+
+
+// ---------- render textures
+
+
+// defined in RenderTextureGL
+RenderSurfaceHandle CreateRenderColorSurfaceGL (TextureID textureID, int width, int height, int samples, TextureDimension dim, UInt32 createFlags, RenderTextureFormat format, GLuint globalSharedFBO);
+RenderSurfaceHandle CreateRenderDepthSurfaceGL (TextureID textureID, int width, int height, int samples, UInt32 createFlags, DepthBufferFormat depthFormat, GLuint globalSharedFBO);
+void DestroyRenderSurfaceGL (RenderSurfaceHandle& rsHandle);
+bool SetRenderTargetGL (int count, RenderSurfaceHandle* colorHandles, RenderSurfaceHandle depthHandle, int mipLevel, CubemapFace face, GLuint globalSharedFBO);
+RenderSurfaceHandle GetActiveRenderColorSurfaceGL(int index);
+RenderSurfaceHandle GetActiveRenderDepthSurfaceGL();
+void ResolveDepthIntoTextureGL (RenderSurfaceHandle colorHandle, RenderSurfaceHandle depthHandle, GLuint globalSharedFBO, GLuint helperFBO);
+void GrabIntoRenderTextureGL (RenderSurfaceHandle rs, int x, int y, int width, int height, GLuint globalSharedFBO);
+
+
+static GLuint GetFBO (GLuint* fbo)
+{
+	if (!(*fbo) && gGraphicsCaps.hasRenderToTexture)
+	{
+		glGenFramebuffersEXT (1, fbo);
+	}
+	return *fbo;
+}
+
+static GLuint GetSharedFBO (DeviceStateGL& state)
+{
+	return GetFBO (&state.m_SharedFBO);
+}
+
+static GLuint GetHelperFBO (DeviceStateGL& state)
+{
+	return GetFBO (&state.m_HelperFBO);
+}
+
+RenderSurfaceHandle GFX_GL_IMPL::CreateRenderColorSurface (TextureID textureID, int width, int height, int samples, int depth, TextureDimension dim, RenderTextureFormat format, UInt32 createFlags)
+{
+	GFX_LOG(("%d, %d, %d, %d, %d", textureID.m_ID, width, height, createFlags, format));
+	GLuint fbo = GetSharedFBO(STATE);
+	RenderSurfaceHandle rs = CreateRenderColorSurfaceGL (textureID, width, height, samples, dim, createFlags, format, fbo);
+	#if GFX_DEVICE_VERIFY_ENABLE
+	VerifyState();
+	#endif
+	return rs;
+}
+RenderSurfaceHandle GFX_GL_IMPL::CreateRenderDepthSurface (TextureID textureID, int width, int height, int samples, TextureDimension dim, DepthBufferFormat depthFormat, UInt32 createFlags)
+{
+	GFX_LOG(("%d, %d, %d, %d", textureID.m_ID, width, height, depthFormat));
+	GLuint fbo = GetSharedFBO(STATE);
+	RenderSurfaceHandle rs = CreateRenderDepthSurfaceGL (textureID, width, height, samples, createFlags, depthFormat, fbo);
+	#if GFX_DEVICE_VERIFY_ENABLE
+	VerifyState();
+	#endif
+	return rs;
+}
+void GFX_GL_IMPL::DestroyRenderSurface (RenderSurfaceHandle& rs)
+{
+	GFX_LOG((""));
+
+	// Early out if render surface is not created (don't do flush in that case)
+	if( !rs.IsValid() )
+		return;
+
+	DestroyRenderSurfaceGL (rs);
+
+	#if UNITY_WIN
+	// Invalidating state causes problems with Windows OpenGL editor (case 490767).
+	int flags = kGLContextSkipInvalidateState;
+	#else
+	// Not invalidating state makes the cached state not match the actual state on OS X (case 494066).
+	int flags = 0;
+	#endif
+
+	GraphicsContextHandle ctx = GetMainGraphicsContext();
+	if( ctx.IsValid() )
+		ActivateGraphicsContext (ctx, false, flags);
+
+	#if GFX_DEVICE_VERIFY_ENABLE
+	VerifyState();
+	#endif
+}
+void GFX_GL_IMPL::SetRenderTargets (int count, RenderSurfaceHandle* colorHandles, RenderSurfaceHandle depthHandle, int mipLevel, CubemapFace face)
+{
+	GFX_LOG(("%d", face));
+	#if GFX_DEVICE_VERIFY_ENABLE
+	VerifyState();
+	#endif
+	SetRenderTargetGL (count, colorHandles, depthHandle, mipLevel, face, GetSharedFBO(STATE));
+	// changing render target might mean different color clear flags; so reset current state
+	STATE.m_CurrBlendState = NULL;
+	#if GFX_DEVICE_VERIFY_ENABLE
+	VerifyState();
+	#endif
+}
+void GFX_GL_IMPL::ResolveDepthIntoTexture (RenderSurfaceHandle colorHandle, RenderSurfaceHandle depthHandle)
+{
+	GFX_LOG((""));
+	::ResolveDepthIntoTextureGL (colorHandle, depthHandle, GetSharedFBO(STATE), GetHelperFBO(STATE));
+}
+void GFX_GL_IMPL::ResolveColorSurface (RenderSurfaceHandle srcHandle, RenderSurfaceHandle dstHandle)
+{
+	void ResolveColorSurfaceGL (RenderSurfaceHandle srcHandle, RenderSurfaceHandle dstHandle, GLuint globalSharedFBO, GLuint helperFBO);
+
+	ResolveColorSurfaceGL (srcHandle, dstHandle, GetSharedFBO(STATE), GetHelperFBO(STATE));
+}
+RenderSurfaceHandle GFX_GL_IMPL::GetActiveRenderColorSurface(int index)
+{
+	return GetActiveRenderColorSurfaceGL(index);
+}
+RenderSurfaceHandle GFX_GL_IMPL::GetActiveRenderDepthSurface()
+{
+	return GetActiveRenderDepthSurfaceGL();
+}
+void GFX_GL_IMPL::SetSurfaceFlags (RenderSurfaceHandle surf, UInt32 flags, UInt32 keepFlags)
+{
+}
+
+// ---------- uploading textures
+
+void GFX_GL_IMPL::UploadTexture2D( TextureID texture, TextureDimension dimension, UInt8* srcData, int srcSize, int width, int height, TextureFormat format, int mipCount, UInt32 uploadFlags, int skipMipLevels, TextureUsageMode usageMode, TextureColorSpace colorSpace )
+{
+	GFX_LOG(("%d, %d, %d, %d, %d, %d, %d, %d, %d, %d", texture.m_ID, dimension, width, height, format, mipCount, uploadFlags, skipMipLevels, usageMode, colorSpace));
+ 	::UploadTexture2DGL( texture, dimension, srcData, width, height, format, mipCount, uploadFlags, skipMipLevels, usageMode, colorSpace );
+}
+
+void GFX_GL_IMPL::UploadTextureSubData2D( TextureID texture, UInt8* srcData, int srcSize, int mipLevel, int x, int y, int width, int height, TextureFormat format, TextureColorSpace colorSpace )
+{
+	GFX_LOG(("%d, %d, %d, %d, %d, %d, %d, %d", texture.m_ID, mipLevel, x, y, width, height, format, colorSpace));
+	::UploadTextureSubData2DGL( texture, srcData, mipLevel, x, y, width, height, format, colorSpace );
+}
+
+void GFX_GL_IMPL::UploadTextureCube( TextureID texture, UInt8* srcData, int srcSize, int faceDataSize, int size, TextureFormat format, int mipCount, UInt32 uploadFlags, TextureColorSpace colorSpace )
+{
+	GFX_LOG(("%d, %d, %d, %d, %d, %d, %d", texture.m_ID, faceDataSize, size, format, mipCount, uploadFlags, colorSpace));
+	::UploadTextureCubeGL( texture, srcData, faceDataSize, size, format, mipCount, uploadFlags, colorSpace );
+}
+
+void GFX_GL_IMPL::UploadTexture3D( TextureID texture, UInt8* srcData, int srcSize, int width, int height, int depth, TextureFormat format, int mipCount, UInt32 uploadFlags )
+{
+	GFX_LOG(("%d, %d, %d, %d, %d, %d, %d", texture.m_ID, width, height, depth, format, mipCount, uploadFlags ));
+	::UploadTexture3DGL( texture, srcData, width, height, depth, format, mipCount, uploadFlags );
+}
+
+void GFX_GL_IMPL::DeleteTexture( TextureID texture )
+{
+	GFX_LOG(("%d", texture.m_ID));
+	GLuint texname = (GLuint)TextureIdMap::QueryNativeTexture(texture);
+    if(texname == 0)
+        return;
+
+	REGISTER_EXTERNAL_GFX_DEALLOCATION(texture.m_ID);
+	glDeleteTextures( 1, &texname );
+
+	// invalidate texture unit states that used this texture
+	for( int i = 0; i < kMaxSupportedTextureUnits; ++i )
+	{
+		TextureUnitStateGL& currTex = STATE.textures[i];
+		if( currTex.texID == texname )
+			currTex.Invalidate();
+	}
+
+	TextureIdMap::RemoveTexture(texture);
+}
+
+
+// ---------- context
+
+GfxDevice::PresentMode GFX_GL_IMPL::GetPresentMode()
+{
+	return kPresentBeforeUpdate;
+}
+void GFX_GL_IMPL::BeginFrame()
+{
+	GFX_LOG((""));
+	m_InsideFrame = true;
+}
+void GFX_GL_IMPL::EndFrame()
+{
+	GFX_LOG((""));
+	m_InsideFrame = false;
+}
+bool GFX_GL_IMPL::IsValidState()
+{
+	#if UNITY_LINUX
+	// The Linux webplayer sometimes appears to lose sync with the GL cache.
+	// This is a quick, best-guess test for that which allows us to recover gracefully.
+	float temp;
+	glGetFloatv (GL_FRONT_FACE, &temp);
+	return CompareApproximately(temp,(STATE.appBackfaceMode != STATE.userBackfaceMode)?GL_CCW:GL_CW,0.0001f);
+	#endif
+	return true;
+}
+
+void GFX_GL_IMPL::PresentFrame()
+{
+	GFX_LOG((""));
+	PresentContextGL( GetMainGraphicsContext() );
+	#if GFX_DEVICE_VERIFY_ENABLE
+	VerifyState();
+	#endif
+}
+
+void GFX_GL_IMPL::FinishRendering()
+{
+	GFX_LOG((""));
+	OGL_CALL(glFinish());
+}
+
+
+// ---------- immediate mode rendering
+
+template <class T>
+void WriteToArray(const T& data, dynamic_array<UInt8>& dest)
+{
+	int offset = dest.size();
+	dest.resize_uninitialized(offset + sizeof(T), true);
+	*reinterpret_cast<T*>(&dest[offset]) = data;
+}
+
+
+void GFX_GL_IMPL::ImmediateVertex( float x, float y, float z )
+{
+	GFX_LOG(("%f, %f, %f", x, y ,z));
+	WriteToArray(UInt32(kImmediateVertex), STATE.m_ImmediateVertices);
+	WriteToArray(Vector3f(x, y, z), STATE.m_ImmediateVertices);
+}
+
+void GFX_GL_IMPL::ImmediateNormal( float x, float y, float z )
+{
+	GFX_LOG(("%f, %f, %f", x, y ,z));
+	WriteToArray(UInt32(kImmediateNormal), STATE.m_ImmediateVertices);
+	WriteToArray(Vector3f(x, y, z), STATE.m_ImmediateVertices);
+}
+
+void GFX_GL_IMPL::ImmediateColor( float r, float g, float b, float a )
+{
+	GFX_LOG(("%f, %f, %f, %f", r, g, b, a));
+	WriteToArray(UInt32(kImmediateColor), STATE.m_ImmediateVertices);
+	WriteToArray(ColorRGBAf(r, g, b, a), STATE.m_ImmediateVertices);
+}
+
+void GFX_GL_IMPL::ImmediateTexCoordAll( float x, float y, float z )
+{
+	GFX_LOG(("%f, %f, %f", x, y ,z));
+	WriteToArray(UInt32(kImmediateTexCoordAll), STATE.m_ImmediateVertices);
+	WriteToArray(Vector3f(x, y, z), STATE.m_ImmediateVertices);
+}
+
+void GFX_GL_IMPL::ImmediateTexCoord( int unit, float x, float y, float z )
+{
+	GFX_LOG(("%d, %f, %f, %f", unit, x, y ,z));
+	WriteToArray(UInt32(kImmediateTexCoord), STATE.m_ImmediateVertices);
+	WriteToArray(UInt32(unit), STATE.m_ImmediateVertices);
+	WriteToArray(Vector3f(x, y, z), STATE.m_ImmediateVertices);
+}
+
+void GFX_GL_IMPL::ImmediateBegin( GfxPrimitiveType type )
+{
+	GFX_LOG(("%d", type));
+	STATE.m_ImmediateMode = type;
+	STATE.m_ImmediateVertices.clear();
+}
+
+void GFX_GL_IMPL::ImmediateEnd()
+{
+	GFX_LOG((""));
+
+	int size = STATE.m_ImmediateVertices.size();
+	if (size == 0)
+		return;
+
+	// when beginning immediate mode, turn off any vertex array components that might be
+	// activated
+	UnbindVertexBuffersGL();
+	ClearActiveChannelsGL();
+	ActivateChannelsGL();
+	BeforeDrawCall( true );
+	glBegin (kTopologyGL[STATE.m_ImmediateMode]);
+
+	const UInt8* src = STATE.m_ImmediateVertices.data();
+	const UInt8* end = src + size;
+	int vertexCount = 0;
+	while (src < end)
+	{
+		UInt32 type = *reinterpret_cast<const UInt32*>(src);
+		src += sizeof(UInt32);
+		switch (type)
+		{
+			case kImmediateVertex:
+			{
+				const Vector3f& v = *reinterpret_cast<const Vector3f*>(src);
+				src += sizeof(Vector3f);
+				glVertex3f( v.x, v.y, v.z );
+				++vertexCount;
+				break;
+			}
+			case kImmediateNormal:
+			{
+				const Vector3f& v = *reinterpret_cast<const Vector3f*>(src);
+				src += sizeof(Vector3f);
+				glNormal3f( v.x, v.y, v.z );
+				break;
+			}
+			case kImmediateColor:
+			{
+				const ColorRGBAf& col = *reinterpret_cast<const ColorRGBAf*>(src);
+				src += sizeof(ColorRGBAf);
+				glColor4f( col.r, col.g, col.b, col.a );
+				break;
+			}
+			case kImmediateTexCoordAll:
+			{
+				const Vector3f& v = *reinterpret_cast<const Vector3f*>(src);
+				src += sizeof(Vector3f);
+				for( int i = gGraphicsCaps.maxTexCoords; i--; )
+				{
+					if( STATE.textures[i].texGen <= kTexGenDisabled )
+						glMultiTexCoord3fARB( GL_TEXTURE0_ARB + i, v.x, v.y, v.z );
+				}
+				break;
+			}
+			case kImmediateTexCoord:
+			{
+				UInt32 unit = *reinterpret_cast<const UInt32*>(src);
+				src += sizeof(UInt32);
+				const Vector3f& v = *reinterpret_cast<const Vector3f*>(src);
+				src += sizeof(Vector3f);
+				glMultiTexCoord3fARB( GL_TEXTURE0_ARB + unit, v.x, v.y, v.z );
+				break;
+			}
+			default:
+				ErrorString("Unknown immediate type!");
+				break;
+		}
+	}
+
+	glEnd();
+	// NOTE: all immediate mode calls CAN'T call glGetError - this will result in an error!
+	// So all of Immediate* calls do not use OGL_CALL macro; instead we're just checking
+	// for errors after glEnd.
+	GLAssert();
+
+	STATE.m_ImmediateVertices.clear();
+
+	// stats
+	switch( STATE.m_ImmediateMode ) {
+	case kPrimitiveTriangles:
+		m_Stats.AddDrawCall( vertexCount / 3, vertexCount );
+		break;
+	case kPrimitiveTriangleStripDeprecated:
+		m_Stats.AddDrawCall( vertexCount - 2, vertexCount );
+		break;
+	case kPrimitiveQuads:
+		m_Stats.AddDrawCall( vertexCount / 4 * 2, vertexCount );
+		break;
+	case kPrimitiveLines:
+		m_Stats.AddDrawCall( vertexCount / 2, vertexCount );
+		break;
+	}
+}
+
+extern GLint gDefaultFBOGL;
+
+
+void GLReadPixelsWrapper (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
+{
+	// When running in Safari 64-bit, we cannot just perform a normal glReadPixels.
+	// This is because we are rendering into an FBO which is allocated by the Safari process.
+	// Apparently there are some memory access restrictions, I have not been able to read from that fbo.
+	// Also, reading from FBOs with FSAA is not possible.
+	// We work around this by allocating an FBO of our own, blitting into that, and reading from there.
+
+	GLuint fbo;
+	GLuint fboTexture;
+	GLint oldTexture;
+	bool useWorkaround = (gDefaultFBOGL != 0);
+
+	if (useWorkaround)
+	{
+		GLint curFBO;
+		glGetIntegerv(GL_FRAMEBUFFER_BINDING_EXT, &curFBO);
+		if (curFBO != gDefaultFBOGL)
+			useWorkaround = false;
+	}
+	if 	(useWorkaround)
+	{
+		if( !gGraphicsCaps.gl.hasFrameBufferBlit )
+		{
+			ErrorString ("Cannot read from image without framebuffer blit extension!");
+			return;
+		}
+
+		glGetIntegerv(GL_TEXTURE_BINDING_2D, &oldTexture);
+
+		// Create FBO
+		glGenTextures(1, &fboTexture);
+		glBindTexture(GL_TEXTURE_2D, fboTexture);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+		glGenFramebuffersEXT(1, &fbo);
+		glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, fbo );
+		glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, fboTexture, 0);
+		GLAssert();
+
+		// Blit into it
+		glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, gDefaultFBOGL);
+		glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fbo);
+		glBlitFramebufferEXT(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
+		glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
+		GLAssert();
+	}
+
+	glReadPixels( x, y, width, height, format, type, pixels );
+
+	if 	(useWorkaround)
+	{
+		// Restore old state
+		glBindTexture(GL_TEXTURE_2D, oldTexture);
+		glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, gDefaultFBOGL);
+
+		// Destroy FBO
+		glDeleteFramebuffersEXT( 1, &fbo );
+		glDeleteTextures(1, &fboTexture);
+		GLAssert();
+	}
+}
+
+bool GFX_GL_IMPL::CaptureScreenshot( int left, int bottom, int width, int height, UInt8* rgba32 )
+{
+	GFX_LOG(("%d, %d, %d, %d", left, bottom, width, height));
+	GLReadPixelsWrapper ( left, bottom, width, height, GL_RGBA, GL_UNSIGNED_BYTE, rgba32 );
+	return true;
+}
+
+bool GFX_GL_IMPL::ReadbackImage( ImageReference& image, int left, int bottom, int width, int height, int destX, int destY )
+{
+	GFX_LOG(("%d, %d, %d, %d, %d, %d", left, bottom, width, height, destX, destY));
+	return ReadbackTextureGL( image, left, bottom, width, height, destX, destY );
+}
+
+void GFX_GL_IMPL::GrabIntoRenderTexture (RenderSurfaceHandle rs, RenderSurfaceHandle rd, int x, int y, int width, int height )
+{
+	GFX_LOG(("%d, %d, %d, %d", x, y, width, height));
+	::GrabIntoRenderTextureGL (rs, x, y, width, height, GetHelperFBO (STATE));
+}
+
+RenderTextureFormat	GFX_GL_IMPL::GetDefaultRTFormat() const	{ return kRTFormatARGB32; }
+RenderTextureFormat	GFX_GL_IMPL::GetDefaultHDRRTFormat() const	{ return kRTFormatARGBHalf; }
+
+void* GFX_GL_IMPL::GetNativeTexturePointer(TextureID id)
+{
+	return (void*)TextureIdMap::QueryNativeTexture(id);
+}
+
+
+void GFX_GL_IMPL::SetActiveContext (void* ctx)
+{
+	GraphicsContextGL* glctx = reinterpret_cast<GraphicsContextGL*> (ctx);
+	ActivateGraphicsContextGL (*glctx, kGLContextSkipInvalidateState | kGLContextSkipUnbindObjects | kGLContextSkipFlush);
+}
+
+
+#if ENABLE_PROFILER
+
+GfxTimerQuery* GFX_GL_IMPL::CreateTimerQuery()
+{
+	TimerQueryGL* query = new TimerQueryGL;
+	return query;
+}
+
+void GFX_GL_IMPL::DeleteTimerQuery(GfxTimerQuery* query)
+{
+	delete query;
+}
+
+void GFX_GL_IMPL::BeginTimerQueries()
+{
+	if( !gGraphicsCaps.hasTimerQuery )
+		return;
+
+	g_TimerQueriesGL.BeginTimerQueries();
+}
+
+void GFX_GL_IMPL::EndTimerQueries()
+{
+	if (!gGraphicsCaps.hasTimerQuery )
+		return;
+
+	g_TimerQueriesGL.EndTimerQueries();
+}
+
+bool GFX_GL_IMPL::TimerQueriesIsActive()
+{
+	if (!gGraphicsCaps.hasTimerQuery )
+		return false;
+
+	return g_TimerQueriesGL.IsActive();
+}
+
+#endif // ENABLE_PROFILER
+
+// -------- editor-only functions
+
+#if UNITY_EDITOR
+
+void GFX_GL_IMPL::SetAntiAliasFlag( bool aa )
+{
+	if( aa )
+	{
+		OGL_CALL(glHint (GL_LINE_SMOOTH_HINT, GL_NICEST));
+		OGL_CALL(glEnable (GL_LINE_SMOOTH));
+	}
+	else
+	{
+		OGL_CALL(glHint (GL_LINE_SMOOTH_HINT, GL_FASTEST));
+		OGL_CALL(glDisable (GL_LINE_SMOOTH));
+	}
+}
+
+
+void GFX_GL_IMPL::DrawUserPrimitives( GfxPrimitiveType type, int vertexCount, UInt32 vertexChannels, const void* data, int stride )
+{
+	if( vertexCount == 0 )
+		return;
+
+	AssertIf( !data || vertexCount < 0 || vertexChannels == 0 );
+
+	UnbindVertexBuffersGL();
+	ClearActiveChannelsGL();
+	int offset = 0;
+	for( int i = 0; i < kShaderChannelCount; ++i )
+	{
+		if( !( vertexChannels & (1<<i) ) )
+			continue;
+		VertexComponent destComponent = kSuitableVertexComponentForChannel[i];
+		SetChannelDataGL( (ShaderChannel)i, destComponent, (const UInt8*)data + offset, stride );
+		offset += VBO::GetDefaultChannelByteSize(i);
+	}
+	ActivateChannelsGL();
+	BeforeDrawCall(false);
+
+	OGL_CALL(glDrawArrays(kTopologyGL[type], 0, vertexCount));
+
+	// stats
+	switch (type) {
+	case kPrimitiveTriangles:
+		m_Stats.AddDrawCall( vertexCount / 3, vertexCount );
+		break;
+	case kPrimitiveQuads:
+		m_Stats.AddDrawCall( vertexCount / 4 * 2, vertexCount );
+		break;
+	case kPrimitiveLines:
+		m_Stats.AddDrawCall( vertexCount / 2, vertexCount );
+		break;
+	case kPrimitiveLineStrip:
+		m_Stats.AddDrawCall( vertexCount-1, vertexCount );
+		break;
+	}
+}
+
+int GFX_GL_IMPL::GetCurrentTargetAA() const
+{
+	int fsaa = 0;
+	if( gGraphicsCaps.hasMultiSample )
+		glGetIntegerv( GL_SAMPLES_ARB, &fsaa );
+	return fsaa;
+}
+
+#if UNITY_WIN
+	GfxDeviceWindow*	GFX_GL_IMPL::CreateGfxWindow( HWND window, int width, int height, DepthBufferFormat depthFormat, int antiAlias )
+	{
+		return new GLWindow(window, width, height, depthFormat, antiAlias);
+	}
+#endif
+
+
+#endif // UNITY_EDITOR
+
+
+
+// --------------------------------------------------------------------------
+// -------- verification of state
+
+
+
+#if GFX_DEVICE_VERIFY_ENABLE
+
+
+void VerifyGLState(GLenum gl, float val, const char *str);
+#define VERIFY(s,t) VerifyGLState (s, t, #s " (" #t ")")
+void VerifyGLStateI(GLenum gl, int val, const char *str);
+#define VERIFYI(s,t) VerifyGLStateI (s, t, #s " (" #t ")")
+void VerifyGLState4(GLenum gl, const float *val, const char *str);
+#define VERIFY4(s,t) VerifyGLState4 (s, t, #s " (" #t ")")
+
+void VerifyEnabled(GLenum gl, bool val, const char *str);
+#define VERIFYENAB(s,t) VerifyEnabled ( s, t, #s " (" #t ")")
+
+void VerifyMaterial (GLenum gl, const float *val, const char *str);
+#define VERIFYMAT(s,t) VerifyMaterial ( s, t, #s " (" #t ")")
+
+void VerifyTexParam (int target, GLenum gl, float val, const char *str);
+#define VERIFYTP(s,t) VerifyTexParam (target, s, t, #s " (" #t ")")
+
+void VerifyTexEnv (GLenum target, GLenum gl, int val, const char *str);
+#define VERIFYTE(g,s,t) VerifyTexEnv (g, s, t, #s " (" #t ")")
+
+void VerifyTexEnv4 (GLenum target, GLenum gl, const float *val, const char *str);
+#define VERIFYTE4(g,s,t) VerifyTexEnv4(g, s, t, #s " (" #t ")")
+
+void VerifyTexGen (GLenum coord, GLenum gl, int val, const char *str);
+#define VERIFYTG(c,s,t) VerifyTexGen (c, s, t, #s " (" #t ")")
+
+
+static void VERIFY_PRINT( const char* format, ... )
+{
+	va_list va;
+	va_start (va, format);
+	ErrorString( VFormat( format, va ) );
+	va_end (va);
+}
+
+const float kVerifyDelta = 0.0001f;
+
+void VerifyGLState(GLenum gl, float val, const char *str)
+{
+	float temp;
+	glGetFloatv (gl, &temp);
+	if( !CompareApproximately(temp,val,kVerifyDelta) ) {
+		VERIFY_PRINT ("%s differs from cache (%f != %f)\n", str, val, temp);
+	}
+}
+
+void VerifyGLStateI(GLenum gl, int val, const char *str)
+{
+	int temp;
+	glGetIntegerv (gl, &temp);
+	if (temp != val) {
+		VERIFY_PRINT ("%s differs from cache (0x%x != 0x%x)\n", str, val, temp);
+	}
+}
+
+void VerifyGLState4 (GLenum gl, const float *val, const char *str)
+{
+	GLfloat temp[4];
+	glGetFloatv (gl, temp);
+	if( !CompareApproximately(temp[0],val[0],kVerifyDelta) ||
+		!CompareApproximately(temp[1],val[1],kVerifyDelta) ||
+		!CompareApproximately(temp[2],val[2],kVerifyDelta) ||
+		!CompareApproximately(temp[3],val[3],kVerifyDelta) )
+	{
+		VERIFY_PRINT ("%s differs from cache (%f,%f,%f,%f) != (%f,%f,%f,%f)\n", str, val[0],val[1],val[2],val[3], temp[0],temp[1],temp[2],temp[3]);
+	}
+}
+
+void VerifyEnabled(GLenum gl, bool val, const char *str)
+{
+	bool temp = glIsEnabled (gl) ? true : false;
+	if (temp != val) {
+		VERIFY_PRINT ("%s differs from cache (%d != %d)\n", str, val, temp);
+	}
+}
+
+void VerifyMaterial (GLenum gl, const float *val, const char *str)
+{
+	GLfloat temp[4];
+	glGetMaterialfv (GL_FRONT, gl, temp);
+	if( !CompareApproximately(temp[0],val[0],kVerifyDelta) ||
+		!CompareApproximately(temp[1],val[1],kVerifyDelta) ||
+		!CompareApproximately(temp[2],val[2],kVerifyDelta) ||
+		!CompareApproximately(temp[3],val[3],kVerifyDelta) )
+	{
+		VERIFY_PRINT ("%s differs from cache (%f,%f,%f,%f) != (%f,%f,%f,%f)\n",str, val[0],val[1],val[2],val[3], temp[0],temp[1],temp[2],temp[3]);
+	}
+}
+
+void VerifyTexParam (int target, GLenum gl, float val, const char *str)
+{
+	float temp;
+	glGetTexParameterfv (target, gl, &temp);
+	if( !CompareApproximately(temp,val,kVerifyDelta) ) {
+		VERIFY_PRINT ("%s differs from cache (%f != %f)\n", str, val, temp);
+	}
+}
+
+void VerifyTexEnv (GLenum target, GLenum gl, int val, const char *str)
+{
+	GLint temp;
+	glGetTexEnviv (target, gl, &temp);
+	if (temp != val) {
+		VERIFY_PRINT ("%s differs from cache (%d != %d)\n", str, (int)val, (int)temp);
+	}
+}
+
+void VerifyTexEnv4( GLenum target, GLenum gl, const float *val, const char *str )
+{
+	GLfloat temp[4];
+	glGetTexEnvfv(target, gl, temp);
+	float val0 = clamp01(val[0]);
+	float val1 = clamp01(val[1]);
+	float val2 = clamp01(val[2]);
+	float val3 = clamp01(val[3]);
+	if( !CompareApproximately(temp[0],val0,kVerifyDelta) ||
+		!CompareApproximately(temp[1],val1,kVerifyDelta) ||
+		!CompareApproximately(temp[2],val2,kVerifyDelta) ||
+		!CompareApproximately(temp[3],val3,kVerifyDelta) )
+	{
+		VERIFY_PRINT ("%s differs from cache (%f,%f,%f,%f) != (%f,%f,%f,%f)\n", str, val0,val1,val2,val3, temp[0],temp[1],temp[2],temp[3]);
+	}
+}
+
+
+void VerifyTexGen(GLenum coord, GLenum gl, int val, const char *str)
+{
+	GLint temp;
+	glGetTexGeniv (coord, gl, &temp);
+	if (temp != val) {
+		VERIFY_PRINT ("TexGen %s differs from cache (%d != %d)\n", str, val, (int)temp);
+	}
+}
+
+
+void GFX_GL_IMPL::VerifyState()
+{
+	STATE.Verify();
+
+	if( m_FogParams.mode != kFogUnknown )
+	{
+		VERIFYENAB( GL_FOG, m_FogParams.mode != 0 );
+		//VERIFY( GL_FOG_MODE, GetFogMode()[m_FogParams.mode] ); // TBD
+		if( m_FogParams.mode != kFogDisabled )
+		{
+			VERIFY( GL_FOG_START, m_FogParams.start );
+			VERIFY( GL_FOG_END, m_FogParams.end );
+			VERIFY( GL_FOG_DENSITY, m_FogParams.density );
+			float clampedFogColor[4];
+			clampedFogColor[0] = clamp01(m_FogParams.color.x);
+			clampedFogColor[1] = clamp01(m_FogParams.color.y);
+			clampedFogColor[2] = clamp01(m_FogParams.color.z);
+			clampedFogColor[3] = clamp01(m_FogParams.color.w);
+
+			VERIFY4( GL_FOG_COLOR, clampedFogColor );
+		}
+	}
+}
+
+
+void DeviceStateGL::Verify()
+{
+	GLAssert();
+	if( depthFunc != kFuncUnknown ) {
+		VERIFYENAB( GL_DEPTH_TEST, depthFunc != kFuncDisabled );
+		if( depthFunc != kFuncDisabled ) {
+			VERIFY( GL_DEPTH_FUNC, kCmpFuncGL[depthFunc] );
+		}
+	}
+	if( depthWrite != -1 ) {
+		GLboolean temp;
+		glGetBooleanv( GL_DEPTH_WRITEMASK, &temp );
+		if( temp != depthWrite )
+			printf_console( "DepthWrite mismatch (%d != %d)\n", (int)temp, (int)depthWrite );
+	}
+	if( blending != -1 ) {
+		VERIFYENAB( GL_BLEND, blending != 0 );
+		if( blending ) {
+			VERIFYI( GL_BLEND_SRC, srcBlend );
+			VERIFYI( GL_BLEND_DST, destBlend );
+			VERIFYI( GL_BLEND_EQUATION_RGB, blendOp );
+			if( gGraphicsCaps.hasSeparateAlphaBlend ) {
+				VERIFYI( GL_BLEND_SRC_ALPHA, srcBlendAlpha );
+				VERIFYI( GL_BLEND_DST_ALPHA, destBlendAlpha );
+				VERIFYI( GL_BLEND_EQUATION_ALPHA, blendOpAlpha );
+			}
+
+		}
+	}
+
+	if( alphaFunc != kFuncUnknown ) {
+		VERIFYENAB( GL_ALPHA_TEST, alphaFunc != kFuncDisabled );
+		if( alphaFunc != kFuncDisabled ) {
+			VERIFY( GL_ALPHA_TEST_FUNC, kCmpFuncGL[alphaFunc] );
+			if( alphaValue != -1 )
+				VERIFY( GL_ALPHA_TEST_REF, alphaValue );
+		}
+	}
+
+	if( culling != kCullUnknown ) {
+		VERIFYENAB( GL_CULL_FACE, culling != kCullOff );
+		switch (culling) {
+			case kCullOff: break;
+			case kCullFront: VERIFY (GL_CULL_FACE_MODE, GL_FRONT); break;
+			case kCullBack:  VERIFY (GL_CULL_FACE_MODE, GL_BACK);  break;
+			default: printf_console( "Invalid face cull mode: %d\n", (int)culling ); break;
+		}
+	}
+	VERIFY( GL_FRONT_FACE, (appBackfaceMode != userBackfaceMode) ? GL_CCW : GL_CW );
+
+	if( scissor != -1 ) {
+		VERIFYENAB( GL_SCISSOR_TEST, scissor != 0 );
+	}
+
+	if( lighting != -1 ) {
+		VERIFYENAB( GL_LIGHTING, lighting != 0 );
+		if( lighting && colorMaterial == kColorMatDisabled ) {
+			if( matAmbient.x != -1.0f )
+				VERIFYMAT( GL_AMBIENT, matAmbient.GetPtr() );
+			if( matDiffuse.x != -1.0f )
+				VERIFYMAT( GL_DIFFUSE, matDiffuse.GetPtr() );
+			if( matSpecular.x != -1.0f )
+				VERIFYMAT( GL_SPECULAR, matSpecular.GetPtr() );
+			if( matEmissive.x != -1.0f )
+				VERIFYMAT( GL_EMISSION, matEmissive.GetPtr() );
+			if( matShininess != -1.0f )
+			{
+				GLfloat temp;
+				glGetMaterialfv( GL_FRONT, GL_SHININESS, &temp );
+				if( !CompareApproximately(temp, matShininess * 128.0f, kVerifyDelta) )
+					printf_console( "Shininess mismatch: %f != %f\n", (float)temp, (float)matShininess );
+			}
+		}
+	}
+
+	// verify bound/enabled programs
+	for( int type = kShaderVertex; type < kShaderTypeCount; ++type )
+	{
+		ShaderImplType currType = shaderEnabledImpl[type];
+		if( currType == kShaderImplBoth )
+		{
+			GLhandleARB gl = glGetHandleARB( GL_PROGRAM_OBJECT_ARB );
+			if( gl != shaderEnabledID[type] )
+			{
+				VERIFY_PRINT( "GLSL program differs from cache (%d != %d)\n", gl, shaderEnabledID[type] );
+			}
+		}
+		else if( currType == kShaderImplUndefined )
+		{
+			AssertIf( shaderEnabledID[type] != -1 && shaderEnabledID[type] != 0 );
+			if( shaderEnabledID[type] == 0 )
+			{
+				if( type == kShaderVertex )
+				{
+					VERIFYENAB( GL_VERTEX_PROGRAM_ARB, false );
+				}
+				else
+				{
+					VERIFYENAB( GL_FRAGMENT_PROGRAM_ARB, false );
+				}
+			}
+		}
+		else
+		{
+			GLenum gltarget = GetGLShaderImplTarget( currType );
+			VERIFYENAB( gltarget, true );
+			int gl;
+			glGetProgramivARB( gltarget, GL_PROGRAM_BINDING_ARB, &gl );
+			if( gl != shaderEnabledID[type] )
+			{
+				VERIFY_PRINT( "Program #%i differs from cache (%d != %d)\n", type, gl, shaderEnabledID[type] );
+			}
+		}
+	}
+
+	// Verify all texture units
+	for( int i = 0; i < gGraphicsCaps.maxTexUnits; ++i ) {
+		textures[i].Verify(i);
+	}
+}
+
+static const unsigned long kTextureBindingTable[6] = {0, GL_TEXTURE_BINDING_1D, GL_TEXTURE_BINDING_2D, GL_TEXTURE_BINDING_3D, GL_TEXTURE_BINDING_CUBE_MAP_ARB};
+
+void TextureUnitStateGL::Verify( int texUnit )
+{
+	if( gGraphicsCaps.maxTexUnits <= 1 ) // do not crash on no-multi-texture machines
+		return;
+
+	if( texDim == kTexDimUnknown )
+		return;
+
+	glActiveTextureARB(GL_TEXTURE0_ARB + texUnit);
+
+	VERIFYI(GL_TEXTURE_2D, texDim == kTexDim2D);
+	VERIFYI(GL_TEXTURE_CUBE_MAP_ARB, texDim == kTexDimCUBE);
+	if( gGraphicsCaps.has3DTexture ) {
+		VERIFYI(GL_TEXTURE_3D, texDim == kTexDim3D);
+	}
+
+	if( color.x != -1 && color.y != -1 && color.z != -1 && color.w != -1 )
+		VERIFYTE4( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color.GetPtr() );
+
+	if( texDim != kTexDimNone && texID != -1 )
+		VERIFYI( kTextureBindingTable[texDim], texID );
+
+	if( texGen != kTexGenUnknown )
+	{
+		switch( texGen )
+		{
+		case kTexGenDisabled:
+			VERIFYENAB( GL_TEXTURE_GEN_S, false );
+			VERIFYENAB( GL_TEXTURE_GEN_T, false );
+			VERIFYENAB( GL_TEXTURE_GEN_R, false );
+			break;
+		case kTexGenSphereMap:
+			VERIFYTG(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
+			VERIFYTG(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
+			VERIFYENAB( GL_TEXTURE_GEN_S, true );
+			VERIFYENAB( GL_TEXTURE_GEN_T, true );
+			VERIFYENAB( GL_TEXTURE_GEN_R, false );
+			break;
+		case kTexGenObject: {
+			VERIFYTG(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
+			VERIFYTG(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
+			VERIFYTG(GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
+			VERIFYENAB( GL_TEXTURE_GEN_S, true );
+			VERIFYENAB( GL_TEXTURE_GEN_T, true );
+			VERIFYENAB( GL_TEXTURE_GEN_R, true );
+			break;
+		}
+		case kTexGenEyeLinear: {
+			VERIFYTG(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
+			VERIFYTG(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
+			VERIFYTG(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
+			VERIFYENAB( GL_TEXTURE_GEN_S, true );
+			VERIFYENAB( GL_TEXTURE_GEN_T, true );
+			VERIFYENAB( GL_TEXTURE_GEN_R, true );
+			break;
+		}
+		case kTexGenCubeReflect:
+			VERIFYTG(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB);
+			VERIFYTG(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB);
+			VERIFYTG(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB);
+			VERIFYENAB( GL_TEXTURE_GEN_S, true );
+			VERIFYENAB( GL_TEXTURE_GEN_T, true );
+			VERIFYENAB( GL_TEXTURE_GEN_R, true );
+			break;
+		case kTexGenCubeNormal:
+			VERIFYTG(GL_S, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_ARB);
+			VERIFYTG(GL_T, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_ARB);
+			VERIFYTG(GL_R, GL_TEXTURE_GEN_MODE, GL_NORMAL_MAP_ARB);
+			VERIFYENAB( GL_TEXTURE_GEN_S, true );
+			VERIFYENAB( GL_TEXTURE_GEN_T, true );
+			VERIFYENAB( GL_TEXTURE_GEN_R, true );
+			break;
+		}
+	}
+}
+
+
+#endif // GFX_DEVICE_VERIFY_ENABLE