Add a Java API for OpenGL ES 2.0. (b3a5352b) · Commits · e / os / android_frameworks_native-old

opengl/tests/gl2_java/Android.mk

0 → 100644

+18 −0

Original line number	Diff line number	Diff line
		#########################################################################
		# OpenGL ES 2.0 Java sample
		#########################################################################

		TOP_LOCAL_PATH:= $(call my-dir)

		# Build activity

		LOCAL_PATH:= $(call my-dir)
		include $(CLEAR_VARS)

		LOCAL_MODULE_TAGS := optional

		LOCAL_SRC_FILES := $(call all-subdir-java-files)

		LOCAL_PACKAGE_NAME := GL2Java

		include $(BUILD_PACKAGE)

opengl/tests/gl2_java/AndroidManifest.xml

0 → 100644

+35 −0

Original line number	Diff line number	Diff line
		<?xml version="1.0" encoding="utf-8"?>
		<!--
		/*
		**
		** Copyright 2009, 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.gl2java">
		<application
		android:label="@string/gl2java_activity">
		<activity android:name="GL2JavaActivity"
		android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
		android:launchMode="singleTask"
		android:configChanges="orientation\|keyboardHidden">
		<intent-filter>
		<action android:name="android.intent.action.MAIN" />
		<category android:name="android.intent.category.LAUNCHER" />
		</intent-filter>
		</activity>
		</application>
		</manifest>

opengl/tests/gl2_java/res/values/strings.xml

0 → 100644

+29 −0

Original line number	Diff line number	Diff line
		<?xml version="1.0" encoding="utf-8"?>
		<!--
		/*
		**
		** Copyright 2006, 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.
		*/
		-->

		<!-- This file contains resource definitions for displayed strings, allowing
		them to be changed based on the locale and options. -->

		<resources>
		<!-- Simple strings. -->
		<string name="gl2java_activity">GL2Java</string>

		</resources>

opengl/tests/gl2_java/src/com/android/gl2java/GL2JavaActivity.java

0 → 100644

+46 −0

Original line number	Diff line number	Diff line
		/*
		* 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.
		*/

		package com.android.gl2java;

		import android.app.Activity;
		import android.os.Bundle;
		import android.util.Log;
		import android.view.WindowManager;

		import java.io.File;


		public class GL2JavaActivity extends Activity {

		GL2JavaView mView;

		@Override protected void onCreate(Bundle icicle) {
		super.onCreate(icicle);
		mView = new GL2JavaView(getApplication());
		setContentView(mView);
		}

		@Override protected void onPause() {
		super.onPause();
		mView.onPause();
		}

		@Override protected void onResume() {
		super.onResume();
		mView.onResume();
		}
		}

opengl/tests/gl2_java/src/com/android/gl2java/GL2JavaView.java

0 → 100644

