// Copyright Epic Games, Inc. All Rights Reserved.

/*=============================================================================
	OpenGL3.h: Public OpenGL 3.2 definitions for non-common functionality
=============================================================================*/

#pragma once

#include "OpenGLPlatform.h"

#if UGL_PLATFORM_SUPPORTS_GL3

#include "Containers/Map.h"
#include "OpenGLBase.h"

struct FPlatformOpenGLContext;
struct FPlatformOpenGLDevice;

#define USE_OPENGL_NAME_CACHE 1
#define OPENGL_NAME_CACHE_SIZE 1024

struct FOpenGL3 : public FOpenGLBase
{
	static FORCEINLINE bool IsDebugContent()						{ return bDebugContext; }

	static FORCEINLINE bool SupportsTimestampQueries()				{ return TimestampQueryBits > 0; }
	static FORCEINLINE bool SupportsSeamlessCubeMap()				{ return bSupportsSeamlessCubemap; }
	static FORCEINLINE bool SupportsVolumeTextureRendering()		{ return bSupportsVolumeTextureRendering; }
	static FORCEINLINE bool AmdWorkaround()							{ return bAmdWorkaround; }
	static FORCEINLINE bool SupportsBufferStorage()					{ return true; }

	// Optional
	static FORCEINLINE void QueryTimestampCounter(GLuint QueryID)
	{
		glQueryCounter(QueryID, GL_TIMESTAMP);
	}

	static FORCEINLINE void BeginQuery(GLenum QueryType, GLuint QueryId)
	{
		glBeginQuery( QueryType, QueryId );
	}

	static FORCEINLINE void EndQuery(GLenum QueryType)
	{
		glEndQuery( QueryType );
	}

	static FORCEINLINE void GetQueryObject(GLuint QueryId, EQueryMode QueryMode, GLuint64* OutResult)
	{
		GLenum QueryName = (QueryMode == QM_Result) ? GL_QUERY_RESULT : GL_QUERY_RESULT_AVAILABLE;
		GLuint64 Result = 0;
		glGetQueryObjectui64v(QueryId, QueryName, &Result);
		*OutResult = Result;
	}

	static FORCEINLINE void ReadBuffer(GLenum Mode)
	{
		glReadBuffer( Mode );
	}

	static FORCEINLINE void DrawBuffer(GLenum Mode)
	{
		glDrawBuffer( Mode );
	}

	static FORCEINLINE void DeleteSync(UGLsync Sync)
	{
		glDeleteSync( Sync );
	}

	static FORCEINLINE UGLsync FenceSync(GLenum Condition, GLbitfield Flags)
	{
		return glFenceSync( Condition, Flags );
	}

	static FORCEINLINE bool IsSync(UGLsync Sync)
	{
		return (glIsSync( Sync ) == GL_TRUE) ? true : false;
	}

	static FORCEINLINE EFenceResult ClientWaitSync(UGLsync Sync, GLbitfield Flags, GLuint64 Timeout)
	{
		GLenum Result = glClientWaitSync( Sync, Flags, Timeout );
		switch (Result)
		{
			case GL_ALREADY_SIGNALED:		return FR_AlreadySignaled;
			case GL_TIMEOUT_EXPIRED:		return FR_TimeoutExpired;
			case GL_CONDITION_SATISFIED:	return FR_ConditionSatisfied;
		}
		return FR_WaitFailed;
	}

	static FORCEINLINE void GenSamplers(GLsizei Count, GLuint* Samplers)
	{
		glGenSamplers(Count, Samplers);
	}

	static FORCEINLINE void DeleteSamplers(GLsizei Count, GLuint* Samplers)
	{
		glDeleteSamplers(Count, Samplers);
	}

	static FORCEINLINE void SetSamplerParameter(GLuint Sampler, GLenum Parameter, GLint Value)
	{
		glSamplerParameteri(Sampler, Parameter, Value);
	}

	static FORCEINLINE void BindSampler(GLuint Unit, GLuint Sampler)
	{
		glBindSampler(Unit, Sampler);
	}

	static FORCEINLINE void PolygonMode(GLenum Face, GLenum Mode)
	{
		glPolygonMode(Face, Mode);
	}

	static FORCEINLINE void VertexAttribDivisor(GLuint Index, GLuint Divisor)
	{
		glVertexAttribDivisor(Index, Divisor);
	}

