add OpelGl performance test as a separate package
Currently runs two types of tests
1. rendering performance comparison with VBO vs without VBO
This can also work as a stress test due to the amount of triangles used.
2. rendering performance comparison with varying numbers of index buffers
This is for bug 5660942
Change-Id: I8a7d05cf0bfaa7063302efdd7fb24519d3a3c5bf
diff --git a/CtsTestCaseList.mk b/CtsTestCaseList.mk
index 3ccf169..c0be204 100644
--- a/CtsTestCaseList.mk
+++ b/CtsTestCaseList.mk
@@ -48,6 +48,7 @@
CtsMediaTestCases \
CtsNdefTestCases \
CtsNetTestCases \
+ CtsOpenGlPerfTestCases \
CtsOsTestCases \
CtsPermissionTestCases \
CtsPermission2TestCases \
diff --git a/tests/tests/openglperf/Android.mk b/tests/tests/openglperf/Android.mk
new file mode 100644
index 0000000..0663c73
--- /dev/null
+++ b/tests/tests/openglperf/Android.mk
@@ -0,0 +1,34 @@
+# Copyright (C) 2011 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+# don't include this package in any target
+LOCAL_MODULE_TAGS := optional
+# and when built explicitly put it in the data partition
+LOCAL_MODULE_PATH := $(TARGET_OUT_DATA_APPS)
+
+LOCAL_JAVA_LIBRARIES := android.test.runner
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_PACKAGE_NAME := CtsOpenGlPerfTestCases
+
+# uncomment when dalvik.annotation.Test* are removed or part of SDK
+LOCAL_SDK_VERSION := current
+
+include $(BUILD_PACKAGE)
+
diff --git a/tests/tests/openglperf/AndroidManifest.xml b/tests/tests/openglperf/AndroidManifest.xml
new file mode 100644
index 0000000..95a7cd1
--- /dev/null
+++ b/tests/tests/openglperf/AndroidManifest.xml
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 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.
+-->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.android.cts.openglperf"
+ android:versionCode="1"
+ android:versionName="1.0" >
+
+ <uses-feature android:glEsVersion="0x00020000" android:required="true" />
+ <instrumentation
+ android:targetPackage="com.android.cts.openglperf"
+ android:name="android.test.InstrumentationTestRunner" />
+ <application
+ android:label="@string/app_name" >
+ <uses-library android:name="android.test.runner" />
+ <activity
+ android:name="android.openglperf.cts.GlPlanetsActivity"
+ android:label="@string/app_name" >
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
+ <category android:name="android.intent.category.LAUNCHER" />
+ </intent-filter>
+ </activity>
+ </application>
+
+</manifest>
diff --git a/tests/tests/openglperf/assets/world_512_512.jpg b/tests/tests/openglperf/assets/world_512_512.jpg
new file mode 100644
index 0000000..b92bfae
--- /dev/null
+++ b/tests/tests/openglperf/assets/world_512_512.jpg
Binary files differ
diff --git a/tests/tests/openglperf/res/values/strings.xml b/tests/tests/openglperf/res/values/strings.xml
new file mode 100644
index 0000000..2cdba7f
--- /dev/null
+++ b/tests/tests/openglperf/res/values/strings.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 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.
+-->
+<resources>
+ <string name="app_name">OpenGlPerfTest</string>
+</resources>
\ No newline at end of file
diff --git a/tests/tests/openglperf/src/android/openglperf/cts/GlPlanetsActivity.java b/tests/tests/openglperf/src/android/openglperf/cts/GlPlanetsActivity.java
new file mode 100644
index 0000000..5a8c0a86
--- /dev/null
+++ b/tests/tests/openglperf/src/android/openglperf/cts/GlPlanetsActivity.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+package android.openglperf.cts;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.WindowManager;
+
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Activity which runs GL test and measure FPS with given parameters passed from
+ * Intent. For the meaning of parameters, check {@PlanetsRenderingParam}
+ */
+public class GlPlanetsActivity extends Activity implements
+ RenderCompletionListener {
+ public static final String INTENT_EXTRA_NUM_PLANETS = "numPlanets";
+ public static final String INTENT_EXTRA_USE_VBO_VERTICES = "useVboVertices";
+ public static final String INTENT_EXTRA_USE_VBO_INDICES = "useVboIndiices";
+ public static final String INTENT_EXTRA_NUM_FRAMES = "numFrames";
+ public static final String INTENT_EXTRA_INDICES_PER_VERTEX = "numIndicesPerVertex";
+
+ public static final String INTENT_RESULT_FPS = "fps";
+ public static final String INTENT_RESULT_NUM_TRIANGLES = "numTrigngles";
+
+ private final Semaphore mSem = new Semaphore(0);
+ private float mFps;
+ private int mNumTriangles;
+
+ private PlanetsSurfaceView mView;
+
+ public boolean waitForGlPlanetsCompletionWithTimeout(long timeoutInSecs)
+ throws InterruptedException {
+ return mSem.tryAcquire(timeoutInSecs, TimeUnit.SECONDS);
+ }
+
+ public float getFps() {
+ return mFps;
+ }
+
+ public int getNumTriangles() {
+ return mNumTriangles;
+ }
+
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+ Intent intent = getIntent();
+ PlanetsRenderingParam param = new PlanetsRenderingParam();
+ param.mNumPlanets = intent.getIntExtra(INTENT_EXTRA_NUM_PLANETS, param.mNumPlanets);
+ param.mUseVboForVertices = intent.getBooleanExtra(INTENT_EXTRA_USE_VBO_VERTICES,
+ param.mUseVboForVertices);
+ param.mUseVboForIndices = intent.getBooleanExtra(INTENT_EXTRA_USE_VBO_INDICES,
+ param.mUseVboForIndices);
+ param.mNumFrames = intent.getIntExtra(INTENT_EXTRA_NUM_FRAMES, param.mNumFrames);
+ param.mNumIndicesPerVertex = intent.getIntExtra(INTENT_EXTRA_INDICES_PER_VERTEX,
+ param.mNumIndicesPerVertex);
+ mView = new PlanetsSurfaceView(this, param, this);
+ setContentView(mView);
+ }
+
+ @Override
+ public void onRenderCompletion(float fps, int numTriangles) {
+ mFps = fps;
+ mNumTriangles = numTriangles;
+ mSem.release();
+ }
+
+ @Override
+ protected void onResume() {
+ super.onResume();
+ mView.onResume();
+ }
+
+ @Override
+ protected void onPause() {
+ super.onPause();
+ mView.onPause();
+ }
+}
\ No newline at end of file
diff --git a/tests/tests/openglperf/src/android/openglperf/cts/GlVboPerfTest.java b/tests/tests/openglperf/src/android/openglperf/cts/GlVboPerfTest.java
new file mode 100644
index 0000000..afd435c
--- /dev/null
+++ b/tests/tests/openglperf/src/android/openglperf/cts/GlVboPerfTest.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+package android.openglperf.cts;
+
+import android.app.Instrumentation;
+import android.content.Intent;
+import android.test.ActivityInstrumentationTestCase2;
+import android.util.Log;
+
+public class GlVboPerfTest extends
+ ActivityInstrumentationTestCase2<GlPlanetsActivity> {
+ private static final String TAG = "GlVboPerfTest";
+ private static final int NUM_FRAMES_TO_RENDER = 100;
+ private static final long RENDERING_TIMEOUT = 5 * 60;
+ // 10% of fps_no_vbo is allowed to compensate variations in measurement
+ private static final float FPS_COMPARISON_MARGIN = 0.1f;
+ // the worst case should be above 70% of the best case
+ private static final float FPS_MIN_MAX_COMPARISON_PERCENTILE = 0.7f;
+
+ private float mFps;
+ private int mNumTriangles;
+
+ public GlVboPerfTest() {
+ super(GlPlanetsActivity.class);
+ }
+
+ public void testVboWithVaryingIndexBufferNumbers() throws Exception {
+ final int[] numIndexBuffers = {1, 10, 100, 200, 400}; // per vertex buffer
+ float[] fpsVbo = new float[numIndexBuffers.length];
+ float[] fpsNonVbo = new float[numIndexBuffers.length];
+
+ for (int i = 0; i < numIndexBuffers.length; i++) {
+ runRendering(0, true, true, numIndexBuffers[i]);
+ fpsVbo[i] = mFps;
+ runRendering(0, true, false, numIndexBuffers[i]);
+ fpsNonVbo[i] = mFps;
+ }
+ StringBuilder msgIndex = new StringBuilder();
+ StringBuilder msgVbo = new StringBuilder();
+ StringBuilder msgNonVbo = new StringBuilder();
+ msgIndex.append("index buffer ");
+ msgVbo.append("Vbo ");
+ msgNonVbo.append("Non-Vbo ");
+ for (int i = 0; i < numIndexBuffers.length; i++) {
+ msgIndex.append(numIndexBuffers[i]).append(" ");
+ msgVbo.append(fpsVbo[i]).append(" ");
+ msgNonVbo.append(fpsNonVbo[i]).append(" ");
+ }
+ Log.i(TAG, msgIndex.toString());
+ Log.i(TAG, msgVbo.toString());
+ Log.i(TAG, msgNonVbo.toString());
+
+ float[] minMaxVbo = findMinMax(fpsVbo);
+ float[] minMaxNonVbo = findMinMax(fpsNonVbo);
+
+ float delta = minMaxVbo[1] - (1f - FPS_COMPARISON_MARGIN)
+ * minMaxNonVbo[1];
+ assertTrue("VBO performance worse than non-VBO " + msgVbo + msgNonVbo, delta > 0f);
+ assertTrue(
+ "Too much FPS drop for VBO case " + msgVbo,
+ minMaxVbo[0] > (FPS_MIN_MAX_COMPARISON_PERCENTILE * minMaxVbo[1]));
+ assertTrue(
+ "Too much FPS drop for No VBO case " + msgNonVbo,
+ minMaxNonVbo[0] > (FPS_MIN_MAX_COMPARISON_PERCENTILE * minMaxNonVbo[1]));
+ }
+
+ public void testVboVsNonVboPerfGeometry0() throws Exception {
+ doRunVboVsNonVboPerfTest(0);
+ }
+
+ public void testVboVsNonVboPerfGeometry1() throws Exception {
+ doRunVboVsNonVboPerfTest(4);
+ }
+
+ private void runRendering(int numPlanets, boolean useVboVertex, boolean useVboIndex,
+ int indicesPerVertex) throws Exception {
+ Intent intent = new Intent();
+ intent.putExtra(GlPlanetsActivity.INTENT_EXTRA_NUM_FRAMES,
+ NUM_FRAMES_TO_RENDER);
+ intent.putExtra(GlPlanetsActivity.INTENT_EXTRA_NUM_PLANETS, numPlanets);
+ intent.putExtra(GlPlanetsActivity.INTENT_EXTRA_USE_VBO_VERTICES, useVboVertex);
+ intent.putExtra(GlPlanetsActivity.INTENT_EXTRA_USE_VBO_INDICES, useVboIndex);
+ intent.putExtra(GlPlanetsActivity.INTENT_EXTRA_INDICES_PER_VERTEX, indicesPerVertex);
+
+ setActivityIntent(intent);
+ final GlPlanetsActivity activity = getActivity();
+ boolean waitResult = activity
+ .waitForGlPlanetsCompletionWithTimeout(RENDERING_TIMEOUT);
+ assertTrue("timeout while waiting for rendering completion", waitResult);
+
+ mFps = activity.getFps();
+ mNumTriangles = activity.getNumTriangles();
+
+ cleanUpActivity();
+ }
+
+ private void cleanUpActivity() throws Exception {
+ // finish the current activity and do clean-up so that a new activity
+ // can be launched in the same test run
+ super.tearDown();
+ super.setUp();
+ // wait until clean-up / set-up finishes
+ getInstrumentation().waitForIdleSync();
+ }
+
+ private void doRunVboVsNonVboPerfTest(int numPlanets) throws Exception {
+ runRendering(numPlanets, true, true, 1); // VBO
+ int numTrianglesVbo = mNumTriangles;
+ float fpsVbo = mFps;
+ runRendering(numPlanets, false, false, 1); // non-VBO
+
+ assertTrue("Number of triangles mismatch",
+ numTrianglesVbo == mNumTriangles);
+
+ // Margin amount of error is allowed due to measuring irregularity
+ float delta = fpsVbo - (1f - FPS_COMPARISON_MARGIN) * mFps;
+ StringBuilder testMsg = new StringBuilder();
+ testMsg.append("VBO performance worse than non-VBO ").append(fpsVbo).append(" ");
+ testMsg.append(mFps);
+ assertTrue(testMsg.toString(), delta > 0f);
+ }
+
+ private float[] findMinMax(float[] data) {
+ float min = data[0];
+ float max = data[0];
+
+ for (int i = 1; i < data.length; i++) {
+ if (data[i] > max) max = data[i];
+ if (data[i] < min) min = data[i];
+ }
+ float[] result = {min, max};
+ return result;
+ }
+}
diff --git a/tests/tests/openglperf/src/android/openglperf/cts/PlanetsRenderer.java b/tests/tests/openglperf/src/android/openglperf/cts/PlanetsRenderer.java
new file mode 100644
index 0000000..59a7782
--- /dev/null
+++ b/tests/tests/openglperf/src/android/openglperf/cts/PlanetsRenderer.java
@@ -0,0 +1,426 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+package android.openglperf.cts;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.opengl.GLES20;
+import android.opengl.GLSurfaceView;
+import android.opengl.GLUtils;
+import android.opengl.Matrix;
+import android.util.Log;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.System;
+import java.nio.FloatBuffer;
+import java.nio.ShortBuffer;
+
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.opengles.GL10;
+
+
+public class PlanetsRenderer implements GLSurfaceView.Renderer {
+
+ private static final String TAG = "PlanetsRenderer";
+ // texture is from
+ // http://en.wikipedia.org/wiki/File:Mercator_projection_SW.jpg
+ private static final String TEXTURE_FILE = "world_512_512.jpg";
+
+ private final Context mContext;
+ private final PlanetsRenderingParam mParam;
+ private final RenderCompletionListener mListener;
+
+ private final Sphere[] mSpheres;
+ private final int mNumSpheres;
+ private final int mNumIndices;
+ private final int mVboVertices[];
+ private final int mVboIndices[];
+
+ // configurations for sun and planets
+ private static final int SPHERE_SLICES = 180;
+ private static final float RADIUS_SUN = 0.4f;
+ private static final float RADIUS_PLANET = 0.08f;
+ private static final float RADIUS_ORBIT = 0.9f;
+
+ private int mWidth;
+ private int mHeight;
+
+ private int mFrameCount = 0;
+ private static final int FPS_DISPLAY_INTERVAL = 50;
+ private long mLastFPSTime;
+ // for total FPS measurement
+ private long mRenderingStartTime;
+ private long mMeasurementStartTime;
+
+ private int mProgram; // shader program
+ private int mMVPMatrixHandle;
+ private float[] mMVPMatrix = new float[16];
+ private float[] mMMatrix = new float[16];
+ private float[] mVMatrix = new float[16];
+ private float[] mProjMatrix = new float[16];
+
+ private int mOffsetHandle;
+ private static final float[] mDefaultOffset = { 0f, 0f, 0f, 1f };
+ private int mPositionHandle;
+ private int mTexCoord0Handle;
+ private int mTextureHandle;
+ private int mTextureId;
+
+ /**
+ * @param numSlices
+ * complexity of sphere used. A sphere will have (numSlices + 1)
+ * x (numSlices x 1) much of vertices
+ * @param useVbo
+ * whether to use Vertex Buffer Object in rendering or not
+ * @param framesToGo
+ * number of frames to render before calling completion to
+ * listener
+ * @param listener
+ */
+ public PlanetsRenderer(Context context, PlanetsRenderingParam param,
+ RenderCompletionListener listener) {
+ resetTimer();
+ mContext = context;
+ mParam = param;
+ mNumSpheres = mParam.mNumPlanets + 1; // 1 for sun
+ mNumIndices = mNumSpheres * mParam.mNumIndicesPerVertex;
+ mSpheres = new Sphere[mNumSpheres];
+
+ printParams();
+
+ // for big model, this construction phase takes time...
+ mSpheres[0] = new Sphere(SPHERE_SLICES, 0f, 0f, 0f, RADIUS_SUN,
+ mParam.mNumIndicesPerVertex);
+ for (int i = 1; i < mNumSpheres; i++) {
+ mSpheres[i] = new Sphere(SPHERE_SLICES,
+ RADIUS_ORBIT * (float) Math.sin(((float) i) / (mNumSpheres - 1) * 2 * Math.PI),
+ RADIUS_ORBIT * (float) Math.cos(((float) i) / (mNumSpheres - 1) * 2 * Math.PI),
+ 0f, RADIUS_PLANET, mParam.mNumIndicesPerVertex);
+ }
+ mVboVertices = new int[mNumSpheres];
+ mVboIndices = new int[mNumIndices];
+ mListener = listener;
+ measureTime("construction");
+ }
+
+ public void onSurfaceCreated(GL10 glUnused, EGLConfig config) {
+ mProgram = createProgram(getVertexShader(), getFragmentShader());
+ if (mProgram == 0) {
+ // error, cannot proceed
+ throw new IllegalStateException("createProgram failed");
+ }
+ mMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
+ mOffsetHandle = GLES20.glGetUniformLocation(mProgram, "uOffset");
+ mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");
+ mTexCoord0Handle = GLES20.glGetAttribLocation(mProgram, "vTexCoord0");
+ mTextureHandle = GLES20.glGetUniformLocation(mProgram, "sTexture");
+
+ // Load the texture
+ mTextureId = createTexture2D();
+ }
+
+ public void onDrawFrame(GL10 glUnused) {
+ long currentTime = System.currentTimeMillis();
+
+ mFrameCount++;
+ if ((mFrameCount % FPS_DISPLAY_INTERVAL == 0) && (mFrameCount != 0)) {
+ float fps = (((float) FPS_DISPLAY_INTERVAL)
+ / ((float) (currentTime - mLastFPSTime)) * 1000.0f);
+ Log.i(TAG, "FPS " + fps);
+ mLastFPSTime = currentTime;
+ }
+
+ if ((mFrameCount == mParam.mNumFrames) && (mParam.mNumFrames > 0)) {
+ long timePassed = currentTime - mRenderingStartTime;
+ float fps = ((float) mParam.mNumFrames) / ((float) timePassed) * 1000.0f;
+ printGlInfos();
+ printParams();
+ int numTriangles = mNumSpheres * mSpheres[0].getTotalIndices() / 3;
+ Log.i(TAG, "Final FPS " + fps + " Num triangles " + numTriangles);
+ if (mListener != null) {
+ mListener.onRenderCompletion(fps, numTriangles);
+ return;
+ }
+ }
+
+ float angle = 0.090f * ((int) (currentTime % 4000L));
+ Matrix.setRotateM(mMMatrix, 0, angle, 0, 0, 1.0f);
+ Matrix.multiplyMM(mMVPMatrix, 0, mVMatrix, 0, mMMatrix, 0);
+ Matrix.multiplyMM(mMVPMatrix, 0, mProjMatrix, 0, mMVPMatrix, 0);
+
+ GLES20.glUseProgram(mProgram);
+ GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+ GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);
+
+ // Apply a ModelView Projection transformation
+ GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mMVPMatrix, 0);
+ GLES20.glUniform4f(mOffsetHandle, mDefaultOffset[0], mDefaultOffset[1],
+ mDefaultOffset[2], mDefaultOffset[3]);
+
+ GLES20.glEnableVertexAttribArray(mPositionHandle);
+ GLES20.glEnableVertexAttribArray(mTexCoord0Handle);
+
+ // Bind the texture
+ GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+ GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureId);
+ // Set the sampler texture unit to 0
+ GLES20.glUniform1i(mTextureHandle, 0);
+
+ for (int i = 0; i < mNumSpheres; i++) {
+ if (mParam.mUseVboForVertices) {
+ // generating VBOs for each sphere is not efficient way for drawing
+ // multiple spheres
+ // But this is done for testing performance with big VBO buffers.
+ // So please do not copy this code as it is.
+ GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mVboVertices[i]);
+ // Load the vertex position
+ GLES20.glVertexAttribPointer(mPositionHandle, 3,
+ GLES20.GL_FLOAT, false, mSpheres[i].getVeticesStride(),
+ 0);
+ // Load the texture coordinate
+ GLES20.glVertexAttribPointer(mTexCoord0Handle, 3,
+ GLES20.GL_FLOAT, false, mSpheres[i].getVeticesStride(),
+ 3 * Sphere.FLOAT_SIZE);
+ } else {
+ // Load the vertex position
+ GLES20.glVertexAttribPointer(mPositionHandle, 3,
+ GLES20.GL_FLOAT, false, mSpheres[i].getVeticesStride(),
+ mSpheres[i].getVertices());
+ // Load the texture coordinate
+ GLES20.glVertexAttribPointer(mTexCoord0Handle, 3,
+ GLES20.GL_FLOAT, false, mSpheres[i].getVeticesStride(),
+ mSpheres[i].getVertices().duplicate().position(3));
+ }
+ int[] numIndices = mSpheres[i].getNumIndices();
+ ShortBuffer[] indices = mSpheres[i].getIndices();
+ if (mParam.mUseVboForIndices) {
+ int indexVboBase = i * mParam.mNumIndicesPerVertex;
+ for (int j = 0; j < numIndices.length; j++) {
+ GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER,
+ mVboIndices[indexVboBase + j]);
+ GLES20.glDrawElements(GLES20.GL_TRIANGLES,
+ numIndices[j], GLES20.GL_UNSIGNED_SHORT,
+ 0);
+ }
+ } else {
+ for (int j = 0; j < numIndices.length; j++) {
+ GLES20.glDrawElements(GLES20.GL_TRIANGLES,
+ numIndices[j], GLES20.GL_UNSIGNED_SHORT,
+ indices[j]);
+ }
+ }
+ }
+ }
+
+ public void onSurfaceChanged(GL10 glUnused, int width, int height) {
+ mWidth = width;
+ mHeight = height;
+ GLES20.glViewport(0, 0, width, height);
+ float ratio = (float) width / height;
+ Matrix.frustumM(mProjMatrix, 0, -ratio, ratio, -1, 1, 3, 7);
+ Matrix.setLookAtM(mVMatrix, 0, 0, 3, 3, 0f, 0f, 0f, 0f, 1.0f, 0.0f);
+
+ createVbo();
+
+ // reset timer to remove delays added for FPS calculation.
+ mLastFPSTime = System.currentTimeMillis();
+ mRenderingStartTime = System.currentTimeMillis();
+ }
+
+ protected final String getVertexShader() {
+ // simple shader with MVP matrix and text coord
+ final String vShaderStr =
+ "uniform mat4 uMVPMatrix; \n"
+ + "uniform vec4 uOffset; \n"
+ + "attribute vec4 vPosition; \n"
+ + "attribute vec2 vTexCoord0; \n"
+ + "varying vec2 vTexCoord; \n"
+ + "void main() \n"
+ + "{ \n"
+ + " gl_Position = uMVPMatrix * (vPosition + uOffset); \n"
+ + " vTexCoord = vTexCoord0; \n"
+ + "} \n";
+ return vShaderStr;
+ }
+
+ protected final String getFragmentShader() {
+ // simple shader with one texture for color
+ final String fShaderStr =
+ "precision mediump float; \n"
+ + "varying vec2 vTexCoord; \n"
+ + "uniform sampler2D sTexture; \n"
+ + "void main() \n"
+ + "{ \n"
+ + " gl_FragColor = texture2D( sTexture, vTexCoord );\n"
+ + "} \n";
+ return fShaderStr;
+ }
+
+ private int loadShader(int shaderType, String source) {
+ int shader = GLES20.glCreateShader(shaderType);
+ if (shader != 0) {
+ GLES20.glShaderSource(shader, source);
+ GLES20.glCompileShader(shader);
+ int[] compiled = new int[1];
+ GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0);
+ if (compiled[0] == 0) {
+ Log.e(TAG, "Could not compile shader " + shaderType + ":");
+ Log.e(TAG, GLES20.glGetShaderInfoLog(shader));
+ GLES20.glDeleteShader(shader);
+ shader = 0;
+ }
+ }
+ return shader;
+ }
+
+ private int createProgram(String vertexSource, String fragmentSource) {
+ int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource);
+ if (vertexShader == 0) {
+ return 0;
+ }
+
+ int pixelShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource);
+ if (pixelShader == 0) {
+ return 0;
+ }
+
+ int program = GLES20.glCreateProgram();
+ if (program != 0) {
+ GLES20.glAttachShader(program, vertexShader);
+ checkGlError("glAttachShader");
+ GLES20.glAttachShader(program, pixelShader);
+ checkGlError("glAttachShader");
+ GLES20.glLinkProgram(program);
+ int[] linkStatus = new int[1];
+ GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0);
+ if (linkStatus[0] != GLES20.GL_TRUE) {
+ Log.e(TAG, "Could not link program: ");
+ Log.e(TAG, GLES20.glGetProgramInfoLog(program));
+ GLES20.glDeleteProgram(program);
+ program = 0;
+ }
+ }
+ return program;
+ }
+
+ private int createTexture2D() {
+ // Texture object handle
+ int[] textureId = new int[1];
+
+ InputStream in = null;
+ try {
+ in = mContext.getAssets().open(TEXTURE_FILE);
+ Bitmap bitmap = BitmapFactory.decodeStream(in);
+
+ // Generate a texture object
+ GLES20.glGenTextures(1, textureId, 0);
+
+ // Bind the texture object
+ GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureId[0]);
+ GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 0);
+
+ // Set the filtering mode
+ GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D,
+ GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
+ GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D,
+ GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
+
+ } catch (IOException e) {
+ throw new IllegalStateException("Couldn't load texture '" + TEXTURE_FILE
+ + "'", e);
+ } finally {
+ if (in != null)
+ try {
+ in.close();
+ } catch (IOException e) {
+ }
+ }
+
+ return textureId[0];
+ }
+
+ private void checkGlError(String op) {
+ int error;
+ while ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR) {
+ Log.e(TAG, op + ": glError " + error);
+ throw new IllegalStateException(op + ": glError " + error);
+ }
+ }
+
+ private void createVbo() {
+ resetTimer();
+ if (mParam.mUseVboForVertices) {
+ GLES20.glGenBuffers(mNumSpheres, mVboVertices, 0);
+ checkGlError("glGenBuffers Vertex");
+ for (int i = 0; i < mNumSpheres; i++) {
+ GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, mVboVertices[i]);
+ FloatBuffer vertices = mSpheres[i].getVertices();
+ GLES20.glBufferData(GLES20.GL_ARRAY_BUFFER, vertices.limit()
+ * Sphere.FLOAT_SIZE, vertices, GLES20.GL_STATIC_DRAW);
+ checkGlError("glBufferData Vertex");
+ mSpheres[i].releaseVertexBuffer(); // release memory
+ }
+ }
+ if (mParam.mUseVboForIndices) {
+ GLES20.glGenBuffers(mNumIndices, mVboIndices, 0);
+ checkGlError("glGenBuffers Index");
+ for (int i = 0; i < mNumSpheres; i++) {
+ int[] numIndices = mSpheres[i].getNumIndices();
+ ShortBuffer[] indices = mSpheres[i].getIndices();
+ int indexVboBase = i * mParam.mNumIndicesPerVertex;
+ for (int j = 0; j < numIndices.length; j++) {
+ GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER,
+ mVboIndices[indexVboBase + j]);
+ GLES20.glBufferData(GLES20.GL_ELEMENT_ARRAY_BUFFER,
+ indices[j].limit() * Sphere.SHORT_SIZE, indices[j],
+ GLES20.GL_STATIC_DRAW);
+ checkGlError("glBufferData Index");
+
+ }
+ mSpheres[i].releaseIndexBuffer(); // release memory
+ }
+ }
+ GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0);
+ GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, 0);
+ measureTime("VBO creation");
+ }
+
+ private void resetTimer() {
+ mMeasurementStartTime = System.currentTimeMillis();
+ }
+
+ private void measureTime(String description) {
+ long currentTime = System.currentTimeMillis();
+ float timePassedInSecs = (float) (currentTime - mMeasurementStartTime) / 1000f;
+ Log.i(TAG, description + " time in secs: " + timePassedInSecs);
+ }
+
+ private void printGlInfos() {
+ Log.i(TAG, "Vendor " + GLES20.glGetString(GLES20.GL_VENDOR));
+ Log.i(TAG, "Version " + GLES20.glGetString(GLES20.GL_VERSION));
+ Log.i(TAG, "Renderer " + GLES20.glGetString(GLES20.GL_RENDERER));
+ Log.i(TAG, "Extensions " + GLES20.glGetString(GLES20.GL_EXTENSIONS));
+ }
+ private void printParams() {
+ Log.i(TAG, "UseVboForVertex " + mParam.mUseVboForVertices);
+ Log.i(TAG, "UseVboForIndex " + mParam.mUseVboForIndices);
+ Log.i(TAG, "No Spheres " + mNumSpheres);
+ Log.i(TAG, "No indices buffer per vertex " + mParam.mNumIndicesPerVertex);
+ }
+}
diff --git a/tests/tests/openglperf/src/android/openglperf/cts/PlanetsRenderingParam.java b/tests/tests/openglperf/src/android/openglperf/cts/PlanetsRenderingParam.java
new file mode 100644
index 0000000..5e2dfd0
--- /dev/null
+++ b/tests/tests/openglperf/src/android/openglperf/cts/PlanetsRenderingParam.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+package android.openglperf.cts;
+
+public class PlanetsRenderingParam {
+ /** whether to use VBO for vertices data */
+ public boolean mUseVboForVertices = true;
+ /** whether to use VBO for indices data */
+ public boolean mUseVboForIndices = true;
+ /** number of indices buffer per one vertices buffer */
+ public int mNumIndicesPerVertex = 1;
+ /** number of planets to render. There is always a sun */
+ public int mNumPlanets = 0;
+ /** number of frames to render to calculate FPS and finish */
+ public int mNumFrames = 100;
+}
diff --git a/tests/tests/openglperf/src/android/openglperf/cts/PlanetsSurfaceView.java b/tests/tests/openglperf/src/android/openglperf/cts/PlanetsSurfaceView.java
new file mode 100644
index 0000000..526f706
--- /dev/null
+++ b/tests/tests/openglperf/src/android/openglperf/cts/PlanetsSurfaceView.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+package android.openglperf.cts;
+
+import android.content.Context;
+import android.opengl.GLSurfaceView;
+
+class PlanetsSurfaceView extends GLSurfaceView {
+
+ public PlanetsSurfaceView(Context context, PlanetsRenderingParam param,
+ RenderCompletionListener listener) {
+ super(context);
+
+ setEGLContextClientVersion(2);
+ setRenderer(new PlanetsRenderer(context, param, listener));
+ }
+
+ @Override
+ public void onPause() {
+ super.onPause();
+ setRenderMode(RENDERMODE_WHEN_DIRTY);
+ }
+
+ @Override
+ public void onResume() {
+ setRenderMode(RENDERMODE_CONTINUOUSLY);
+ super.onResume();
+ }
+}
\ No newline at end of file
diff --git a/tests/tests/openglperf/src/android/openglperf/cts/RenderCompletionListener.java b/tests/tests/openglperf/src/android/openglperf/cts/RenderCompletionListener.java
new file mode 100644
index 0000000..1643087e
--- /dev/null
+++ b/tests/tests/openglperf/src/android/openglperf/cts/RenderCompletionListener.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+package android.openglperf.cts;
+
+public interface RenderCompletionListener {
+ /**
+ * @param fps total frame rate
+ * @param numTriangles Number of triangles in geometric model
+ */
+ void onRenderCompletion(float fps, int numTriangles);
+
+}
diff --git a/tests/tests/openglperf/src/android/openglperf/cts/Sphere.java b/tests/tests/openglperf/src/android/openglperf/cts/Sphere.java
new file mode 100644
index 0000000..e8876dd
--- /dev/null
+++ b/tests/tests/openglperf/src/android/openglperf/cts/Sphere.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+package android.openglperf.cts;
+
+import java.lang.Math;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+import java.nio.ShortBuffer;
+
+/*
+ * Class for generating a sphere model for given input params
+ * The generated class will have vertices and indices
+ * Vertices data is composed of vertex coordinates in x, y, z followed by
+ * texture coordinates s, t for each vertex
+ * Indices store vertex indices for the whole sphere.
+ * Formula for generating sphere is originally coming from source code of
+ * OpenGL ES2.0 Programming guide
+ * which is available from http://code.google.com/p/opengles-book-samples/,
+ * but some changes were made to make texture look right.
+ */
+public class Sphere {
+ public static final int FLOAT_SIZE = 4;
+ public static final int SHORT_SIZE = 2;
+
+ private FloatBuffer mVertices;
+ private ShortBuffer[] mIndices;
+ private int[] mNumIndices;
+ private int mTotalIndices;
+
+ /*
+ * @param nSlices how many slice in horizontal direction.
+ * The same slice for vertical direction is applied.
+ * nSlices should be > 1 and should be <= 180
+ * @param x,y,z the origin of the sphere
+ * @param r the radius of the sphere
+ */
+ public Sphere(int nSlices, float x, float y, float z, float r, int indicesPerVertex) {
+
+ int iMax = nSlices + 1;
+ int nVertices = iMax * iMax;
+ if (nVertices > Short.MAX_VALUE) {
+ // this cannot be handled in one vertices / indices pair
+ throw new RuntimeException("nSlices " + nSlices + " too big for vertex");
+ }
+ mTotalIndices = nSlices * nSlices * 6;
+ float angleStepI = ((float) Math.PI / nSlices);
+ float angleStepJ = ((2.0f * (float) Math.PI) / nSlices);
+
+ // 3 vertex coords + 2 texture coords
+ mVertices = ByteBuffer.allocateDirect(nVertices * 5 * FLOAT_SIZE)
+ .order(ByteOrder.nativeOrder()).asFloatBuffer();
+ mIndices = new ShortBuffer[indicesPerVertex];
+ mNumIndices = new int[indicesPerVertex];
+ // first evenly distribute to n-1 buffers, then put remaining ones to the last one.
+ int noIndicesPerBuffer = (mTotalIndices / indicesPerVertex / 6) * 6;
+ for (int i = 0; i < indicesPerVertex - 1; i++) {
+ mNumIndices[i] = noIndicesPerBuffer;
+ }
+ mNumIndices[indicesPerVertex - 1] = mTotalIndices - noIndicesPerBuffer *
+ (indicesPerVertex - 1);
+
+ for (int i = 0; i < indicesPerVertex; i++) {
+ mIndices[i] = ByteBuffer.allocateDirect(mNumIndices[i] * SHORT_SIZE)
+ .order(ByteOrder.nativeOrder()).asShortBuffer();
+ }
+ // calling put for each float took too much CPU time, so put by line instead
+ float[] vLineBuffer = new float[iMax * 5];
+ for (int i = 0; i < iMax; i++) {
+ for (int j = 0; j < iMax; j++) {
+ int vertexBase = j * 5;
+ float sini = (float) Math.sin(angleStepI * i);
+ float sinj = (float) Math.sin(angleStepJ * j);
+ float cosi = (float) Math.cos(angleStepI * i);
+ float cosj = (float) Math.cos(angleStepJ * j);
+ // vertex x,y,z
+ vLineBuffer[vertexBase + 0] = x + r * sini * sinj;
+ vLineBuffer[vertexBase + 1] = y + r * sini * cosj;
+ vLineBuffer[vertexBase + 2] = z + r * cosi;
+ // texture s,t
+ vLineBuffer[vertexBase + 3] = (float) j / (float) nSlices;
+ vLineBuffer[vertexBase + 4] = (1.0f - i) / (float)nSlices;
+ }
+ mVertices.put(vLineBuffer, 0, vLineBuffer.length);
+ }
+
+ short[] indexBuffer = new short[max(mNumIndices)];
+ int index = 0;
+ int bufferNum = 0;
+ for (int i = 0; i < nSlices; i++) {
+ for (int j = 0; j < nSlices; j++) {
+ int i1 = i + 1;
+ int j1 = j + 1;
+ if (index >= mNumIndices[bufferNum]) {
+ // buffer ready for moving to target
+ mIndices[bufferNum].put(indexBuffer, 0, mNumIndices[bufferNum]);
+ // move to the next one
+ index = 0;
+ bufferNum++;
+ }
+ indexBuffer[index++] = (short) (i * iMax + j);
+ indexBuffer[index++] = (short) (i1 * iMax + j);
+ indexBuffer[index++] = (short) (i1 * iMax + j1);
+ indexBuffer[index++] = (short) (i * iMax + j);
+ indexBuffer[index++] = (short) (i1 * iMax + j1);
+ indexBuffer[index++] = (short) (i * iMax + j1);
+ }
+ }
+ mIndices[bufferNum].put(indexBuffer, 0, mNumIndices[bufferNum]);
+
+ mVertices.position(0);
+ for (int i = 0; i < indicesPerVertex; i++) {
+ mIndices[i].position(0);
+ }
+ }
+
+ public FloatBuffer getVertices() {
+ return mVertices;
+ }
+
+ public int getVeticesStride() {
+ return 5*FLOAT_SIZE;
+ }
+
+ public ShortBuffer[] getIndices() {
+ return mIndices;
+ }
+
+ public int[] getNumIndices() {
+ return mNumIndices;
+ }
+
+ public int getTotalIndices() {
+ return mTotalIndices;
+ }
+ /** once VBO buffer is generated, model data can be dropped */
+ public void releaseVertexBuffer() {
+ mVertices = null;
+ }
+
+ public void releaseIndexBuffer() {
+ mVertices = null;
+ }
+
+ private int max(int[] array) {
+ int max = array[0];
+ for (int i = 1; i < array.length; i++) {
+ if (array[i] > max) max = array[i];
+ }
+ return max;
+ }
+}
