Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

am cd0aceb7: Merge change 25883 into eclair

Browse Source 
Merge commit 'cd0aceb710fc3b62a238992ceef628e359ee1e7d' into eclair-plus-aosp

* commit 'cd0aceb710fc3b62a238992ceef628e359ee1e7d':
  Draw a green triangle using OpenGL 2.0 APIs.
This commit is contained in:
Jack Palevich
2009-09-18 18:37:38 -07:00
committed by Android Git Automerger
parent 3bd5378329 cd0aceb710
commit f44ddb6b45
1 changed files with 226 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

329
opengl/tests/gl2_basic/gl2_basic.cpp
View File

@@ -21,8 +21,8 @@
#include <sys/resource.h> #include <sys/resource.h>
#include <EGL/egl.h> #include <EGL/egl.h>
#include <GLES/gl.h> #include <GLES2/gl2.h>
#include <GLES/glext.h> #include <GLES2/gl2ext.h>
#include <utils/Timers.h> #include <utils/Timers.h>
@@ -31,144 +31,267 @@
using namespace android; using namespace android;
static void printGLString(const char *name, GLenum s) static void printGLString(const char *name, GLenum s) {
{ // fprintf(stderr, "printGLString %s, %d\n", name, s);
fprintf(stderr, "printGLString %s, %d\n", name, s); const char *v = (const char *) glGetString(s);
#if 0 // causes hangs // int error = glGetError();
const char *v = (const char *)glGetString(s); // fprintf(stderr, "glGetError() = %d, result of glGetString = %x\n", error,
int error = glGetError(); // (unsigned int) v);
fprintf(stderr, "glGetError() = %d, result of glGetString = %x\n", error, // if ((v < (const char*) 0) || (v > (const char*) 0x10000))
(unsigned int)v); // fprintf(stderr, "GL %s = %s\n", name, v);
if ((v < (const char*) 0) || (v > (const char*) 0x10000)) // else
fprintf(stderr, "GL %s = %s\n", name, v); // fprintf(stderr, "GL %s = (null) 0x%08x\n", name, (unsigned int) v);
else fprintf(stderr, "GL %s = %s\n", name, v);
fprintf(stderr, "GL %s = (null) 0x%08x\n", name, (unsigned int) v);
#endif
} }
static const char* eglErrorToString[] = { static const char* eglErrorToString[] = {
"EGL_SUCCESS", // 0x3000 12288 "EGL_SUCCESS", // 0x3000 12288
"EGL_NOT_INITIALIZED", "EGL_NOT_INITIALIZED",
"EGL_BAD_ACCESS", // 0x3002 12290 "EGL_BAD_ACCESS", // 0x3002 12290
"EGL_BAD_ALLOC", "EGL_BAD_ALLOC", "EGL_BAD_ATTRIBUTE",
"EGL_BAD_ATTRIBUTE", "EGL_BAD_CONFIG",
"EGL_BAD_CONFIG", "EGL_BAD_CONTEXT", // 0x3006 12294
"EGL_BAD_CONTEXT", // 0x3006 12294 "EGL_BAD_CURRENT_SURFACE", "EGL_BAD_DISPLAY", "EGL_BAD_MATCH",
"EGL_BAD_CURRENT_SURFACE", "EGL_BAD_NATIVE_PIXMAP", "EGL_BAD_NATIVE_WINDOW", "EGL_BAD_PARAMETER", // 0x300c 12300
"EGL_BAD_DISPLAY", "EGL_BAD_SURFACE" };
"EGL_BAD_MATCH",
"EGL_BAD_NATIVE_PIXMAP",
"EGL_BAD_NATIVE_WINDOW",
"EGL_BAD_PARAMETER", // 0x300c 12300
"EGL_BAD_SURFACE"
};
static void checkEglError(const char* op, EGLBoolean returnVal = EGL_TRUE) { static void checkEglError(const char* op, EGLBoolean returnVal = EGL_TRUE) {
if (returnVal != EGL_TRUE) { if (returnVal != EGL_TRUE) {
fprintf(stderr, "%s() returned %d\n", op, returnVal); fprintf(stderr, "%s() returned %d\n", op, returnVal);
} }
for(EGLint error = eglGetError(); for (EGLint error = eglGetError(); error != EGL_SUCCESS; error
error != EGL_SUCCESS; = eglGetError()) {
error = eglGetError()) {
const char* errorString = "unknown"; const char* errorString = "unknown";
if (error >= EGL_SUCCESS && error <= EGL_BAD_SURFACE) { if (error >= EGL_SUCCESS && error <= EGL_BAD_SURFACE) {
errorString = eglErrorToString[error - EGL_SUCCESS]; errorString = eglErrorToString[error - EGL_SUCCESS];
} }
fprintf(stderr, "after %s() eglError %s (0x%x)\n", op, fprintf(stderr, "after %s() eglError %s (0x%x)\n", op, errorString,
errorString, error); error);
} }
} }
int main(int argc, char** argv) static void checkGlError(const char* op) {
{ for (GLint error = glGetError(); error; error
= glGetError()) {
fprintf(stderr, "after %s() glError (0x%x)\n", op, error);
}
}
static const char gVertexShader[] = "attribute vec4 vPosition;\n"
"void main() {\n"
" gl_Position = vPosition;\n"
"}\n";
static const char gFragmentShader[] = "precision mediump float;\n"
"void main() {\n"
" gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);\n"
"}\n";
GLuint loadShader(GLenum shaderType, const char* pSource) {
GLuint shader = glCreateShader(shaderType);
if (shader) {
glShaderSource(shader, 1, &pSource, NULL);
glCompileShader(shader);
GLint compiled = 0;
glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
if (!compiled) {
GLint infoLen = 0;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
if (infoLen) {
char* buf = (char*) malloc(infoLen);
if (buf) {
glGetShaderInfoLog(shader, infoLen, NULL, buf);
fprintf(stderr, "Could not compile shader %d:\n%s\n",
shaderType, buf);
free(buf);
}
glDeleteShader(shader);
shader = 0;
}
}
}
return shader;
}
GLuint createProgram(const char* pVertexSource, const char* pFragmentSource) {
GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource);
if (!vertexShader) {
return 0;
}
GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource);
if (!pixelShader) {
return 0;
}
GLuint program = glCreateProgram();
if (program) {
glAttachShader(program, vertexShader);
checkGlError("glAttachShader");
glAttachShader(program, pixelShader);
checkGlError("glAttachShader");
glLinkProgram(program);
GLint linkStatus = GL_FALSE;
glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
if (linkStatus != GL_TRUE) {
GLint bufLength = 0;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
if (bufLength) {
char* buf = (char*) malloc(bufLength);
if (buf) {
glGetProgramInfoLog(program, bufLength, NULL, buf);
fprintf(stderr, "Could not link program:\n%s\n", buf);
free(buf);
}
}
glDeleteProgram(program);
program = 0;
}
}
return program;
}
GLuint gProgram;
GLuint gvPositionHandle;
bool setupGraphics(int w, int h) {
gProgram = createProgram(gVertexShader, gFragmentShader);
if (!gProgram) {
return false;
}
gvPositionHandle = glGetAttribLocation(gProgram, "vPosition");
checkGlError("glGetAttribLocation");
fprintf(stderr, "glGetAttribLocation(\"vPosition\") = %d\n",
gvPositionHandle);
glViewport(0, 0, w, h);
checkGlError("glViewport");
return true;
}
const GLfloat gTriangleVertices[] = { 0.0f, 0.5f, -0.5f, -0.5f,
0.5f, -0.5f };
void renderFrame() {
glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
checkGlError("glClearColor");
glClear( GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
checkGlError("glClear");
glUseProgram(gProgram);
checkGlError("glUseProgram");
glVertexAttribPointer(gvPositionHandle, 2, GL_FLOAT, GL_FALSE, 0, gTriangleVertices);
checkGlError("glVertexAttribPointer");
glEnableVertexAttribArray(gvPositionHandle);
checkGlError("glEnableVertexAttribArray");
glDrawArrays(GL_TRIANGLES, 0, 3);
checkGlError("glDrawArrays");
}
int main(int argc, char** argv) {
EGLBoolean returnValue; EGLBoolean returnValue;
EGLConfig configs[2]; EGLConfig configs[2];
EGLint config_count; EGLint config_count;
EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE}; EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
EGLint s_configAttribs[] = { EGLint s_configAttribs[] = { EGL_BUFFER_SIZE, EGL_DONT_CARE, EGL_RED_SIZE,
EGL_BUFFER_SIZE, EGL_DONT_CARE, 5, EGL_GREEN_SIZE, 6, EGL_BLUE_SIZE, 5, EGL_DEPTH_SIZE, 8,
EGL_RED_SIZE, 5, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_NONE };
EGL_GREEN_SIZE, 6,
EGL_BLUE_SIZE, 5,
EGL_DEPTH_SIZE, 8,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
EGLint majorVersion; EGLint s_configAttribs2[] =
EGLint minorVersion; {
EGLContext context; EGL_DEPTH_SIZE, 16,
EGLSurface surface; EGL_NONE
EGLint w, h; };
EGLDisplay dpy; EGLint majorVersion;
EGLint minorVersion;
EGLContext context;
EGLSurface surface;
EGLint w, h;
EGLNativeWindowType window = 0; EGLDisplay dpy;
window = android_createDisplaySurface();
checkEglError("<init>"); EGLNativeWindowType window = 0;
dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY); window = android_createDisplaySurface();
checkEglError("eglGetDisplay");
if (dpy == EGL_NO_DISPLAY) {
printf("eglGetDisplay returned EGL_NO_DISPLAY.\n");
return 0;
}
returnValue = eglInitialize(dpy, &majorVersion, &minorVersion);
checkEglError("eglInitialize", returnValue);
fprintf(stderr, "EGL version %d.%d\n", majorVersion, minorVersion);
returnValue = eglGetConfigs (dpy, configs, 2, &config_count); checkEglError("<init>");
checkEglError("eglGetConfigs", returnValue); dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
fprintf(stderr, "Config count: %d\n", config_count); checkEglError("eglGetDisplay");
for(int i = 0; i < config_count; i++) { if (dpy == EGL_NO_DISPLAY) {
printf("eglGetDisplay returned EGL_NO_DISPLAY.\n");
return 0;
}
returnValue = eglInitialize(dpy, &majorVersion, &minorVersion);
checkEglError("eglInitialize", returnValue);
fprintf(stderr, "EGL version %d.%d\n", majorVersion, minorVersion);
if (returnValue != EGL_TRUE) {
printf("eglInitialize failed\n");
return 0;
}
returnValue = eglGetConfigs(dpy, configs, 2, &config_count);
checkEglError("eglGetConfigs", returnValue);
fprintf(stderr, "Config count: %d\n", config_count);
for (int i = 0; i < config_count; i++) {
fprintf(stderr, "%d: 0x%08x\n", i, (unsigned int) configs[i]); fprintf(stderr, "%d: 0x%08x\n", i, (unsigned int) configs[i]);
} }
#if 0 #if 0
EGLConfig config; EGLConfig config;
EGLUtils::selectConfigForNativeWindow(dpy, s_configAttribs, window, &config); EGLUtils::selectConfigForNativeWindow(dpy, s_configAttribs, window, &config);
checkEglError("EGLUtils::selectConfigForNativeWindow"); checkEglError("EGLUtils::selectConfigForNativeWindow");
#else #else
int chooseConfigResult = eglChooseConfig(dpy, s_configAttribs, configs, 2, &config_count); int chooseConfigResult = eglChooseConfig(dpy, s_configAttribs2, configs, 2,
&config_count);
checkEglError("eglChooseConfig", chooseConfigResult); checkEglError("eglChooseConfig", chooseConfigResult);
if (chooseConfigResult != EGL_TRUE ) if (chooseConfigResult != EGL_TRUE) {
{
printf("eglChooseConfig failed\n"); printf("eglChooseConfig failed\n");
return 0; return 0;
} }
#endif #endif
surface = eglCreateWindowSurface(dpy, configs[0], window, NULL); surface = eglCreateWindowSurface(dpy, configs[0], window, NULL);
checkEglError("eglCreateWindowSurface"); checkEglError("eglCreateWindowSurface");
if (surface == EGL_NO_SURFACE) if (surface == EGL_NO_SURFACE) {
{ printf("gelCreateWindowSurface failed.\n");
printf("gelCreateWindowSurface failed.\n"); return 0;
return 0; }
} EGLint gl2_0Attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
EGLint gl2_0Attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
context = eglCreateContext(dpy, configs[0], EGL_NO_CONTEXT, context_attribs); context = eglCreateContext(dpy, configs[0], EGL_NO_CONTEXT, context_attribs);
checkEglError("eglCreateContext"); checkEglError("eglCreateContext");
if (context == EGL_NO_CONTEXT) if (context == EGL_NO_CONTEXT) {
{
printf("eglCreateContext failed\n"); printf("eglCreateContext failed\n");
return 0; return 0;
} }
eglMakeCurrent(dpy, surface, surface, context); eglMakeCurrent(dpy, surface, surface, context);
checkEglError("eglMakeCurrent"); checkEglError("eglMakeCurrent");
eglQuerySurface(dpy, surface, EGL_WIDTH, &w); eglQuerySurface(dpy, surface, EGL_WIDTH, &w);
checkEglError("eglQuerySurface"); checkEglError("eglQuerySurface");
eglQuerySurface(dpy, surface, EGL_HEIGHT, &h); eglQuerySurface(dpy, surface, EGL_HEIGHT, &h);
checkEglError("eglQuerySurface"); checkEglError("eglQuerySurface");
GLint dim = w<h ? w : h; GLint dim = w < h ? w : h;
fprintf(stderr, "Window dimensions: %d x %d\n", w, h); fprintf(stderr, "Window dimensions: %d x %d\n", w, h);
printGLString("Version", GL_VERSION); printGLString("Version", GL_VERSION);
printGLString("Vendor", GL_VENDOR); printGLString("Vendor", GL_VENDOR);
printGLString("Renderer", GL_RENDERER); printGLString("Renderer", GL_RENDERER);
printGLString("Extensions", GL_EXTENSIONS); printGLString("Extensions", GL_EXTENSIONS);
return 0; if(!setupGraphics(w, h)) {
fprintf(stderr, "Could not set up graphics.\n");
return 0;
}
for (;;) {
renderFrame();
eglSwapBuffers(dpy, surface);
}
return 0;
} }