+386 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2009 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 com.android.gl2java;

		import android.content.Context;
		import android.opengl.GLSurfaceView;
		import android.util.AttributeSet;
		import android.util.Log;
		import android.view.KeyEvent;
		import android.view.MotionEvent;

		import java.nio.ByteBuffer;
		import java.nio.ByteOrder;
		import java.nio.FloatBuffer;

		import javax.microedition.khronos.egl.EGL10;
		import javax.microedition.khronos.egl.EGLConfig;
		import javax.microedition.khronos.egl.EGLContext;
		import javax.microedition.khronos.egl.EGLDisplay;
		import javax.microedition.khronos.opengles.GL10;

		import android.opengl.GLES20;

		/**
		* An implementation of SurfaceView that uses the dedicated surface for
		* displaying an OpenGL animation. This allows the animation to run in a
		* separate thread, without requiring that it be driven by the update mechanism
		* of the view hierarchy.
		*
		* The application-specific rendering code is delegated to a GLView.Renderer
		* instance.
		*/
		class GL2JavaView extends GLSurfaceView {
		private static String TAG = "GL2JavaView";

		public GL2JavaView(Context context) {
		super(context);
		init(false, 0, 0);
		}

		public GL2JavaView(Context context, boolean translucent, int depth, int stencil) {
		super(context);
		init(translucent, depth, stencil);
		}

		private void init(boolean translucent, int depth, int stencil) {
		setEGLContextFactory(new ContextFactory());
		setEGLConfigChooser( translucent ?
		new ConfigChooser(8,8,8,8, depth, stencil) :
		new ConfigChooser(5,6,5,0, depth, stencil));
		setRenderer(new Renderer());
		}

		private static class ContextFactory implements GLSurfaceView.EGLContextFactory {
		private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
		public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig) {
		Log.w(TAG, "creating OpenGL ES 2.0 context");
		checkEglError("Before eglCreateContext", egl);
		int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };
		EGLContext context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);
		checkEglError("After eglCreateContext", egl);
		return context;
		}

		public void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context) {
		egl.eglDestroyContext(display, context);
		}
		}

		private static void checkEglError(String prompt, EGL10 egl) {
		int error;
		while ((error = egl.eglGetError()) != EGL10.EGL_SUCCESS) {
		Log.e(TAG, String.format("%s: EGL error: 0x%x", prompt, error));
		}
		}

		private static class ConfigChooser implements GLSurfaceView.EGLConfigChooser {
		private static int EGL_OPENGL_ES2_BIT = 4;
		private static int[] s_configAttribs2 =
		{
		EGL10.EGL_RED_SIZE, 4,
		EGL10.EGL_GREEN_SIZE, 4,
		EGL10.EGL_BLUE_SIZE, 4,
		EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
		EGL10.EGL_NONE
		};

		public ConfigChooser(int r, int g, int b, int a, int depth, int stencil) {
		mRedSize = r;
		mGreenSize = g;
		mBlueSize = b;
		mAlphaSize = a;
		mDepthSize = depth;
		mStencilSize = stencil;
		}

		public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {

		int[] num_config = new int[1];
		egl.eglChooseConfig(display, s_configAttribs2, null, 0, num_config);

		int numConfigs = num_config[0];

		if (numConfigs <= 0) {
		throw new IllegalArgumentException("No configs match configSpec");
		}
		EGLConfig[] configs = new EGLConfig[numConfigs];
		egl.eglChooseConfig(display, s_configAttribs2, configs, numConfigs, num_config);
		// printConfigs(egl, display, configs);
		return chooseConfig(egl, display, configs);
		}

		public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,
		EGLConfig[] configs) {
		EGLConfig closestConfig = null;
		int closestDistance = 1000;
		for(EGLConfig config : configs) {
		int d = findConfigAttrib(egl, display, config,
		EGL10.EGL_DEPTH_SIZE, 0);
		int s = findConfigAttrib(egl, display, config,
		EGL10.EGL_STENCIL_SIZE, 0);
		if (d >= mDepthSize && s>= mStencilSize) {
		int r = findConfigAttrib(egl, display, config,
		EGL10.EGL_RED_SIZE, 0);
		int g = findConfigAttrib(egl, display, config,
		EGL10.EGL_GREEN_SIZE, 0);
		int b = findConfigAttrib(egl, display, config,
		EGL10.EGL_BLUE_SIZE, 0);
		int a = findConfigAttrib(egl, display, config,
		EGL10.EGL_ALPHA_SIZE, 0);
		int distance = Math.abs(r - mRedSize)
		+ Math.abs(g - mGreenSize)
		+ Math.abs(b - mBlueSize)
		+ Math.abs(a - mAlphaSize);
		if (distance < closestDistance) {
		closestDistance = distance;
		closestConfig = config;
		}
		}
		}
		return closestConfig;
		}

		private int findConfigAttrib(EGL10 egl, EGLDisplay display,
		EGLConfig config, int attribute, int defaultValue) {

		if (egl.eglGetConfigAttrib(display, config, attribute, mValue)) {
		return mValue[0];
		}
		return defaultValue;
		}

		private void printConfigs(EGL10 egl, EGLDisplay display,
		EGLConfig[] configs) {
		int numConfigs = configs.length;
		Log.w(TAG, String.format("%d configurations", numConfigs));
		for (int i = 0; i < numConfigs; i++) {
		Log.w(TAG, String.format("Configuration %d:\n", i));
		printConfig(egl, display, configs[i]);
		}
		}

		private void printConfig(EGL10 egl, EGLDisplay display,
		EGLConfig config) {
		int[] attributes = {
		EGL10.EGL_BUFFER_SIZE,
		EGL10.EGL_ALPHA_SIZE,
		EGL10.EGL_BLUE_SIZE,
		EGL10.EGL_GREEN_SIZE,
		EGL10.EGL_RED_SIZE,
		EGL10.EGL_DEPTH_SIZE,
		EGL10.EGL_STENCIL_SIZE,
		EGL10.EGL_CONFIG_CAVEAT,
		EGL10.EGL_CONFIG_ID,
		EGL10.EGL_LEVEL,
		EGL10.EGL_MAX_PBUFFER_HEIGHT,
		EGL10.EGL_MAX_PBUFFER_PIXELS,
		EGL10.EGL_MAX_PBUFFER_WIDTH,
		EGL10.EGL_NATIVE_RENDERABLE,
		EGL10.EGL_NATIVE_VISUAL_ID,
		EGL10.EGL_NATIVE_VISUAL_TYPE,
		0x3030, // EGL10.EGL_PRESERVED_RESOURCES,
		EGL10.EGL_SAMPLES,
		EGL10.EGL_SAMPLE_BUFFERS,
		EGL10.EGL_SURFACE_TYPE,
		EGL10.EGL_TRANSPARENT_TYPE,
		EGL10.EGL_TRANSPARENT_RED_VALUE,
		EGL10.EGL_TRANSPARENT_GREEN_VALUE,
		EGL10.EGL_TRANSPARENT_BLUE_VALUE,
		0x3039, // EGL10.EGL_BIND_TO_TEXTURE_RGB,
		0x303A, // EGL10.EGL_BIND_TO_TEXTURE_RGBA,
		0x303B, // EGL10.EGL_MIN_SWAP_INTERVAL,
		0x303C, // EGL10.EGL_MAX_SWAP_INTERVAL,
		EGL10.EGL_LUMINANCE_SIZE,
		EGL10.EGL_ALPHA_MASK_SIZE,
		EGL10.EGL_COLOR_BUFFER_TYPE,
		EGL10.EGL_RENDERABLE_TYPE,
		0x3042 // EGL10.EGL_CONFORMANT
		};
		String[] names = {
		"EGL_BUFFER_SIZE",
		"EGL_ALPHA_SIZE",
		"EGL_BLUE_SIZE",
		"EGL_GREEN_SIZE",
		"EGL_RED_SIZE",
		"EGL_DEPTH_SIZE",
		"EGL_STENCIL_SIZE",
		"EGL_CONFIG_CAVEAT",
		"EGL_CONFIG_ID",
		"EGL_LEVEL",
		"EGL_MAX_PBUFFER_HEIGHT",
		"EGL_MAX_PBUFFER_PIXELS",
		"EGL_MAX_PBUFFER_WIDTH",
		"EGL_NATIVE_RENDERABLE",
		"EGL_NATIVE_VISUAL_ID",
		"EGL_NATIVE_VISUAL_TYPE",
		"EGL_PRESERVED_RESOURCES",
		"EGL_SAMPLES",
		"EGL_SAMPLE_BUFFERS",
		"EGL_SURFACE_TYPE",
		"EGL_TRANSPARENT_TYPE",
		"EGL_TRANSPARENT_RED_VALUE",
		"EGL_TRANSPARENT_GREEN_VALUE",
		"EGL_TRANSPARENT_BLUE_VALUE",
		"EGL_BIND_TO_TEXTURE_RGB",
		"EGL_BIND_TO_TEXTURE_RGBA",
		"EGL_MIN_SWAP_INTERVAL",
		"EGL_MAX_SWAP_INTERVAL",
		"EGL_LUMINANCE_SIZE",
		"EGL_ALPHA_MASK_SIZE",
		"EGL_COLOR_BUFFER_TYPE",
		"EGL_RENDERABLE_TYPE",
		"EGL_CONFORMANT"
		};
		int[] value = new int[1];
		for (int i = 0; i < attributes.length; i++) {
		int attribute = attributes[i];
		String name = names[i];
		if ( egl.eglGetConfigAttrib(display, config, attribute, value)) {
		Log.w(TAG, String.format(" %s: %d\n", name, value[0]));
		} else {
		// Log.w(TAG, String.format(" %s: failed\n", name));
		while (egl.eglGetError() != EGL10.EGL_SUCCESS);
		}
		}
		}

		// Subclasses can adjust these values:
		protected int mRedSize;
		protected int mGreenSize;
		protected int mBlueSize;
		protected int mAlphaSize;
		protected int mDepthSize;
		protected int mStencilSize;
		private int[] mValue = new int[1];
		}

		private static class Renderer implements GLSurfaceView.Renderer {

		public Renderer() {
		mTriangleVertices = ByteBuffer.allocateDirect(mTriangleVerticesData.length * 4)
		.order(ByteOrder.nativeOrder()).asFloatBuffer();
		mTriangleVertices.put(mTriangleVerticesData).position(0);
		}

		public void onDrawFrame(GL10 gl) {
		GLES20.glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
		GLES20.glClear( GLES20.GL_DEPTH_BUFFER_BIT \| GLES20.GL_COLOR_BUFFER_BIT);
		GLES20.glUseProgram(mProgram);
		checkGlError("glUseProgram");

		GLES20.glVertexAttribPointer(mvPositionHandle, 2, GLES20.GL_FLOAT, false, 0, mTriangleVertices);
		checkGlError("glVertexAttribPointer");
		GLES20.glEnableVertexAttribArray(mvPositionHandle);
		checkGlError("glEnableVertexAttribArray");
		GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 3);
		checkGlError("glDrawArrays");

		}

		public void onSurfaceChanged(GL10 gl, int width, int height) {
		GLES20.glViewport(0, 0, width, height);
		}

		public void onSurfaceCreated(GL10 gl, EGLConfig config) {
		mProgram = createProgram(mVertexShader, mFragmentShader);
		if (mProgram == 0) {
		return;
		}
		mvPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");
		checkGlError("glGetAttribLocation");
		if (mvPositionHandle == -1) {
		throw new RuntimeException("Could not get attrib location for vPosition");
		}
		}

		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 void checkGlError(String op) {
		int error;
		while ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR) {
		Log.e(TAG, op + ": glError " + error);
		throw new RuntimeException(op + ": glError " + error);
		}
		}

		private final float[] mTriangleVerticesData = { 0.0f, 0.5f, -0.5f, -0.5f,
		0.5f, -0.5f };

		private FloatBuffer mTriangleVertices;

		private final String mVertexShader = "attribute vec4 vPosition;\n"
		+ "void main() {\n"
		+ " gl_Position = vPosition;\n"
		+ "}\n";

		private final String mFragmentShader = "precision mediump float;\n"
		+ "void main() {\n"
		+ " gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0);\n"
		+ "}\n";

		private int mProgram;
		private int mvPositionHandle;

		}
		}