8160f20b0a
Now test-only common files reside in tests/common, and each test executable type (macrobench, microbench, and unit) has a subdir there. This change means the shared lib no longer has test code in it, and sets up a means for scenes to be shared between tests. Change-Id: I37b081f6977300e03fdd961b8e6439fde730605e
274 lines
11 KiB
C++
274 lines
11 KiB
C++
/*
|
|
* 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 <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;
|
|
}
|