//----------------------------------------------------------------------------------
// Include
//----------------------------------------------------------------------------------
#include "EffekseerRendererGL.GLExtension.h"
#include "Effekseer.h"

#if defined(__ANDROID__) || defined(__EMSCRIPTEN__)
#include <EGL/egl.h>
#endif

//-----------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------
namespace EffekseerRendererGL
{
namespace GLExt
{
//-----------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------
#if _WIN32

typedef void(EFK_STDCALL* FP_glDeleteBuffers)(GLsizei n, const GLuint* buffers);
typedef GLuint(EFK_STDCALL* FP_glCreateShader)(GLenum type);
typedef void(EFK_STDCALL* FP_glBindBuffer)(GLenum target, GLuint buffer);
typedef void(EFK_STDCALL* FP_glGenBuffers)(GLsizei n, GLuint* buffers);
typedef void(EFK_STDCALL* FP_glBufferData)(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage);

typedef void(EFK_STDCALL* FP_glBlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha);
typedef void(EFK_STDCALL* FP_glBlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);

typedef void(EFK_STDCALL* FP_glBlendEquation)(GLenum mode);

typedef void(EFK_STDCALL* FP_glActiveTexture)(GLenum texture);

typedef void(EFK_STDCALL* FP_glUniform1i)(GLint location, GLint v0);

typedef void(EFK_STDCALL* FP_glShaderSource)(GLuint shader, GLsizei count, const GLchar** strings, const GLint* lengths);

typedef void(EFK_STDCALL* FP_glCompileShader)(GLuint shader);

typedef void(EFK_STDCALL* FP_glGetShaderiv)(GLuint shader, GLenum pname, GLint* param);

typedef GLuint(EFK_STDCALL* FP_glCreateProgram)(void);

typedef void(EFK_STDCALL* FP_glAttachShader)(GLuint program, GLuint shader);

typedef void(EFK_STDCALL* FP_glDeleteProgram)(GLuint program);
typedef void(EFK_STDCALL* FP_glDeleteShader)(GLuint shader);
typedef void(EFK_STDCALL* FP_glLinkProgram)(GLuint program);

typedef void(EFK_STDCALL* FP_glGetProgramiv)(GLuint program, GLenum pname, GLint* param);

typedef void(EFK_STDCALL* FP_glGetShaderInfoLog)(GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog);
typedef void(EFK_STDCALL* FP_glGetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog);

typedef GLint(EFK_STDCALL* FP_glGetAttribLocation)(GLuint program, const GLchar* name);

typedef GLint(EFK_STDCALL* FP_glGetUniformLocation)(GLuint program, const GLchar* name);

typedef void(EFK_STDCALL* FP_glUseProgram)(GLuint program);

typedef void(EFK_STDCALL* FP_glEnableVertexAttribArray)(GLuint index);
typedef void(EFK_STDCALL* FP_glDisableVertexAttribArray)(GLuint index);
typedef void(EFK_STDCALL* FP_glVertexAttribPointer)(
	GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* pointer);
typedef void(EFK_STDCALL* FP_glUniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
typedef void(EFK_STDCALL* FP_glUniform4fv)(GLint location, GLsizei count, const GLfloat* value);
typedef void(EFK_STDCALL* FP_glGenerateMipmap)(GLenum target);
typedef void(EFK_STDCALL* FP_glBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data);

typedef void(EFK_STDCALL* FP_glGenVertexArrays)(GLsizei n, GLuint* arrays);
typedef void(EFK_STDCALL* FP_glDeleteVertexArrays)(GLsizei n, const GLuint* arrays);
typedef void(EFK_STDCALL* FP_glBindVertexArray)(GLuint array);

typedef void(EFK_STDCALL* FP_glGenSamplers)(GLsizei n, GLuint* samplers);
typedef void(EFK_STDCALL* FP_glDeleteSamplers)(GLsizei n, const GLuint* samplers);
typedef void(EFK_STDCALL* FP_glSamplerParameteri)(GLuint sampler, GLenum pname, GLint param);
typedef void(EFK_STDCALL* FP_glBindSampler)(GLuint unit, GLuint sampler);

typedef void*(EFK_STDCALL* FP_glMapBuffer)(GLenum target, GLenum access);
typedef void*(EFK_STDCALL* FP_glMapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
typedef GLboolean(EFK_STDCALL* FP_glUnmapBuffer)(GLenum target);

typedef void(EFK_STDCALL* FP_glDrawElementsInstanced)(GLenum mode,
													  GLsizei count,
													  GLenum type,
													  const void* indices,
													  GLsizei primcount);

typedef void(EFK_STDCALL* FP_glCompressedTexImage2D)(
	GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data);

typedef void(EFK_STDCALL* FP_glGenFramebuffers)(GLsizei n, GLuint* ids);

typedef void(EFK_STDCALL* FP_glBindFramebuffer)(GLenum target, GLuint framebuffer);

typedef void(EFK_STDCALL* FP_glDeleteFramebuffers)(GLsizei n, GLuint* framebuffers);

typedef void(EFK_STDCALL* FP_glFramebufferTexture2D)(GLenum target,
													 GLenum attachment,
													 GLenum textarget,
													 GLuint texture,
													 GLint level);

typedef void(EFK_STDCALL* FP_glGenRenderbuffers)(GLsizei n, GLuint* renderbuffers);

typedef void(EFK_STDCALL* FP_glBindRenderbuffer)(GLenum target, GLuint renderbuffer);

typedef void(EFK_STDCALL* FP_glDeleteRenderbuffers)(GLsizei n, GLuint* renderbuffers);

typedef void(EFK_STDCALL* FP_glRenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);

typedef void(EFK_STDCALL* FP_glDrawBuffers)(GLsizei n, const GLenum* bufs);

typedef void(EFK_STDCALL* FP_glTexImage3D)(GLenum target,
										   GLint level,
										   GLint internalformat,
										   GLsizei width,
										   GLsizei height,
										   GLsizei depth,
										   GLint border,
										   GLenum format,
										   GLenum type,
										   const void* data);

typedef void(EFK_STDCALL* FP_glCopyTexSubImage3D)(GLenum target,
												  GLint level,
												  GLint xoffset,
												  GLint yoffset,
												  GLint zoffset,
												  GLint x,
												  GLint y,
												  GLsizei width,
												  GLsizei height);

static FP_glDeleteBuffers g_glDeleteBuffers = nullptr;
static FP_glCreateShader g_glCreateShader = nullptr;
static FP_glBindBuffer g_glBindBuffer = nullptr;
static FP_glGenBuffers g_glGenBuffers = nullptr;
static FP_glBufferData g_glBufferData = nullptr;
static FP_glBlendEquationSeparate g_glBlendEquationSeparate = nullptr;
static FP_glBlendFuncSeparate g_glBlendFuncSeparate = nullptr;
static FP_glBlendEquation g_glBlendEquation = nullptr;
static FP_glActiveTexture g_glActiveTexture = nullptr;
static FP_glUniform1i g_glUniform1i = nullptr;
static FP_glShaderSource g_glShaderSource = nullptr;
static FP_glCompileShader g_glCompileShader = nullptr;
static FP_glGetShaderiv g_glGetShaderiv = nullptr;
static FP_glCreateProgram g_glCreateProgram = nullptr;
static FP_glAttachShader g_glAttachShader = nullptr;
static FP_glDeleteProgram g_glDeleteProgram = nullptr;
static FP_glDeleteShader g_glDeleteShader = nullptr;
static FP_glLinkProgram g_glLinkProgram = nullptr;
static FP_glGetProgramiv g_glGetProgramiv = nullptr;
static FP_glGetShaderInfoLog g_glGetShaderInfoLog = nullptr;
static FP_glGetProgramInfoLog g_glGetProgramInfoLog = nullptr;
static FP_glGetAttribLocation g_glGetAttribLocation = nullptr;
static FP_glGetUniformLocation g_glGetUniformLocation = nullptr;
static FP_glUseProgram g_glUseProgram = nullptr;
static FP_glEnableVertexAttribArray g_glEnableVertexAttribArray = nullptr;
static FP_glDisableVertexAttribArray g_glDisableVertexAttribArray = nullptr;
static FP_glVertexAttribPointer g_glVertexAttribPointer = nullptr;
static FP_glUniformMatrix4fv g_glUniformMatrix4fv = nullptr;
static FP_glUniform4fv g_glUniform4fv = nullptr;
static FP_glGenerateMipmap g_glGenerateMipmap = nullptr;
static FP_glBufferSubData g_glBufferSubData = nullptr;
static FP_glGenVertexArrays g_glGenVertexArrays = nullptr;
static FP_glDeleteVertexArrays g_glDeleteVertexArrays = nullptr;
static FP_glBindVertexArray g_glBindVertexArray = nullptr;
static FP_glGenSamplers g_glGenSamplers = nullptr;
static FP_glDeleteSamplers g_glDeleteSamplers = nullptr;
static FP_glSamplerParameteri g_glSamplerParameteri = nullptr;
static FP_glBindSampler g_glBindSampler = nullptr;

static FP_glMapBuffer g_glMapBuffer = nullptr;
static FP_glMapBufferRange g_glMapBufferRange = nullptr;
static FP_glUnmapBuffer g_glUnmapBuffer = nullptr;

static FP_glDrawElementsInstanced g_glDrawElementsInstanced = nullptr;

static FP_glCompressedTexImage2D g_glCompressedTexImage2D = nullptr;

static FP_glGenFramebuffers g_glGenFramebuffers = nullptr;

static FP_glBindFramebuffer g_glBindFramebuffer = nullptr;

static FP_glGenRenderbuffers g_glGenRenderbuffers = nullptr;

static FP_glBindRenderbuffer g_glBindRenderbuffer = nullptr;

static FP_glDeleteFramebuffers g_glDeleteFramebuffers = nullptr;

static FP_glFramebufferTexture2D g_glFramebufferTexture2D = nullptr;

static FP_glDeleteRenderbuffers g_glDeleteRenderbuffers = nullptr;

static FP_glRenderbufferStorageMultisample g_glRenderbufferStorageMultisample = nullptr;

static FP_glDrawBuffers g_glDrawBuffers = nullptr;

static FP_glTexImage3D g_glTexImage3D = nullptr;

static FP_glCopyTexSubImage3D g_glCopyTexSubImage3D = nullptr;

#elif defined(__EFFEKSEER_RENDERER_GLES2__)

typedef void (*FP_glGenVertexArraysOES)(GLsizei n, GLuint* arrays);
typedef void (*FP_glDeleteVertexArraysOES)(GLsizei n, const GLuint* arrays);
typedef void (*FP_glBindVertexArrayOES)(GLuint array);

typedef void* (*FP_glMapBufferOES)(GLenum target, GLenum access);
typedef void* (*FP_glMapBufferRangeEXT)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
typedef GLboolean (*FP_glUnmapBufferOES)(GLenum target);

#ifdef EMSCRIPTEN
typedef void(EFK_STDCALL* FP_glDrawElementsInstancedANGLE)(GLenum mode,
														   GLsizei count,
														   GLenum type,
														   const void* indices,
														   GLsizei primcount);

#endif

static FP_glGenVertexArraysOES g_glGenVertexArraysOES = nullptr;
static FP_glDeleteVertexArraysOES g_glDeleteVertexArraysOES = nullptr;
static FP_glBindVertexArrayOES g_glBindVertexArrayOES = nullptr;

static FP_glMapBufferOES g_glMapBufferOES = nullptr;
static FP_glMapBufferRangeEXT g_glMapBufferRangeEXT = nullptr;
static FP_glUnmapBufferOES g_glUnmapBufferOES = nullptr;

#ifdef EMSCRIPTEN
static FP_glDrawElementsInstancedANGLE g_glDrawElementsInstancedANGLE = nullptr;
#endif

#endif

static bool g_isInitialized = false;
static bool g_isSupportedVertexArray = false;
static bool g_isSurrpotedBufferRange = false;
static bool g_isSurrpotedMapBuffer = false;
static OpenGLDeviceType g_deviceType = OpenGLDeviceType::OpenGL2;

#if _WIN32
#define GET_PROC_REQ(name)                                                                       \
	g_##name = (FP_##name)wglGetProcAddress(#name);                                              \
	if (g_##name == nullptr)                                                                     \
	{                                                                                            \
		Effekseer::Log(Effekseer::LogType::Error, "Failed to get proc : " + std::string(#name)); \
		return false;                                                                            \
	}
#elif defined(__EFFEKSEER_RENDERER_GLES2__) || defined(__EFFEKSEER_RENDERER_GLES3__)
#define GET_PROC_REQ(name)                                                                       \
	g_##name = (FP_##name)eglGetProcAddress(#name);                                              \
	if (g_##name == nullptr)                                                                     \
	{                                                                                            \
		Effekseer::Log(Effekseer::LogType::Error, "Failed to get proc : " + std::string(#name)); \
		return false;                                                                            \
	}
#endif

#if _WIN32
#define GET_PROC(name)                                                                             \
	g_##name = (FP_##name)wglGetProcAddress(#name);                                                \
	if (g_##name == nullptr)                                                                       \
	{                                                                                              \
		Effekseer::Log(Effekseer::LogType::Warning, "Failed to get proc : " + std::string(#name)); \
	}
#elif defined(__EFFEKSEER_RENDERER_GLES2__) || defined(__EFFEKSEER_RENDERER_GLES3__)
#define GET_PROC(name)                                                                             \
	g_##name = (FP_##name)eglGetProcAddress(#name);                                                \
	if (g_##name == nullptr)                                                                       \
	{                                                                                              \
		Effekseer::Log(Effekseer::LogType::Warning, "Failed to get proc : " + std::string(#name)); \
	}
#endif

OpenGLDeviceType GetDeviceType()
{
	return g_deviceType;
}

bool Initialize(OpenGLDeviceType deviceType, bool isExtensionsEnabled)
{
	if (g_isInitialized)
		return true;
	g_deviceType = deviceType;
#if 0
	GET_PROC_REQ(glDeleteBuffers);
	GET_PROC_REQ(glCreateShader);
	GET_PROC_REQ(glBindBuffer);
	GET_PROC_REQ(glGenBuffers);
	GET_PROC_REQ(glBufferData);
	GET_PROC_REQ(glBlendEquationSeparate);
	GET_PROC_REQ(glBlendFuncSeparate);
	GET_PROC_REQ(glBlendEquation);
	GET_PROC_REQ(glActiveTexture);
	GET_PROC_REQ(glUniform1i);
	GET_PROC_REQ(glShaderSource);

	GET_PROC_REQ(glCompileShader);
	GET_PROC_REQ(glGetShaderiv);
	GET_PROC_REQ(glCreateProgram);

	GET_PROC_REQ(glAttachShader);
	GET_PROC_REQ(glDeleteProgram);
	GET_PROC_REQ(glDeleteShader);

	GET_PROC_REQ(glLinkProgram);
	GET_PROC_REQ(glGetProgramiv);
	GET_PROC_REQ(glGetShaderInfoLog);

	GET_PROC_REQ(glGetProgramInfoLog);
	GET_PROC_REQ(glGetAttribLocation);
	GET_PROC_REQ(glGetUniformLocation);

	GET_PROC_REQ(glUseProgram);
	GET_PROC_REQ(glEnableVertexAttribArray);
	GET_PROC_REQ(glDisableVertexAttribArray);

	GET_PROC_REQ(glVertexAttribPointer);
	GET_PROC_REQ(glUniformMatrix4fv);
	GET_PROC_REQ(glUniform4fv);

	GET_PROC_REQ(glGenerateMipmap);
	GET_PROC_REQ(glBufferSubData);

	GET_PROC_REQ(glGenVertexArrays);
	GET_PROC_REQ(glDeleteVertexArrays);
	GET_PROC_REQ(glBindVertexArray);

	GET_PROC_REQ(glGenSamplers);
	GET_PROC_REQ(glDeleteSamplers);
	GET_PROC_REQ(glSamplerParameteri);
	GET_PROC_REQ(glBindSampler);

	GET_PROC_REQ(glMapBuffer);
	GET_PROC_REQ(glMapBufferRange);
	GET_PROC_REQ(glUnmapBuffer);

	GET_PROC_REQ(glDrawElementsInstanced);

	GET_PROC_REQ(glCompressedTexImage2D);

	GET_PROC_REQ(glGenFramebuffers);

	GET_PROC_REQ(glBindFramebuffer);

	GET_PROC_REQ(glDeleteFramebuffers);

	GET_PROC(glFramebufferTexture2D);

	GET_PROC(glGenRenderbuffers);

	GET_PROC(glBindRenderbuffer);

	GET_PROC(glDeleteRenderbuffers);

	GET_PROC(glRenderbufferStorageMultisample);

	GET_PROC_REQ(glDrawBuffers);

	GET_PROC_REQ(glTexImage3D);

	GET_PROC_REQ(glCopyTexSubImage3D);

	g_isSupportedVertexArray = (g_glGenVertexArrays && g_glDeleteVertexArrays && g_glBindVertexArray);
	g_isSurrpotedBufferRange = (g_glMapBufferRange && g_glUnmapBuffer);
	g_isSurrpotedMapBuffer = (g_glMapBuffer && g_glUnmapBuffer);

#endif

#if defined(__EFFEKSEER_RENDERER_GLES2__)

#if defined(__APPLE__)
	g_glGenVertexArraysOES = ::glGenVertexArraysOES;
	g_glDeleteVertexArraysOES = ::glDeleteVertexArraysOES;
	g_glBindVertexArrayOES = ::glBindVertexArrayOES;
	g_isSupportedVertexArray = true;

	g_glMapBufferRangeEXT = ::glMapBufferRangeEXT;
	g_glMapBufferOES = ::glMapBufferOES;
	g_glUnmapBufferOES = ::glUnmapBufferOES;
	g_isSurrpotedBufferRange = true;
	g_isSurrpotedMapBuffer = true;
#else
	char* glExtensions = (char*)glGetString(GL_EXTENSIONS);

	if (isExtensionsEnabled)
	{
		GET_PROC(glGenVertexArraysOES);
		GET_PROC(glDeleteVertexArraysOES);
		GET_PROC(glBindVertexArrayOES);
	}

#if defined(__EMSCRIPTEN__)
	if (isExtensionsEnabled)
	{
		GET_PROC(glDrawElementsInstancedANGLE);
	}

	g_isSupportedVertexArray = (g_glGenVertexArraysOES && g_glDeleteVertexArraysOES && g_glBindVertexArrayOES &&
								((glExtensions && strstr(glExtensions, "OES_vertex_array_object")) ? true : false));
#else
	g_isSupportedVertexArray = (g_glGenVertexArraysOES && g_glDeleteVertexArraysOES && g_glBindVertexArrayOES &&
								((glExtensions && strstr(glExtensions, "GL_OES_vertex_array_object")) ? true : false));
#endif

	// Some smartphone causes segmentation fault.
	// GET_PROC(glMapBufferRangeEXT);

#ifdef EMSCRIPTEN
	g_isSurrpotedBufferRange = false;
	g_isSurrpotedMapBuffer = false;
#else
	if (isExtensionsEnabled)
	{
		GET_PROC(glMapBufferOES);
		GET_PROC(glUnmapBufferOES);
	}
	g_isSurrpotedBufferRange = (g_glMapBufferRangeEXT && g_glUnmapBufferOES);
	g_isSurrpotedMapBuffer =
		(g_glMapBufferOES && g_glUnmapBufferOES && ((glExtensions && strstr(glExtensions, "GL_OES_mapbuffer")) ? true : false));
#endif

#endif

#else
	if (deviceType == OpenGLDeviceType::OpenGL3 || deviceType == OpenGLDeviceType::OpenGLES3)
	{
		g_isSupportedVertexArray = true;
		g_isSurrpotedBufferRange = true;
	}
	if (deviceType == OpenGLDeviceType::OpenGL3)
	{
		g_isSurrpotedMapBuffer = true;
	}

#endif

	g_isInitialized = true;
	return true;
}

bool IsSupportedVertexArray()
{
	return g_isSupportedVertexArray;
}

bool IsSupportedBufferRange()
{
	return g_isSurrpotedBufferRange;
}

bool IsSupportedMapBuffer()
{
	return g_isSurrpotedMapBuffer;
}

void MakeMapBufferInvalid()
{
	g_isSurrpotedMapBuffer = false;
}

//void glDeleteBuffers(GLsizei n, const GLuint* buffers)
//{
//#if _WIN32
//	g_glDeleteBuffers(n, buffers);
//#else
//	::glDeleteBuffers(n, buffers);
//#endif
//}
//
//GLuint glCreateShader(GLenum type)
//{
//#if _WIN32
//	return g_glCreateShader(type);
//#else
//	return ::glCreateShader(type);
//#endif
//}
//
//void glBindBuffer(GLenum target, GLuint buffer)
//{
//#if _WIN32
//	return g_glBindBuffer(target, buffer);
//#else
//	return ::glBindBuffer(target, buffer);
//#endif
//}
//
//void glGenBuffers(GLsizei n, GLuint* buffers)
//{
//#if _WIN32
//	g_glGenBuffers(n, buffers);
//#else
//	::glGenBuffers(n, buffers);
//#endif
//}
//
//void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
//{
//#if _WIN32
//	g_glBufferData(target, size, data, usage);
//#else
//	::glBufferData(target, size, data, usage);
//#endif
//}
//
//void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
//{
//#if _WIN32
//	g_glBlendEquationSeparate(modeRGB, modeAlpha);
//#else
//	::glBlendEquationSeparate(modeRGB, modeAlpha);
//#endif
//}
//
//void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
//{
//#if _WIN32
//	g_glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
//#else
//	::glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
//#endif
//}
//
//void glBlendEquation(GLenum mode)
//{
//#if _WIN32
//	g_glBlendEquation(mode);
//#else
//	::glBlendEquation(mode);
//#endif
//}
//
//void glActiveTexture(GLenum texture)
//{
//#if _WIN32
//	g_glActiveTexture(texture);
//#else
//	::glActiveTexture(texture);
//#endif
//}
//
//void glUniform1i(GLint location, GLint v0)
//{
//#if _WIN32
//	g_glUniform1i(location, v0);
//#else
//	::glUniform1i(location, v0);
//#endif
//}
//
//void glShaderSource(GLuint shader, GLsizei count, const GLchar** strings, const GLint* lengths)
//{
//#if _WIN32
//	g_glShaderSource(shader, count, strings, lengths);
//#else
//	::glShaderSource(shader, count, strings, lengths);
//#endif
//}
//
//void glCompileShader(GLuint shader)
//{
//#if _WIN32
//	g_glCompileShader(shader);
//#else
//	::glCompileShader(shader);
//#endif
//}
//
//void glGetShaderiv(GLuint shader, GLenum pname, GLint* param)
//{
//#if _WIN32
//	g_glGetShaderiv(shader, pname, param);
//#else
//	::glGetShaderiv(shader, pname, param);
//#endif
//}
//
//GLuint glCreateProgram(void)
//{
//#if _WIN32
//	return g_glCreateProgram();
//#else
//	return ::glCreateProgram();
//#endif
//}
//
//void glAttachShader(GLuint program, GLuint shader)
//{
//#if _WIN32
//	g_glAttachShader(program, shader);
//#else
//	::glAttachShader(program, shader);
//#endif
//}
//
//void glDeleteProgram(GLuint program)
//{
//#if _WIN32
//	g_glDeleteProgram(program);
//#else
//	::glDeleteProgram(program);
//#endif
//}
//
//void glDeleteShader(GLuint shader)
//{
//#if _WIN32
//	g_glDeleteShader(shader);
//#else
//	::glDeleteShader(shader);
//#endif
//}
//
//void glLinkProgram(GLuint program)
//{
//#if _WIN32
//	g_glLinkProgram(program);
//#else
//	::glLinkProgram(program);
//#endif
//}
//
//void glGetProgramiv(GLuint program, GLenum pname, GLint* param)
//{
//#if _WIN32
//	g_glGetProgramiv(program, pname, param);
//#else
//	::glGetProgramiv(program, pname, param);
//#endif
//}
//
//void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog)
//{
//#if _WIN32
//	g_glGetShaderInfoLog(shader, bufSize, length, infoLog);
//#else
//	::glGetShaderInfoLog(shader, bufSize, length, infoLog);
//#endif
//}
//
//void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog)
//{
//#if _WIN32
//	g_glGetProgramInfoLog(program, bufSize, length, infoLog);
//#else
//	::glGetProgramInfoLog(program, bufSize, length, infoLog);
//#endif
//}
//
//GLint glGetAttribLocation(GLuint program, const GLchar* name)
//{
//#if _WIN32
//	return g_glGetAttribLocation(program, name);
//#else
//	return ::glGetAttribLocation(program, name);
//#endif
//}
//
//GLint glGetUniformLocation(GLuint program, const GLchar* name)
//{
//#if _WIN32
//	return g_glGetUniformLocation(program, name);
//#else
//	return ::glGetUniformLocation(program, name);
//#endif
//}
//
//void glUseProgram(GLuint program)
//{
//#if _WIN32
//	g_glUseProgram(program);
//#else
//	::glUseProgram(program);
//#endif
//}
//
//void glEnableVertexAttribArray(GLuint index)
//{
//#if _WIN32
//	g_glEnableVertexAttribArray(index);
//#else
//	::glEnableVertexAttribArray(index);
//#endif
//}
//
//void glDisableVertexAttribArray(GLuint index)
//{
//#if _WIN32
//	g_glDisableVertexAttribArray(index);
//#else
//	::glDisableVertexAttribArray(index);
//#endif
//}
//
//void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* pointer)
//{
//#if _WIN32
//	g_glVertexAttribPointer(index, size, type, normalized, stride, pointer);
//#else
//	::glVertexAttribPointer(index, size, type, normalized, stride, pointer);
//#endif
//}
//
//void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
//{
//#if _WIN32
//	g_glUniformMatrix4fv(location, count, transpose, value);
//#else
//	::glUniformMatrix4fv(location, count, transpose, value);
//#endif
//}
//
//void glUniform4fv(GLint location, GLsizei count, const GLfloat* value)
//{
//#if _WIN32
//	g_glUniform4fv(location, count, value);
//#else
//	::glUniform4fv(location, count, value);
//#endif
//}
//
//void glGenerateMipmap(GLenum target)
//{
//#if _WIN32
//	g_glGenerateMipmap(target);
//#else
//	::glGenerateMipmap(target);
//#endif
//}
//
//void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
//{
//#if _WIN32
//	g_glBufferSubData(target, offset, size, data);
//#else
//	::glBufferSubData(target, offset, size, data);
//#endif
//}
//
//void glGenVertexArrays(GLsizei n, GLuint* arrays)
//{
//#if _WIN32
//	g_glGenVertexArrays(n, arrays);
//#elif defined(__EFFEKSEER_RENDERER_GLES2__)
//	g_glGenVertexArraysOES(n, arrays);
//#else
//	::glGenVertexArrays(n, arrays);
//#endif
//}
//
//void glDeleteVertexArrays(GLsizei n, const GLuint* arrays)
//{
//#if _WIN32
//	g_glDeleteVertexArrays(n, arrays);
//#elif defined(__EFFEKSEER_RENDERER_GLES2__)
//	g_glDeleteVertexArraysOES(n, arrays);
//#else
//	::glDeleteVertexArrays(n, arrays);
//#endif
//}
//
//void glBindVertexArray(GLuint array)
//{
//#if _WIN32
//	g_glBindVertexArray(array);
//#elif defined(__EFFEKSEER_RENDERER_GLES2__)
//	g_glBindVertexArrayOES(array);
//#else
//	::glBindVertexArray(array);
//#endif
//}
//
//void glGenSamplers(GLsizei n, GLuint* samplers)
//{
//#if _WIN32
//	g_glGenSamplers(n, samplers);
//#elif defined(__EFFEKSEER_RENDERER_GLES2__) || defined(__EFFEKSEER_RENDERER_GL2__)
//#else
//	::glGenSamplers(n, samplers);
//#endif
//}
//
//void glDeleteSamplers(GLsizei n, const GLuint* samplers)
//{
//#if _WIN32
//	g_glDeleteSamplers(n, samplers);
//#elif defined(__EFFEKSEER_RENDERER_GLES2__) || defined(__EFFEKSEER_RENDERER_GL2__)
//#else
//	::glDeleteSamplers(n, samplers);
//#endif
//}
//
//void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
//{
//#if _WIN32
//	g_glSamplerParameteri(sampler, pname, param);
//#elif defined(__EFFEKSEER_RENDERER_GLES2__) || defined(__EFFEKSEER_RENDERER_GL2__)
//#else
//	::glSamplerParameteri(sampler, pname, param);
//#endif
//}
//
//void glBindSampler(GLuint unit, GLuint sampler)
//{
//#if _WIN32
//	g_glBindSampler(unit, sampler);
//#elif defined(__EFFEKSEER_RENDERER_GLES2__) || defined(__EFFEKSEER_RENDERER_GL2__)
//#else
//	::glBindSampler(unit, sampler);
//#endif
//}
//
//void* glMapBuffer(GLenum target, GLenum access)
//{
//#if _WIN32
//	return g_glMapBuffer(target, access);
//#elif defined(__EFFEKSEER_RENDERER_GLES2__)
//	return g_glMapBufferOES(target, access);
//#elif defined(__EFFEKSEER_RENDERER_GLES3__)
//	return nullptr;
//#else
//	return ::glMapBuffer(target, access);
//#endif
//}
//
//void* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
//{
//#if _WIN32
//	return g_glMapBufferRange(target, offset, length, access);
//#elif defined(__EFFEKSEER_RENDERER_GLES2__)
//	return g_glMapBufferRangeEXT(target, offset, length, access);
//#else
//
//#if defined(__APPLE__)
//
//#if defined(GL_ARB_map_buffer_range)
//	return ::glMapBufferRange(target, offset, length, access);
//#else
//	return nullptr;
//#endif
//
//#else
//	return ::glMapBufferRange(target, offset, length, access);
//#endif
//
//#endif
//}
//
//GLboolean glUnmapBuffer(GLenum target)
//{
//	return glUnmapBuffer(target);
//}
//
//void glDrawElementsInstanced(GLenum mode,
//							 GLsizei count,
//							 GLenum type,
//							 const void* indices,
//							 GLsizei primcount)
//{
//	return ::glDrawElementsInstanced(mode, count, type, indices, primcount);
//}
//
//void glCompressedTexImage2D(
//	GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
//{
//	::glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
//}
//
//void glGenFramebuffers(GLsizei n, GLuint* ids)
//{
//	::glGenFramebuffers(n, ids);
//}
//
//void glBindFramebuffer(GLenum target, GLuint framebuffer)
//{
//	glBindFramebuffer(target, framebuffer);
//}
//
//void glDeleteFramebuffers(GLsizei n, GLuint* framebuffers)
//{
//	::glDeleteFramebuffers(n, framebuffers);
//}
//
//void glFramebufferTexture2D(GLenum target,
//							GLenum attachment,
//							GLenum textarget,
//							GLuint texture,
//							GLint level)
//{
//	::glFramebufferTexture2D(target,
//							 attachment,
//							 textarget,
//							 texture,
//							 level);
//}
//
//void glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
//{
//    glGenRenderbuffers(n, renderbuffers);
//}
//
//void glBindRenderbuffer(GLenum target, GLuint renderbuffer)
//{
//#if _WIN32
//	g_glBindRenderbuffer(target, renderbuffer);
//#elif defined(__EFFEKSEER_RENDERER_GLES2__) || defined(__EFFEKSEER_RENDERER_GL2__)
//#else
//	::glBindRenderbuffer(target, renderbuffer);
//#endif
//}
//
//void glDeleteRenderbuffers(GLsizei n, GLuint* renderbuffers)
//{
//#if _WIN32
//	g_glDeleteRenderbuffers(n, renderbuffers);
//#elif defined(__EFFEKSEER_RENDERER_GLES2__) || defined(__EFFEKSEER_RENDERER_GL2__)
//#else
//	::glDeleteRenderbuffers(n, renderbuffers);
//#endif
//}
//
//void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
//{
//#if _WIN32
//	g_glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
//#elif defined(__EFFEKSEER_RENDERER_GLES2__) || defined(__EFFEKSEER_RENDERER_GL2__)
//#else
//	::glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
//#endif
//}
//
//void glDrawBuffers(GLsizei n, const GLenum* bufs)
//{
//#if _WIN32
//	g_glDrawBuffers(n, bufs);
//#elif defined(__EFFEKSEER_RENDERER_GLES2__) || defined(__EFFEKSEER_RENDERER_GL2__)
//#else
//	::glDrawBuffers(n, bufs);
//#endif
//}
//
//void glTexImage3D(GLenum target,
//				  GLint level,
//				  GLint internalformat,
//				  GLsizei width,
//				  GLsizei height,
//				  GLsizei depth,
//				  GLint border,
//				  GLenum format,
//				  GLenum type,
//				  const void* data)
//{
//#if _WIN32
//	g_glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, data);
//#elif defined(__EFFEKSEER_RENDERER_GLES2__) || defined(__EFFEKSEER_RENDERER_GL2__)
//#else
//	::glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, data);
//#endif
//}
//
//void glCopyTexSubImage3D(GLenum target,
//						 GLint level,
//						 GLint xoffset,
//						 GLint yoffset,
//						 GLint zoffset,
//						 GLint x,
//						 GLint y,
//						 GLsizei width,
//						 GLsizei height)
//{
//#if _WIN32
//	g_glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
//#elif defined(__EFFEKSEER_RENDERER_GLES2__) || defined(__EFFEKSEER_RENDERER_GL2__)
//#else
//	::glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
//#endif
//}

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
} // namespace GLExt
} // namespace EffekseerRendererGL