	// Required
	static FORCEINLINE void* MapBufferRange(GLenum Type, uint32 InOffset, uint32 InSize, EResourceLockMode LockMode)
	{
		GLenum Access;
		switch ( LockMode )
		{
			case EResourceLockMode::RLM_ReadOnly:
				Access = GL_MAP_READ_BIT;
				break;
			case EResourceLockMode::RLM_ReadOnlyPersistent:
				Access = (GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
				break;
			case EResourceLockMode::RLM_WriteOnly:
				Access = (GL_MAP_INVALIDATE_BUFFER_BIT | GL_MAP_WRITE_BIT);
#if 1
				// Temp workaround for synchrnoization when a UBO is discarded while being referenced
				Access |= GL_MAP_UNSYNCHRONIZED_BIT;
#endif
				break;
			case EResourceLockMode::RLM_WriteOnlyUnsynchronized:
				Access = (GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
				break;
			case EResourceLockMode::RLM_WriteOnlyPersistent:
				Access = (GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT);
				break;
			case EResourceLockMode::RLM_ReadWrite:
			default:
				Access = (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT);
		}
		return glMapBufferRange(Type, InOffset, InSize, Access);
	}

	static FORCEINLINE void UnmapBuffer(GLenum Type)
	{
		glUnmapBuffer(Type);
	}

	static FORCEINLINE void UnmapBufferRange(GLenum Type, uint32 InOffset, uint32 InSize)
	{
		UnmapBuffer(Type);
	}

	static FORCEINLINE void GenQueries(GLsizei NumQueries, GLuint* QueryIDs)
	{
		glGenQueries(NumQueries, QueryIDs);
	}

	static FORCEINLINE void DeleteQueries(GLsizei NumQueries, const GLuint* QueryIDs )
	{
		glDeleteQueries( NumQueries, QueryIDs );
	}

	static FORCEINLINE void GetQueryObject(GLuint QueryId, EQueryMode QueryMode, GLuint* OutResult)
	{
		GLenum QueryName = (QueryMode == QM_Result) ? GL_QUERY_RESULT : GL_QUERY_RESULT_AVAILABLE;
		glGetQueryObjectuiv(QueryId, QueryName, OutResult);
	}

	static FORCEINLINE void BindBufferBase(GLenum Target, GLuint Index, GLuint Buffer)
	{
		glBindBufferBase(Target, Index, Buffer);
	}

	static FORCEINLINE void BindBufferRange(GLenum Target, GLuint Index, GLuint Buffer, GLintptr Offset, GLsizeiptr Size)
	{
		glBindBufferRange(Target, Index, Buffer, Offset, Size);
	}

	static FORCEINLINE GLuint GetUniformBlockIndex(GLuint Program, const GLchar* UniformBlockName)
	{
		return glGetUniformBlockIndex(Program, UniformBlockName);
	}

	static FORCEINLINE void UniformBlockBinding(GLuint Program, GLuint UniformBlockIndex, GLuint UniformBlockBinding)
	{
		glUniformBlockBinding(Program, UniformBlockIndex, UniformBlockBinding);
	}

	static FORCEINLINE void BindFragDataLocation(GLuint Program, GLuint Color, const GLchar* Name)
	{
		glBindFragDataLocation(Program, Color, Name);
	}

	static FORCEINLINE void TexParameter(GLenum Target, GLenum Parameter, GLint Value)
	{
		glTexParameteri(Target, Parameter, Value);
	}

	static FORCEINLINE void FramebufferTexture(GLenum Target, GLenum Attachment, GLuint Texture, GLint Level)
	{
		glFramebufferTexture(Target, Attachment, Texture, Level);
	}

	static FORCEINLINE void FramebufferTexture3D(GLenum Target, GLenum Attachment, GLenum TexTarget, GLuint Texture, GLint Level, GLint ZOffset)
	{
		glFramebufferTexture3D(Target, Attachment, TexTarget, Texture, Level, ZOffset);
	}

	static FORCEINLINE void FramebufferTextureLayer(GLenum Target, GLenum Attachment, GLuint Texture, GLint Level, GLint Layer)
	{
		glFramebufferTextureLayer(Target, Attachment, Texture, Level, Layer);
	}

	static FORCEINLINE void Uniform4uiv(GLint Location, GLsizei Count, const GLuint* Value)
	{
		glUniform4uiv(Location, Count, Value);
	}

	static FORCEINLINE void BlitFramebuffer(GLint SrcX0, GLint SrcY0, GLint SrcX1, GLint SrcY1, GLint DstX0, GLint DstY0, GLint DstX1, GLint DstY1, GLbitfield Mask, GLenum Filter)
	{
		glBlitFramebuffer(SrcX0, SrcY0, SrcX1, SrcY1, DstX0, DstY0, DstX1, DstY1, Mask, Filter);
	}

	static FORCEINLINE void DrawBuffers(GLsizei NumBuffers, const GLenum* Buffers)
	{
		glDrawBuffers(NumBuffers, Buffers);
	}

	static FORCEINLINE void DepthRange(GLdouble Near, GLdouble Far)
	{
		glDepthRange(Near, Far);
	}

	static FORCEINLINE void EnableIndexed(GLenum Parameter, GLuint Index)
	{
		glEnablei(Parameter, Index);
	}

	static FORCEINLINE void DisableIndexed(GLenum Parameter, GLuint Index)
	{
		glDisablei(Parameter, Index);
	}

	static FORCEINLINE void ColorMaskIndexed(GLuint Index, GLboolean Red, GLboolean Green, GLboolean Blue, GLboolean Alpha)
	{
		glColorMaski(Index, Red, Green, Blue, Alpha);
	}

	static FORCEINLINE void VertexAttribPointer(GLuint Index, GLint Size, GLenum Type, GLboolean Normalized, GLsizei Stride, const GLvoid* Pointer)
	{
		glVertexAttribPointer(Index, Size, Type, Normalized, Stride, Pointer);
	}

	static FORCEINLINE void VertexAttribIPointer(GLuint Index, GLint Size, GLenum Type, GLsizei Stride, const GLvoid* Pointer)
	{
		glVertexAttribIPointer(Index, Size, Type, Stride, Pointer);
	}

	static FORCEINLINE void VertexAttrib4Nsv(GLuint AttributeIndex, const GLshort* Values)
	{
		glVertexAttrib4Nsv(AttributeIndex, Values);
	}

	static FORCEINLINE void VertexAttrib4sv(GLuint AttributeIndex, const GLshort* Values)
	{
		glVertexAttrib4sv(AttributeIndex, Values);
	}

	static FORCEINLINE void VertexAttribI4sv(GLuint AttributeIndex, const GLshort* Values)
	{
		glVertexAttribI4sv(AttributeIndex, Values);
	}

	static FORCEINLINE void VertexAttribI4usv(GLuint AttributeIndex, const GLushort* Values)
	{
		glVertexAttribI4usv(AttributeIndex, Values);
	}

	static FORCEINLINE void VertexAttrib4Nubv(GLuint AttributeIndex, const GLubyte* Values)
	{
		glVertexAttrib4Nubv(AttributeIndex, Values);
	}

	static FORCEINLINE void VertexAttrib4ubv(GLuint AttributeIndex, const GLubyte* Values)
	{
		glVertexAttrib4ubv(AttributeIndex, Values);
	}

	static FORCEINLINE void VertexAttribI4ubv(GLuint AttributeIndex, const GLubyte* Values)
	{
		glVertexAttribI4ubv(AttributeIndex, Values);
	}

	static FORCEINLINE void VertexAttrib4Nbv(GLuint AttributeIndex, const GLbyte* Values)
	{
		glVertexAttrib4Nbv(AttributeIndex, Values);
	}

	static FORCEINLINE void VertexAttrib4bv(GLuint AttributeIndex, const GLbyte* Values)
	{
		glVertexAttrib4bv(AttributeIndex, Values);
	}

	static FORCEINLINE void VertexAttribI4bv(GLuint AttributeIndex, const GLbyte* Values)
	{
		glVertexAttribI4bv(AttributeIndex, Values);
	}

	static FORCEINLINE void VertexAttrib4dv(GLuint AttributeIndex, const GLdouble* Values)
	{
		glVertexAttrib4dv(AttributeIndex, Values);
	}

	static FORCEINLINE void VertexAttribI4iv(GLuint AttributeIndex, const GLint* Values)
	{
		glVertexAttribI4iv(AttributeIndex, Values);
	}

	static FORCEINLINE void VertexAttribI4uiv(GLuint AttributeIndex, const GLuint* Values)
	{
		glVertexAttribI4uiv(AttributeIndex, Values);
	}

	static FORCEINLINE void DrawArraysInstanced(GLenum Mode, GLint First, GLsizei Count, GLsizei InstanceCount)
	{
		glDrawArraysInstanced(Mode, First, Count, InstanceCount);
	}

	static FORCEINLINE void DrawElementsInstanced(GLenum Mode, GLsizei Count, GLenum Type, const GLvoid* Indices, GLsizei InstanceCount)
	{
		glDrawElementsInstanced(Mode, Count, Type, Indices, InstanceCount);
	}

	static FORCEINLINE void DrawRangeElements(GLenum Mode, GLuint Start, GLuint End, GLsizei Count, GLenum Type, const GLvoid* Indices)
	{
		glDrawRangeElements(Mode, Start, End, Count, Type, Indices);
	}

	static FORCEINLINE void ClearBufferfv(GLenum Buffer, GLint DrawBufferIndex, const GLfloat* Value)
	{
		glClearBufferfv(Buffer, DrawBufferIndex, Value);
	}

	static FORCEINLINE void ClearBufferfi(GLenum Buffer, GLint DrawBufferIndex, GLfloat Depth, GLint Stencil)
	{
		glClearBufferfi(Buffer, DrawBufferIndex, Depth, Stencil);
	}

	static FORCEINLINE void ClearBufferiv(GLenum Buffer, GLint DrawBufferIndex, const GLint* Value)
	{
		glClearBufferiv(Buffer, DrawBufferIndex, Value);
	}

	static FORCEINLINE void ClearDepth(GLdouble Depth)
	{
		glClearDepth(Depth);
	}

	static FORCEINLINE void TexImage3D(GLenum Target, GLint Level, GLint InternalFormat, GLsizei Width, GLsizei Height, GLsizei Depth, GLint Border, GLenum Format, GLenum Type, const GLvoid* PixelData)
	{
		glTexImage3D(Target, Level, InternalFormat, Width, Height, Depth, Border, Format, Type, PixelData);
	}

	static FORCEINLINE void CompressedTexImage3D(GLenum Target, GLint Level, GLenum InternalFormat, GLsizei Width, GLsizei Height, GLsizei Depth, GLint Border, GLsizei ImageSize, const GLvoid* PixelData)
	{
		glCompressedTexImage3D(Target, Level, InternalFormat, Width, Height, Depth, Border, ImageSize, PixelData);
	}

	static FORCEINLINE void CompressedTexSubImage2D(GLenum Target, GLint Level, GLsizei Width, GLsizei Height, GLenum Format, GLsizei ImageSize, const GLvoid* PixelData)
	{
		glCompressedTexSubImage2D(Target, Level, 0, 0, Width, Height, Format, ImageSize, PixelData);
	}

	static FORCEINLINE void TexImage2DMultisample(GLenum Target, GLsizei Samples, GLint InternalFormat, GLsizei Width, GLsizei Height, GLboolean FixedSampleLocations)
	{
		glTexImage2DMultisample(Target, Samples, InternalFormat, Width, Height, FixedSampleLocations);
	}

	static FORCEINLINE void TexBuffer(GLenum Target, GLenum InternalFormat, GLuint Buffer)
	{
		glTexBuffer(Target, InternalFormat, Buffer);
	}

	static FORCEINLINE void TexSubImage3D(GLenum Target, GLint Level, GLint XOffset, GLint YOffset, GLint ZOffset, GLsizei Width, GLsizei Height, GLsizei Depth, GLenum Format, GLenum Type, const GLvoid* PixelData)
	{
		glTexSubImage3D(Target, Level, XOffset, YOffset, ZOffset, Width, Height, Depth, Format, Type, PixelData);
	}

	static FORCEINLINE void	CopyTexSubImage1D(GLenum Target, GLint Level, GLint XOffset, GLint X, GLint Y, GLsizei Width)
	{
		glCopyTexSubImage1D(Target, Level, XOffset, X, Y, Width);
	}

	static FORCEINLINE void	CopyTexSubImage2D(GLenum Target, GLint Level, GLint XOffset, GLint YOffset, GLint X, GLint Y, GLsizei Width, GLsizei Height)
	{
		glCopyTexSubImage2D(Target, Level, XOffset, YOffset, X, Y, Width, Height);
	}

	static FORCEINLINE void	CopyTexSubImage3D(GLenum Target, GLint Level, GLint XOffset, GLint YOffset, GLint ZOffset, GLint X, GLint Y, GLsizei Width, GLsizei Height)
	{
		glCopyTexSubImage3D(Target, Level, XOffset, YOffset, ZOffset, X, Y, Width, Height);
	}

	static FORCEINLINE void GetCompressedTexImage(GLenum Target, GLint Level, GLvoid* OutImageData)
	{
		glGetCompressedTexImage(Target, Level, OutImageData);
	}

	static FORCEINLINE void GetTexImage(GLenum Target, GLint Level, GLenum Format, GLenum Type, GLvoid* OutPixelData)
	{
		glGetTexImage(Target, Level, Format, Type, OutPixelData);
	}

	static FORCEINLINE void CopyBufferSubData(GLenum ReadTarget, GLenum WriteTarget, GLintptr ReadOffset, GLintptr WriteOffset, GLsizeiptr Size)
	{
		glCopyBufferSubData(ReadTarget, WriteTarget, ReadOffset, WriteOffset, Size);
	}
	
	static FORCEINLINE GLuint CreateShader(GLenum Type)
	{
#if USE_OPENGL_NAME_CACHE
		static TMap<GLenum, TArray<GLuint>> ShaderNames;
		TArray<GLuint>& Shaders = ShaderNames.FindOrAdd(Type);
		if(!Shaders.Num())
		{
			while(Shaders.Num() < OPENGL_NAME_CACHE_SIZE)
			{
				GLuint Resource = glCreateShader(Type);
				Shaders.Add(Resource);
			}
		}
		return Shaders.Pop();
#else
		return glCreateShader(Type);
#endif
	}
	
	static FORCEINLINE GLuint CreateProgram()
	{
#if USE_OPENGL_NAME_CACHE
		static TArray<GLuint> ProgramNames;
		if(!ProgramNames.Num())
		{
			while(ProgramNames.Num() < OPENGL_NAME_CACHE_SIZE)
			{
				GLuint Resource = glCreateProgram();
				ProgramNames.Add(Resource);
			}
		}
		return ProgramNames.Pop();
#else
		return glCreateProgram();
#endif
	}

	static FORCEINLINE void GenBuffers( GLsizei n, GLuint *buffers)
	{
#if USE_OPENGL_NAME_CACHE
		if ( n < OPENGL_NAME_CACHE_SIZE - NextBufferName)
		{
			FMemory::Memcpy( buffers, &BufferNamesCache[NextBufferName], sizeof(GLuint)*n);
			NextBufferName += n;
		}
		else
		{
			if ( n >= OPENGL_NAME_CACHE_SIZE)
			{
				glGenBuffers( n, buffers);
			}
			else
			{
				GLsizei Leftover = OPENGL_NAME_CACHE_SIZE - NextBufferName;

				FMemory::Memcpy( buffers, &BufferNamesCache[NextBufferName], sizeof(GLuint)*Leftover);

				glGenBuffers( OPENGL_NAME_CACHE_SIZE, BufferNamesCache);

				n -= Leftover;
				buffers += Leftover;

				FMemory::Memcpy( buffers, BufferNamesCache, sizeof(GLuint)*n);
				NextBufferName = n;
			}
		}
#else
		glGenBuffers( n, buffers);
#endif
	}

	static FORCEINLINE void GenTextures( GLsizei n, GLuint *textures)
	{
#if USE_OPENGL_NAME_CACHE
		if ( n < OPENGL_NAME_CACHE_SIZE - NextTextureName)
		{
			FMemory::Memcpy( textures, &TextureNamesCache[NextTextureName], sizeof(GLuint)*n);
			NextTextureName += n;
		}
		else
		{
			if ( n >= OPENGL_NAME_CACHE_SIZE)
			{
				glGenTextures( n, textures);
			}
			else
			{
				GLsizei Leftover = OPENGL_NAME_CACHE_SIZE - NextTextureName;

				FMemory::Memcpy( textures, &TextureNamesCache[NextTextureName], sizeof(GLuint)*Leftover);

				glGenTextures( OPENGL_NAME_CACHE_SIZE, TextureNamesCache);

				n -= Leftover;
				textures += Leftover;

				FMemory::Memcpy( textures, TextureNamesCache, sizeof(GLuint)*n);
				NextTextureName = n;
			}
		}
#else
		glGenTextures( n, textures);
#endif
	}
	
	static FORCEINLINE void CompressedTexSubImage3D(GLenum Target, GLint Level, GLint XOffset, GLint YOffset, GLint ZOffset, GLsizei Width, GLsizei Height, GLsizei Depth, GLenum Format, GLsizei ImageSize, const GLvoid* PixelData)
	{
		glCompressedTexSubImage3D( Target, Level, XOffset, YOffset, ZOffset, Width, Height, Depth, Format, ImageSize, PixelData);
	}

	static FORCEINLINE void GenerateMipmap( GLenum Target )
	{
		glGenerateMipmap( Target);
	}

	static FORCEINLINE const ANSICHAR* GetStringIndexed(GLenum Name, GLuint Index)
	{
		return (const ANSICHAR*)glGetStringi(Name, Index);
	}

	static FORCEINLINE GLuint GetMajorVersion()
	{
		GLint MajorVersion = 0;
		glGetIntegerv(GL_MAJOR_VERSION, &MajorVersion);
		return MajorVersion;
	}

	static FORCEINLINE GLuint GetMinorVersion()
	{
		GLint MinorVersion = 0;
		glGetIntegerv(GL_MINOR_VERSION, &MinorVersion);
		return MinorVersion;
	}
	static FORCEINLINE void ProgramParameter(GLuint Program, GLenum PName, GLint Value)
	{
		check(PName != GL_PROGRAM_SEPARABLE);
		glProgramParameteri(Program, PName, Value);
	}
	static FORCEINLINE void ProgramUniform1i(GLuint Program, GLint Location, GLint V0)
	{
		glUniform1i(Location, V0);
	}
	static FORCEINLINE void ProgramUniform4iv(GLuint Program, GLint Location, GLsizei Count, const GLint *Value)
	{
		glUniform4iv(Location, Count, Value);
	}
	static FORCEINLINE void ProgramUniform4fv(GLuint Program, GLint Location, GLsizei Count, const GLfloat *Value)
	{
		glUniform4fv(Location, Count, Value);
	}
	static FORCEINLINE void ProgramUniform4uiv(GLuint Program, GLint Location, GLsizei Count, const GLuint *Value)
	{
		glUniform4uiv(Location, Count, Value);
	}
	static FORCEINLINE void GetProgramPipelineiv(GLuint Pipeline, GLenum Pname, GLint* Params)
	{
		glGetProgramPipelineiv(Pipeline, Pname, Params);
	}
	static FORCEINLINE void ValidateProgramPipeline(GLuint Pipeline)
	{
		glValidateProgramPipeline(Pipeline);
	}
	static FORCEINLINE void GetProgramPipelineInfoLog(GLuint Pipeline, GLsizei BufSize, GLsizei* Length, GLchar* InfoLog)
	{
		glGetProgramPipelineInfoLog(Pipeline, BufSize, Length, InfoLog);
	}
	static FORCEINLINE bool IsProgramPipeline(GLuint Pipeline)
	{
		return (glIsProgramPipeline(Pipeline) == GL_TRUE);
	}

	static FORCEINLINE ERHIFeatureLevel::Type GetFeatureLevel()
	{
		return ERHIFeatureLevel::ES3_1;
	}

	static FORCEINLINE EShaderPlatform GetShaderPlatform()
	{
		return bAndroidGLESCompatibilityMode ? SP_OPENGL_ES3_1_ANDROID : SP_OPENGL_PCES3_1;
	}

	static FORCEINLINE FString GetAdapterName()
	{
		return ANSI_TO_TCHAR((const ANSICHAR*)glGetString(GL_RENDERER));
	}

	static FPlatformOpenGLDevice*	CreateDevice()	UGL_REQUIRED(NULL)
	static FPlatformOpenGLContext*	CreateContext( FPlatformOpenGLDevice* Device, void* WindowHandle )	UGL_REQUIRED(NULL)

	static void ProcessQueryGLInt();
	static void ProcessExtensions(const FString& ExtensionsString);
	
	static FORCEINLINE int32 GetReadHalfFloatPixelsEnum() { return GL_HALF_FLOAT; }

	static FORCEINLINE bool IsAndroidGLESCompatibilityModeEnabled() { return bAndroidGLESCompatibilityMode; }

	static GLenum GetPlatfrom5551Format() { return GL_UNSIGNED_SHORT_1_5_5_5_REV; }
protected:
	static GLsizei NextTextureName;
	static GLuint TextureNamesCache[OPENGL_NAME_CACHE_SIZE];
	static GLsizei NextBufferName;
	static GLuint BufferNamesCache[OPENGL_NAME_CACHE_SIZE];
	static GLsizei NextPipelineName;
	static GLuint PipelineNamesCache[OPENGL_NAME_CACHE_SIZE];

	static GLint TimestampQueryBits;
	
	static bool bDebugContext;
	static bool bAndroidGLESCompatibilityMode;
};

#endif // UGL_PLATFORM_SUPPORTS_GL3