libs/hwui/debug/nullgles.cpp - platform/frameworks/base - Gitiles

 /*
  * Copyright(C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0(the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "unwrap_gles.h"

 #include <GLES3/gl3.h>
 #include <GLES2/gl2ext.h>

 #include <stdlib.h>
 #include <string.h>

 struct {
     GLboolean scissorEnabled;
 } gState;

 void glGenCommon(GLsizei n, GLuint *buffers) {
     static GLuint nextId = 0;
     int i;
     for(i = 0; i < n; i++) {
         buffers[i] = ++nextId;
     }
 }

 void glGenBuffers(GLsizei n, GLuint *buffers) {
     glGenCommon(n, buffers);
 }

 void glGenFramebuffers(GLsizei n, GLuint *framebuffers) {
     glGenCommon(n, framebuffers);
 }

 void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers) {
     glGenCommon(n, renderbuffers);
 }

 void glGenTextures(GLsizei n, GLuint *textures) {
     glGenCommon(n, textures);
 }

 GLuint glCreateProgram(void) {
     static GLuint nextProgram = 0;
     return ++nextProgram;
 }

 GLuint glCreateShader(GLenum type) {
     static GLuint nextShader = 0;
     return ++nextShader;
 }

 void glGetProgramiv(GLuint program, GLenum pname, GLint *params) {
     switch (pname) {
     case GL_DELETE_STATUS:
     case GL_LINK_STATUS:
     case GL_VALIDATE_STATUS:
         *params = GL_TRUE;
         break;
     case GL_INFO_LOG_LENGTH:
         *params = 16;
         break;
     }
 }

 void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog) {
     *length = snprintf(infoLog, bufSize, "success");
     if (*length >= bufSize) {
         *length = bufSize - 1;
     }
 }

 void glGetShaderiv(GLuint shader, GLenum pname, GLint *params) {
     switch (pname) {
     case GL_COMPILE_STATUS:
     case GL_DELETE_STATUS:
         *params = GL_TRUE;
     }
 }

 void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog) {
     *length = snprintf(infoLog, bufSize, "success");
     if (*length >= bufSize) {
         *length = bufSize - 1;
     }
 }

 void setBooleanState(GLenum cap, GLboolean value) {
     switch (cap) {
     case GL_SCISSOR_TEST:
         gState.scissorEnabled = value;
         break;
     }
 }

 void glEnable(GLenum cap) {
     setBooleanState(cap, GL_TRUE);
 }

 void glDisable(GLenum cap) {
     setBooleanState(cap, GL_FALSE);
 }

 GLboolean glIsEnabled(GLenum cap) {
     switch (cap) {
     case GL_SCISSOR_TEST:
         return gState.scissorEnabled;
     default:
         return GL_FALSE;
     }
 }

 void glGetIntegerv(GLenum pname, GLint *data) {
     switch (pname) {
     case GL_MAX_TEXTURE_SIZE:
         *data = 2048;
         break;
     case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
         *data = 4;
         break;
     default:
         *data = 0;
     }
 }

 const char* getString(GLenum name) {
     switch (name) {
     case GL_VENDOR:
         return "android";
     case GL_RENDERER:
         return "null";
     case GL_VERSION:
         return "OpenGL ES 2.0 rev1";
     case GL_SHADING_LANGUAGE_VERSION:
         return "OpenGL ES GLSL ES 2.0 rev1";
     case GL_EXTENSIONS:
     default:
         return "";
     }
 }

 const GLubyte* glGetString(GLenum name) {
     return (GLubyte*) getString(name);
 }

 void glActiveTexture(GLenum texture) {}
 void glAttachShader(GLuint program, GLuint shader) {}
 void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name) {}
 void glBindBuffer(GLenum target, GLuint buffer) {}
 void glBindFramebuffer(GLenum target, GLuint framebuffer) {}
 void glBindRenderbuffer(GLenum target, GLuint renderbuffer) {}
 void glBindTexture(GLenum target, GLuint texture) {}
 void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {}
 void glBlendEquation(GLenum mode) {}
 void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {}
 void glBlendFunc(GLenum sfactor, GLenum dfactor) {}
 void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {}
 void glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage) {}
 void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data) {}
 void glClear(GLbitfield mask) {}
 void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {}
 void glClearDepthf(GLfloat d) {}
 void glClearStencil(GLint s) {}
 void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {}
 void glCompileShader(GLuint shader) {}
 void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data) {}
 void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data) {}
 void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {}
 void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {}
 void glCullFace(GLenum mode) {}
 void glDeleteBuffers(GLsizei n, const GLuint *buffers) {}
 void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers) {}
 void glDeleteProgram(GLuint program) {}
 void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers) {}
 void glDeleteShader(GLuint shader) {}
 void glDeleteTextures(GLsizei n, const GLuint *textures) {}
 void glDepthFunc(GLenum func) {}
 void glDepthMask(GLboolean flag) {}
 void glDepthRangef(GLfloat n, GLfloat f) {}
 void glDetachShader(GLuint program, GLuint shader) {}
 void glDisableVertexAttribArray(GLuint index) {}
 void glDrawArrays(GLenum mode, GLint first, GLsizei count) {}
 void glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) {}
 void glEnableVertexAttribArray(GLuint index) {}
 void glFinish(void) {}
 void glFlush(void) {}
 void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {}
 void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {}
 void glFrontFace(GLenum mode) {}
 void glGenerateMipmap(GLenum target) {}
 GLint glGetAttribLocation(GLuint program, const GLchar *name) { return 1; }
 GLenum glGetError(void) { return GL_NO_ERROR; }
 GLint glGetUniformLocation(GLuint program, const GLchar *name) { return 2; }
 void glHint(GLenum target, GLenum mode) {}
 void glLineWidth(GLfloat width) {}
 void glLinkProgram(GLuint program) {}
 void glPixelStorei(GLenum pname, GLint param) {}
 void glPolygonOffset(GLfloat factor, GLfloat units) {}
 void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels) {}
 void glReleaseShaderCompiler(void) {}
 void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {}
 void glSampleCoverage(GLfloat value, GLboolean invert) {}
 void glScissor(GLint x, GLint y, GLsizei width, GLsizei height) {}
 void glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length) {}
 void glShaderSource(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length) {}
 void glStencilFunc(GLenum func, GLint ref, GLuint mask) {}
 void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) {}
 void glStencilMask(GLuint mask) {}
 void glStencilMaskSeparate(GLenum face, GLuint mask) {}
 void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {}
 void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) {}
 void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) {}
 void glTexParameterf(GLenum target, GLenum pname, GLfloat param) {}
 void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) {}
 void glTexParameteri(GLenum target, GLenum pname, GLint param) {}
 void glTexParameteriv(GLenum target, GLenum pname, const GLint *params) {}
 void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) {}
 void glUniform1f(GLint location, GLfloat v0) {}
 void glUniform1fv(GLint location, GLsizei count, const GLfloat *value) {}
 void glUniform1i(GLint location, GLint v0) {}
 void glUniform1iv(GLint location, GLsizei count, const GLint *value) {}
 void glUniform2f(GLint location, GLfloat v0, GLfloat v1) {}
 void glUniform2fv(GLint location, GLsizei count, const GLfloat *value) {}
 void glUniform2i(GLint location, GLint v0, GLint v1) {}
 void glUniform2iv(GLint location, GLsizei count, const GLint *value) {}
 void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {}
 void glUniform3fv(GLint location, GLsizei count, const GLfloat *value) {}
 void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2) {}
 void glUniform3iv(GLint location, GLsizei count, const GLint *value) {}
 void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {}
 void glUniform4fv(GLint location, GLsizei count, const GLfloat *value) {}
 void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {}
 void glUniform4iv(GLint location, GLsizei count, const GLint *value) {}
 void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {}
 void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {}
 void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {}
 void glUseProgram(GLuint program) {}
 void glValidateProgram(GLuint program) {}
 void glVertexAttrib1f(GLuint index, GLfloat x) {}
 void glVertexAttrib1fv(GLuint index, const GLfloat *v) {}
 void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y) {}
 void glVertexAttrib2fv(GLuint index, const GLfloat *v) {}
 void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z) {}
 void glVertexAttrib3fv(GLuint index, const GLfloat *v) {}
 void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {}
 void glVertexAttrib4fv(GLuint index, const GLfloat *v) {}
 void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) {}
 void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {}


 // gles2 ext
 void glInsertEventMarkerEXT(GLsizei length, const GLchar *marker) {}
 void glPushGroupMarkerEXT(GLsizei length, const GLchar *marker) {}
 void glPopGroupMarkerEXT(void) {}
 void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum *attachments) {}
 void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) {}

 // GLES3
 void* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) {
     return 0;
 }

 GLboolean glUnmapBuffer(GLenum target) {
     return GL_FALSE;
 }
	/*
	* Copyright(C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0(the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "unwrap_gles.h"

	#include <GLES3/gl3.h>
	#include <GLES2/gl2ext.h>

	#include <stdlib.h>
	#include <string.h>

	struct {
	GLboolean scissorEnabled;
	} gState;

	void glGenCommon(GLsizei n, GLuint *buffers) {
	static GLuint nextId = 0;
	int i;
	for(i = 0; i < n; i++) {
	buffers[i] = ++nextId;
	}
	}

	void glGenBuffers(GLsizei n, GLuint *buffers) {
	glGenCommon(n, buffers);
	}

	void glGenFramebuffers(GLsizei n, GLuint *framebuffers) {
	glGenCommon(n, framebuffers);
	}

	void glGenRenderbuffers(GLsizei n, GLuint *renderbuffers) {
	glGenCommon(n, renderbuffers);
	}

	void glGenTextures(GLsizei n, GLuint *textures) {
	glGenCommon(n, textures);
	}

	GLuint glCreateProgram(void) {
	static GLuint nextProgram = 0;
	return ++nextProgram;
	}

	GLuint glCreateShader(GLenum type) {
	static GLuint nextShader = 0;
	return ++nextShader;
	}

	void glGetProgramiv(GLuint program, GLenum pname, GLint *params) {
	switch (pname) {
	case GL_DELETE_STATUS:
	case GL_LINK_STATUS:
	case GL_VALIDATE_STATUS:
	*params = GL_TRUE;
	break;
	case GL_INFO_LOG_LENGTH:
	*params = 16;
	break;
	}
	}

	void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei length, GLchar infoLog) {
	*length = snprintf(infoLog, bufSize, "success");
	if (*length >= bufSize) {
	*length = bufSize - 1;
	}
	}

	void glGetShaderiv(GLuint shader, GLenum pname, GLint *params) {
	switch (pname) {
	case GL_COMPILE_STATUS:
	case GL_DELETE_STATUS:
	*params = GL_TRUE;
	}
	}

	void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei length, GLchar infoLog) {
	*length = snprintf(infoLog, bufSize, "success");
	if (*length >= bufSize) {
	*length = bufSize - 1;
	}
	}

	void setBooleanState(GLenum cap, GLboolean value) {
	switch (cap) {
	case GL_SCISSOR_TEST:
	gState.scissorEnabled = value;
	break;
	}
	}

	void glEnable(GLenum cap) {
	setBooleanState(cap, GL_TRUE);
	}

	void glDisable(GLenum cap) {
	setBooleanState(cap, GL_FALSE);
	}

	GLboolean glIsEnabled(GLenum cap) {
	switch (cap) {
	case GL_SCISSOR_TEST:
	return gState.scissorEnabled;
	default:
	return GL_FALSE;
	}
	}

	void glGetIntegerv(GLenum pname, GLint *data) {
	switch (pname) {
	case GL_MAX_TEXTURE_SIZE:
	*data = 2048;
	break;
	case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
	*data = 4;
	break;
	default:
	*data = 0;
	}
	}

	const char* getString(GLenum name) {
	switch (name) {
	case GL_VENDOR:
	return "android";
	case GL_RENDERER:
	return "null";
	case GL_VERSION:
	return "OpenGL ES 2.0 rev1";
	case GL_SHADING_LANGUAGE_VERSION:
	return "OpenGL ES GLSL ES 2.0 rev1";
	case GL_EXTENSIONS:
	default:
	return "";
	}
	}

	const GLubyte* glGetString(GLenum name) {
	return (GLubyte*) getString(name);
	}

	void glActiveTexture(GLenum texture) {}
	void glAttachShader(GLuint program, GLuint shader) {}
	void glBindAttribLocation(GLuint program, GLuint index, const GLchar *name) {}
	void glBindBuffer(GLenum target, GLuint buffer) {}
	void glBindFramebuffer(GLenum target, GLuint framebuffer) {}
	void glBindRenderbuffer(GLenum target, GLuint renderbuffer) {}
	void glBindTexture(GLenum target, GLuint texture) {}
	void glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {}
	void glBlendEquation(GLenum mode) {}
	void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {}
	void glBlendFunc(GLenum sfactor, GLenum dfactor) {}
	void glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {}
	void glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage) {}
	void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data) {}
	void glClear(GLbitfield mask) {}
	void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {}
	void glClearDepthf(GLfloat d) {}
	void glClearStencil(GLint s) {}
	void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {}
	void glCompileShader(GLuint shader) {}
	void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data) {}
	void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data) {}
	void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {}
	void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {}
	void glCullFace(GLenum mode) {}
	void glDeleteBuffers(GLsizei n, const GLuint *buffers) {}
	void glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers) {}
	void glDeleteProgram(GLuint program) {}
	void glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers) {}
	void glDeleteShader(GLuint shader) {}
	void glDeleteTextures(GLsizei n, const GLuint *textures) {}
	void glDepthFunc(GLenum func) {}
	void glDepthMask(GLboolean flag) {}
	void glDepthRangef(GLfloat n, GLfloat f) {}
	void glDetachShader(GLuint program, GLuint shader) {}
	void glDisableVertexAttribArray(GLuint index) {}
	void glDrawArrays(GLenum mode, GLint first, GLsizei count) {}
	void glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) {}
	void glEnableVertexAttribArray(GLuint index) {}
	void glFinish(void) {}
	void glFlush(void) {}
	void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {}
	void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {}
	void glFrontFace(GLenum mode) {}
	void glGenerateMipmap(GLenum target) {}
	GLint glGetAttribLocation(GLuint program, const GLchar *name) { return 1; }
	GLenum glGetError(void) { return GL_NO_ERROR; }
	GLint glGetUniformLocation(GLuint program, const GLchar *name) { return 2; }
	void glHint(GLenum target, GLenum mode) {}
	void glLineWidth(GLfloat width) {}
	void glLinkProgram(GLuint program) {}
	void glPixelStorei(GLenum pname, GLint param) {}
	void glPolygonOffset(GLfloat factor, GLfloat units) {}
	void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels) {}
	void glReleaseShaderCompiler(void) {}
	void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {}
	void glSampleCoverage(GLfloat value, GLboolean invert) {}
	void glScissor(GLint x, GLint y, GLsizei width, GLsizei height) {}
	void glShaderBinary(GLsizei count, const GLuint shaders, GLenum binaryformat, const void binary, GLsizei length) {}
	void glShaderSource(GLuint shader, GLsizei count, const GLchar conststring, const GLint *length) {}
	void glStencilFunc(GLenum func, GLint ref, GLuint mask) {}
	void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) {}
	void glStencilMask(GLuint mask) {}
	void glStencilMaskSeparate(GLenum face, GLuint mask) {}
	void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {}
	void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) {}
	void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) {}
	void glTexParameterf(GLenum target, GLenum pname, GLfloat param) {}
	void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) {}
	void glTexParameteri(GLenum target, GLenum pname, GLint param) {}
	void glTexParameteriv(GLenum target, GLenum pname, const GLint *params) {}
	void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) {}
	void glUniform1f(GLint location, GLfloat v0) {}
	void glUniform1fv(GLint location, GLsizei count, const GLfloat *value) {}
	void glUniform1i(GLint location, GLint v0) {}
	void glUniform1iv(GLint location, GLsizei count, const GLint *value) {}
	void glUniform2f(GLint location, GLfloat v0, GLfloat v1) {}
	void glUniform2fv(GLint location, GLsizei count, const GLfloat *value) {}
	void glUniform2i(GLint location, GLint v0, GLint v1) {}
	void glUniform2iv(GLint location, GLsizei count, const GLint *value) {}
	void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {}
	void glUniform3fv(GLint location, GLsizei count, const GLfloat *value) {}
	void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2) {}
	void glUniform3iv(GLint location, GLsizei count, const GLint *value) {}
	void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {}
	void glUniform4fv(GLint location, GLsizei count, const GLfloat *value) {}
	void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {}
	void glUniform4iv(GLint location, GLsizei count, const GLint *value) {}
	void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {}
	void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {}
	void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) {}
	void glUseProgram(GLuint program) {}
	void glValidateProgram(GLuint program) {}
	void glVertexAttrib1f(GLuint index, GLfloat x) {}
	void glVertexAttrib1fv(GLuint index, const GLfloat *v) {}
	void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y) {}
	void glVertexAttrib2fv(GLuint index, const GLfloat *v) {}
	void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z) {}
	void glVertexAttrib3fv(GLuint index, const GLfloat *v) {}
	void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {}
	void glVertexAttrib4fv(GLuint index, const GLfloat *v) {}
	void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) {}
	void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {}


	// gles2 ext
	void glInsertEventMarkerEXT(GLsizei length, const GLchar *marker) {}
	void glPushGroupMarkerEXT(GLsizei length, const GLchar *marker) {}
	void glPopGroupMarkerEXT(void) {}
	void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum *attachments) {}
	void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) {}

	// GLES3
	void* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) {
	return 0;
	}

	GLboolean glUnmapBuffer(GLenum target) {
	return GL_FALSE;
	}