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

Merge "Remove points from fixed function. Add basic GL performance test."

Browse Source
This commit is contained in:
Jason Sams
2010-07-09 15:35:09 -07:00
committed by Android (Google) Code Review
parent a6935ab009 53a93d5e91
commit 2caad1dcec
13 changed files with 665 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
graphics/java/android/renderscript/ProgramRaster.java
View File

@@ -29,7 +29,6 @@ public class ProgramRaster extends BaseObj {
boolean mPointSmooth;
boolean mLineSmooth;
boolean mPointSprite;
float mPointSize;
float mLineWidth;
Element mIn;
Element mOut;
@@ -38,7 +37,6 @@ public class ProgramRaster extends BaseObj {
super(rs);
mID = id;
mPointSize = 1.0f;
mLineWidth = 1.0f;
mPointSmooth = false;
mLineSmooth = false;
@@ -51,12 +49,6 @@ public class ProgramRaster extends BaseObj {
mRS.nProgramRasterSetLineWidth(mID, w);
}
public void setPointSize(float s) {
mRS.validate();
mPointSize = s;
mRS.nProgramRasterSetPointSize(mID, s);
}
void internalInit() {
int inID = 0;
int outID = 0;

1
graphics/java/android/renderscript/RenderScript.java
View File

@@ -167,7 +167,6 @@ public class RenderScript {
native int nProgramRasterCreate(int in, int out, boolean pointSmooth, boolean lineSmooth, boolean pointSprite);
native void nProgramRasterSetLineWidth(int pr, float v);
native void nProgramRasterSetPointSize(int pr, float v);
native void nProgramBindConstants(int pv, int slot, int mID);
native void nProgramBindTexture(int vpf, int slot, int a);

9
graphics/jni/android_renderscript_RenderScript.cpp
View File

@@ -1212,14 +1212,6 @@ nProgramRasterCreate(JNIEnv *_env, jobject _this, jint in, jint out,
return (jint)rsProgramRasterCreate(con, (RsElement)in, (RsElement)out, pointSmooth, lineSmooth, pointSprite);
}
static void
nProgramRasterSetPointSize(JNIEnv *_env, jobject _this, jint vpr, jfloat v)
{
RsContext con = (RsContext)(_env->GetIntField(_this, gContextId));
LOG_API("nProgramRasterSetPointSize, con(%p), vpf(%p), value(%f)", con, (RsProgramRaster)vpr, v);
rsProgramRasterSetPointSize(con, (RsProgramFragment)vpr, v);
}
static void
nProgramRasterSetLineWidth(JNIEnv *_env, jobject _this, jint vpr, jfloat v)
{
@@ -1482,7 +1474,6 @@ static JNINativeMethod methods[] = {
{"nProgramFragmentCreate2", "(Ljava/lang/String;[I)I", (void*)nProgramFragmentCreate2 },
{"nProgramRasterCreate", "(IIZZZ)I", (void*)nProgramRasterCreate },
{"nProgramRasterSetPointSize", "(IF)V", (void*)nProgramRasterSetPointSize },
{"nProgramRasterSetLineWidth", "(IF)V", (void*)nProgramRasterSetLineWidth },
{"nProgramVertexCreate", "(Z)I", (void*)nProgramVertexCreate },

5
libs/rs/rs.spec
View File

@@ -360,11 +360,6 @@ ProgramRasterSetLineWidth {
param float lw
}
ProgramRasterSetPointSize{
param RsProgramRaster pr
param float ps
}
ProgramBindConstants {
param RsProgram vp

16
libs/rs/rsProgramRaster.cpp
View File

@@ -41,8 +41,6 @@ ProgramRaster::ProgramRaster(Context *rsc,
mPointSmooth = pointSmooth;
mLineSmooth = lineSmooth;
mPointSprite = pointSprite;
mPointSize = 1.0f;
mLineWidth = 1.0f;
}
@@ -55,11 +53,6 @@ void ProgramRaster::setLineWidth(float s)
mLineWidth = s;
}
void ProgramRaster::setPointSize(float s)
{
mPointSize = s;
}
void ProgramRaster::setupGL(const Context *rsc, ProgramRasterState *state)
{
if (state->mLast.get() == this) {
@@ -67,7 +60,6 @@ void ProgramRaster::setupGL(const Context *rsc, ProgramRasterState *state)
}
state->mLast.set(this);
glPointSize(mPointSize);
if (mPointSmooth) {
glEnable(GL_POINT_SMOOTH);
} else {
@@ -102,7 +94,7 @@ void ProgramRaster::setupGL2(const Context *rsc, ProgramRasterState *state)
void ProgramRaster::serialize(OStream *stream) const
{
}
ProgramRaster *ProgramRaster::createFromStream(Context *rsc, IStream *stream)
@@ -147,12 +139,6 @@ RsProgramRaster rsi_ProgramRasterCreate(Context * rsc, RsElement in, RsElement o
return pr;
}
void rsi_ProgramRasterSetPointSize(Context * rsc, RsProgramRaster vpr, float s)
{
ProgramRaster *pr = static_cast<ProgramRaster *>(vpr);
pr->setPointSize(s);
}
void rsi_ProgramRasterSetLineWidth(Context * rsc, RsProgramRaster vpr, float s)
{
ProgramRaster *pr = static_cast<ProgramRaster *>(vpr);

5
libs/rs/rsProgramRaster.h
View File

@@ -41,17 +41,12 @@ public:
static ProgramRaster *createFromStream(Context *rsc, IStream *stream);
void setLineWidth(float w);
void setPointSize(float s);
protected:
bool mPointSmooth;
bool mLineSmooth;
bool mPointSprite;
float mPointSize;
float mLineWidth;
};
class ProgramRasterState

6
libs/rs/rsProgramVertex.cpp
View File

@@ -191,7 +191,6 @@ void ProgramVertex::createShader()
mShader.append("attribute vec4 ATTRIB_position;\n");
mShader.append("attribute vec4 ATTRIB_color;\n");
mShader.append("attribute vec3 ATTRIB_normal;\n");
mShader.append("attribute float ATTRIB_pointSize;\n");
mShader.append("attribute vec4 ATTRIB_texture0;\n");
for (uint32_t ct=0; ct < mUniformCount; ct++) {
@@ -202,7 +201,7 @@ void ProgramVertex::createShader()
mShader.append("void main() {\n");
mShader.append(" gl_Position = UNI_MVP * ATTRIB_position;\n");
mShader.append(" gl_PointSize = ATTRIB_pointSize;\n");
mShader.append(" gl_PointSize = 1.0;\n");
mShader.append(" varColor = ATTRIB_color;\n");
if (mTextureMatrixEnable) {
@@ -210,9 +209,6 @@ void ProgramVertex::createShader()
} else {
mShader.append(" varTex0 = ATTRIB_texture0;\n");
}
//mShader.append(" pos.x = pos.x / 480.0;\n");
//mShader.append(" pos.y = pos.y / 800.0;\n");
//mShader.append(" gl_Position = pos;\n");
mShader.append("}\n");
}
}

3
libs/rs/rsShaderCache.cpp
View File

@@ -101,8 +101,7 @@ bool ShaderCache::lookup(Context *rsc, ProgramVertex *vtx, ProgramFragment *frag
glBindAttribLocation(pgm, 0, "ATTRIB_position");
glBindAttribLocation(pgm, 1, "ATTRIB_color");
glBindAttribLocation(pgm, 2, "ATTRIB_normal");
glBindAttribLocation(pgm, 3, "ATTRIB_pointSize");
glBindAttribLocation(pgm, 4, "ATTRIB_texture0");
glBindAttribLocation(pgm, 3, "ATTRIB_texture0");
}
//LOGE("e2 %x", glGetError());

4
libs/rs/rsVertexArray.cpp
View File

@@ -144,10 +144,8 @@ void VertexArray::setupGL2(const Context *rsc, class VertexArrayState *state, Sh
slot = 1;
} else if (mAttribs[ct].name == "normal") {
slot = 2;
} else if (mAttribs[ct].name == "pointSize") {
slot = 3;
} else if (mAttribs[ct].name == "texture0") {
slot = 4;
slot = 3;
} else {
continue;
}

17
libs/rs/scriptc/rs_math.rsh
View File

@@ -48,6 +48,23 @@ extern int64_t rsElapsedTimeMillis();
extern int rsSendToClient(void *data, int cmdID, int len, int waitForSpace);
// Script to Script
typedef struct rs_script_call_rec {
rs_script script;
rs_allocation input;
rs_allocation output;
uint32_t xStart;
uint32_t xEnd;
uint32_t yStart;
uint32_t yEnd;
uint32_t zStart;
uint32_t zEnd;
uint32_t arrayStart;
uint32_t arrayEnd;
const void * usrData;
} rs_script_call;
extern void __attribute__((overloadable))rsForEach(rs_script, rs_allocation input);
extern void __attribute__((overloadable))rsForEach(rs_script, rs_allocation input, rs_allocation output);
extern void __attribute__((overloadable))rsForEach(rs_script, rs_allocation input, int xStart, int xEnd);

20
opengl/tests/gl_perf/Android.mk Normal file
View File

@@ -0,0 +1,20 @@
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES:= \
gl2_perf.cpp \
filltest.cpp
LOCAL_SHARED_LIBRARIES := \
libcutils \
libEGL \
libGLESv2 \
libui
LOCAL_MODULE:= test-opengl-gl2_perf
LOCAL_MODULE_TAGS := optional
LOCAL_CFLAGS := -DGL_GLEXT_PROTOTYPES
include $(BUILD_EXECUTABLE)

382
opengl/tests/gl_perf/filltest.cpp Normal file
View File

@@ -0,0 +1,382 @@
/*
* Copyright (C) 2007 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 <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <sched.h>
#include <sys/resource.h>
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#include <utils/Timers.h>
#include <EGL/egl.h>
using namespace android;
static void checkGlError(const char* op) {
for (GLint error = glGetError(); error; error
= glGetError()) {
fprintf(stderr, "after %s() glError (0x%x)\n", op, error);
}
}
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;
}
enum {
A_POS,
A_COLOR,
A_TEX0,
A_TEX1
};
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 v");
glAttachShader(program, pixelShader);
checkGlError("glAttachShader p");
glBindAttribLocation(program, A_POS, "a_pos");
glBindAttribLocation(program, A_COLOR, "a_color");
glBindAttribLocation(program, A_TEX0, "a_tex0");
glBindAttribLocation(program, A_TEX1, "a_tex1");
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);
printf("Could not link program:\n%s\n", buf);
free(buf);
}
}
glDeleteProgram(program);
program = 0;
}
}
checkGlError("createProgram");
glUseProgram(program);
return program;
}
uint64_t getTime() {
struct timespec t;
clock_gettime(CLOCK_MONOTONIC, &t);
return t.tv_nsec + ((uint64_t)t.tv_sec * 1000 * 1000 * 1000);
}
uint64_t gTime;
void startTimer() {
gTime = getTime();
}
void endTimer(const char *str, int w, int h, double dc, int count) {
uint64_t t2 = getTime();
double delta = ((double)(t2 - gTime)) / 1000000000;
double pixels = dc * (w * h) * count;
double mpps = pixels / delta / 1000000;
double dc60 = pixels / delta / (w * h) / 60;
printf("test %s, Mpps %f, dc = %f\n", str, mpps, dc60);
}
static const char gVertexShader[] =
"attribute vec4 a_pos;\n"
"attribute vec4 a_color;\n"
"attribute vec2 a_tex0;\n"
"attribute vec2 a_tex1;\n"
"varying vec4 v_color;\n"
"varying vec2 v_tex0;\n"
"varying vec2 v_tex1;\n"
"void main() {\n"
" v_color = a_color;\n"
" v_tex0 = a_tex0;\n"
" v_tex1 = a_tex1;\n"
" gl_Position = a_pos;\n"
"}\n";
static const char gShaderPrefix[] =
"precision mediump float;\n"
"uniform vec4 u_color;\n"
"uniform vec4 u_0;\n"
"uniform vec4 u_1;\n"
"uniform vec4 u_2;\n"
"uniform vec4 u_3;\n"
"varying vec4 v_color;\n"
"varying vec2 v_tex0;\n"
"varying vec2 v_tex1;\n"
"uniform sampler2D u_tex0;\n"
"uniform sampler2D u_tex1;\n"
"void main() {\n";
static const char gShaderPostfix[] =
" gl_FragColor = c;\n"
"}\n";
static char * append(char *d, const char *s) {
size_t len = strlen(s);
memcpy(d, s, len);
return d + len;
}
static char * genShader(
bool useVarColor,
int texCount,
bool modulateFirstTex,
int extraMath)
{
char *str = (char *)calloc(16 * 1024, 1);
char *tmp = append(str, gShaderPrefix);
if (modulateFirstTex || !texCount) {
if (useVarColor) {
tmp = append(tmp, " vec4 c = v_color;\n");
} else {
tmp = append(tmp, " vec4 c = u_color;\n");
}
} else {
tmp = append(tmp, " vec4 c = texture2D(u_tex0, v_tex0);\n");
}
if (modulateFirstTex && texCount) {
tmp = append(tmp, " c *= texture2D(u_tex0, v_tex0);\n");
}
if (texCount > 1) {
tmp = append(tmp, " c *= texture2D(u_tex1, v_tex1);\n");
}
if (extraMath > 0) {
tmp = append(tmp, " c *= u_0;\n");
}
if (extraMath > 1) {
tmp = append(tmp, " c *= u_1;\n");
}
if (extraMath > 2) {
tmp = append(tmp, " c *= u_2;\n");
}
if (extraMath > 3) {
tmp = append(tmp, " c *= u_3;\n");
}
tmp = append(tmp, gShaderPostfix);
tmp[0] = 0;
//printf("%s", str);
return str;
}
static void setupVA() {
static const float vtx[] = {
-2.0f,-1.0f,
1.0f,-1.0f,
-2.0f, 1.0f,
1.0f, 1.0f };
static const float color[] = {
1.0f,0.0f,1.0f,1.0f,
0.0f,0.0f,1.0f,1.0f,
1.0f,1.0f,0.0f,1.0f,
1.0f,1.0f,1.0f,1.0f };
static const float tex0[] = {
0.0f,0.0f,
1.0f,0.0f,
1.0f,1.0f,
0.0f,1.0f };
static const float tex1[] = {
1.0f,0.0f,
1.0f,1.0f,
0.0f,1.0f,
0.0f,0.0f };
glEnableVertexAttribArray(A_POS);
glEnableVertexAttribArray(A_COLOR);
glEnableVertexAttribArray(A_TEX0);
glEnableVertexAttribArray(A_TEX1);
glVertexAttribPointer(A_POS, 2, GL_FLOAT, false, 8, vtx);
glVertexAttribPointer(A_COLOR, 4, GL_FLOAT, false, 16, color);
glVertexAttribPointer(A_TEX0, 2, GL_FLOAT, false, 8, tex0);
glVertexAttribPointer(A_TEX1, 2, GL_FLOAT, false, 8, tex1);
}
//////////////////////////
void ptSwap();
static void doLoop(uint32_t w, uint32_t h, const char *str) {
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
ptSwap();
glFinish();
startTimer();
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
for (int ct=0; ct < 100; ct++) {
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
ptSwap();
glFinish();
endTimer(str, w, h, 1, 100);
}
static void doSingleTest(uint32_t w, uint32_t h,
bool useVarColor,
int texCount,
bool modulateFirstTex,
int extraMath,
int tex0, int tex1) {
char *pgmTxt = genShader(useVarColor, texCount, modulateFirstTex, extraMath);
int pgm = createProgram(gVertexShader, pgmTxt);
if (!pgm) {
printf("error running test\n");
return;
}
int loc = glGetUniformLocation(pgm, "u_tex0");
//printf("loc = %i \n", loc);
if (loc >= 0) glUniform1i(loc, 0);
loc = glGetUniformLocation(pgm, "u_tex1");
if (loc >= 0) glUniform1i(loc, 1);
loc = glGetUniformLocation(pgm, "u_color");
if (loc >= 0) glUniform4f(loc, 1.f, 0.4f, 0.6f, 0.8f);
loc = glGetUniformLocation(pgm, "u_0");
if (loc >= 0) glUniform4f(loc, 1.f, 0.4f, 0.6f, 0.8f);
loc = glGetUniformLocation(pgm, "u_1");
if (loc >= 0) glUniform4f(loc, 0.7f, 0.8f, 0.6f, 0.8f);
loc = glGetUniformLocation(pgm, "u_2");
if (loc >= 0) glUniform4f(loc, 0.9f, 0.6f, 0.7f, 1.0f);
loc = glGetUniformLocation(pgm, "u_3");
if (loc >= 0) glUniform4f(loc, 0.88f, 0.2f, 0.4f, 0.2f);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, tex0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, tex1);
glActiveTexture(GL_TEXTURE0);
char str2[1024];
glBlendFunc(GL_ONE, GL_ONE);
glDisable(GL_BLEND);
sprintf(str2, "Test varColor=%i, texCount=%i, modulate=%i, extraMath=%i, texSize=%i, blend=0",
useVarColor, texCount, modulateFirstTex, extraMath, tex0);
doLoop(w, h, str2);
glEnable(GL_BLEND);
sprintf(str2, "Test varColor=%i, texCount=%i, modulate=%i, extraMath=%i, texSize=%i, blend=1",
useVarColor, texCount, modulateFirstTex, extraMath, tex0);
doLoop(w, h, str2);
}
void genTextures() {
uint32_t *m = (uint32_t *)malloc(1024*1024*4);
for (int y=0; y < 1024; y++){
for (int x=0; x < 1024; x++){
m[y*1024 + x] = 0xff0000ff | ((x & 0xff) << 8) | (y << 16);
}
}
glBindTexture(GL_TEXTURE_2D, 1);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1024, 1024, 0, GL_RGBA, GL_UNSIGNED_BYTE, m);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
for (int y=0; y < 16; y++){
for (int x=0; x < 16; x++){
m[y*16 + x] = 0xff0000ff | (x<<12) | (y<<20);
}
}
glBindTexture(GL_TEXTURE_2D, 2);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, m);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
}
bool doTest(uint32_t w, uint32_t h) {
setupVA();
genTextures();
for (int texCount = 0; texCount < 3; texCount++) {
for (int extraMath = 0; extraMath < 5; extraMath++) {
doSingleTest(w, h, false, texCount, false, extraMath, 1, 1);
doSingleTest(w, h, true, texCount, false, extraMath, 1, 1);
if (texCount) {
doSingleTest(w, h, false, texCount, true, extraMath, 1, 1);
doSingleTest(w, h, true, texCount, true, extraMath, 1, 1);
doSingleTest(w, h, false, texCount, false, extraMath, 2, 2);
doSingleTest(w, h, true, texCount, false, extraMath, 2, 2);
doSingleTest(w, h, false, texCount, true, extraMath, 2, 2);
doSingleTest(w, h, true, texCount, true, extraMath, 2, 2);
}
}
}
exit(0);
return true;
}

242
opengl/tests/gl_perf/gl2_perf.cpp Normal file
View File

@@ -0,0 +1,242 @@
/*
* Copyright (C) 2007 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 <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <sched.h>
#include <sys/resource.h>
#include <EGL/egl.h>
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#include <utils/Timers.h>
#include <ui/FramebufferNativeWindow.h>
#include <ui/EGLUtils.h>
using namespace android;
static void printGLString(const char *name, GLenum s) {
// fprintf(stderr, "printGLString %s, %d\n", name, s);
const char *v = (const char *) glGetString(s);
// int error = glGetError();
// fprintf(stderr, "glGetError() = %d, result of glGetString = %x\n", error,
// (unsigned int) v);
// if ((v < (const char*) 0) || (v > (const char*) 0x10000))
// fprintf(stderr, "GL %s = %s\n", name, v);
// else
// fprintf(stderr, "GL %s = (null) 0x%08x\n", name, (unsigned int) v);
fprintf(stderr, "GL %s = %s\n", name, v);
}
static void checkEglError(const char* op, EGLBoolean returnVal = EGL_TRUE) {
if (returnVal != EGL_TRUE) {
fprintf(stderr, "%s() returned %d\n", op, returnVal);
}
for (EGLint error = eglGetError(); error != EGL_SUCCESS; error
= eglGetError()) {
fprintf(stderr, "after %s() eglError %s (0x%x)\n", op, EGLUtils::strerror(error),
error);
}
}
static void checkGlError(const char* op) {
for (GLint error = glGetError(); error; error
= glGetError()) {
fprintf(stderr, "after %s() glError (0x%x)\n", op, error);
}
}
void printEGLConfiguration(EGLDisplay dpy, EGLConfig config) {
#define X(VAL) {VAL, #VAL}
struct {EGLint attribute; const char* name;} names[] = {
X(EGL_BUFFER_SIZE),
X(EGL_ALPHA_SIZE),
X(EGL_BLUE_SIZE),
X(EGL_GREEN_SIZE),
X(EGL_RED_SIZE),
X(EGL_DEPTH_SIZE),
X(EGL_STENCIL_SIZE),
X(EGL_CONFIG_CAVEAT),
X(EGL_CONFIG_ID),
X(EGL_LEVEL),
X(EGL_MAX_PBUFFER_HEIGHT),
X(EGL_MAX_PBUFFER_PIXELS),
X(EGL_MAX_PBUFFER_WIDTH),
X(EGL_NATIVE_RENDERABLE),
X(EGL_NATIVE_VISUAL_ID),
X(EGL_NATIVE_VISUAL_TYPE),
X(EGL_SAMPLES),
X(EGL_SAMPLE_BUFFERS),
X(EGL_SURFACE_TYPE),
X(EGL_TRANSPARENT_TYPE),
X(EGL_TRANSPARENT_RED_VALUE),
X(EGL_TRANSPARENT_GREEN_VALUE),
X(EGL_TRANSPARENT_BLUE_VALUE),
X(EGL_BIND_TO_TEXTURE_RGB),
X(EGL_BIND_TO_TEXTURE_RGBA),
X(EGL_MIN_SWAP_INTERVAL),
X(EGL_MAX_SWAP_INTERVAL),
X(EGL_LUMINANCE_SIZE),
X(EGL_ALPHA_MASK_SIZE),
X(EGL_COLOR_BUFFER_TYPE),
X(EGL_RENDERABLE_TYPE),
X(EGL_CONFORMANT),
};
#undef X
for (size_t j = 0; j < sizeof(names) / sizeof(names[0]); j++) {
EGLint value = -1;
EGLint returnVal = eglGetConfigAttrib(dpy, config, names[j].attribute, &value);
EGLint error = eglGetError();
if (returnVal && error == EGL_SUCCESS) {
printf(" %s: ", names[j].name);
printf("%d (0x%x)", value, value);
}
}
printf("\n");
}
int printEGLConfigurations(EGLDisplay dpy) {
EGLint numConfig = 0;
EGLint returnVal = eglGetConfigs(dpy, NULL, 0, &numConfig);
checkEglError("eglGetConfigs", returnVal);
if (!returnVal) {
return false;
}
printf("Number of EGL configuration: %d\n", numConfig);
EGLConfig* configs = (EGLConfig*) malloc(sizeof(EGLConfig) * numConfig);
if (! configs) {
printf("Could not allocate configs.\n");
return false;
}
returnVal = eglGetConfigs(dpy, configs, numConfig, &numConfig);
checkEglError("eglGetConfigs", returnVal);
if (!returnVal) {
free(configs);
return false;
}
for(int i = 0; i < numConfig; i++) {
printf("Configuration %d\n", i);
printEGLConfiguration(dpy, configs[i]);
}
free(configs);
return true;
}
bool doTest(uint32_t w, uint32_t h);
static EGLDisplay dpy;
static EGLSurface surface;
int main(int argc, char** argv) {
EGLBoolean returnValue;
EGLConfig myConfig = {0};
EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
EGLint s_configAttribs[] = {
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE };
EGLint majorVersion;
EGLint minorVersion;
EGLContext context;
EGLint w, h;
checkEglError("<init>");
dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
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);
if (returnValue != EGL_TRUE) {
printf("eglInitialize failed\n");
return 0;
}
EGLNativeWindowType window = android_createDisplaySurface();
returnValue = EGLUtils::selectConfigForNativeWindow(dpy, s_configAttribs, window, &myConfig);
if (returnValue) {
printf("EGLUtils::selectConfigForNativeWindow() returned %d", returnValue);
return 0;
}
checkEglError("EGLUtils::selectConfigForNativeWindow");
printf("Chose this configuration:\n");
printEGLConfiguration(dpy, myConfig);
surface = eglCreateWindowSurface(dpy, myConfig, window, NULL);
checkEglError("eglCreateWindowSurface");
if (surface == EGL_NO_SURFACE) {
printf("gelCreateWindowSurface failed.\n");
return 0;
}
context = eglCreateContext(dpy, myConfig, EGL_NO_CONTEXT, context_attribs);
checkEglError("eglCreateContext");
if (context == EGL_NO_CONTEXT) {
printf("eglCreateContext failed\n");
return 0;
}
returnValue = eglMakeCurrent(dpy, surface, surface, context);
checkEglError("eglMakeCurrent", returnValue);
if (returnValue != EGL_TRUE) {
return 0;
}
eglQuerySurface(dpy, surface, EGL_WIDTH, &w);
checkEglError("eglQuerySurface");
eglQuerySurface(dpy, surface, EGL_HEIGHT, &h);
checkEglError("eglQuerySurface");
GLint dim = w < h ? w : h;
fprintf(stderr, "Window dimensions: %d x %d\n", w, h);
printGLString("Version", GL_VERSION);
printGLString("Vendor", GL_VENDOR);
printGLString("Renderer", GL_RENDERER);
printGLString("Extensions", GL_EXTENSIONS);
glViewport(0, 0, w, h);
for (;;) {
doTest(w, h);
eglSwapBuffers(dpy, surface);
checkEglError("eglSwapBuffers");
}
return 0;
}
void ptSwap() {
eglSwapBuffers(dpy, surface);
}