//---------------------------------------------------------------------------------- // File: libs\src\com\nvidia\devtech\NvGLESActivity.java // Samples Version: Android NVIDIA samples 1.0 // Email: tegradev@nvidia.com // Forum: http://developer.nvidia.com/tegra/forums/tegra-forums/android-development // // Copyright 2010-2011 NVIDIA® Corporation // // 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.nvidia.devtech; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; 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.egl.EGLSurface; import javax.microedition.khronos.opengles.GL11; import android.app.AlertDialog; import android.content.DialogInterface; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.view.SurfaceHolder; import android.view.SurfaceView; import android.view.View; import android.view.ViewGroup; import android.view.SurfaceHolder.Callback; import android.widget.TextView; /** * While {@link NvActivity} takes care of the basis of an application in the NVIDIA samples, * NvGLESActivity takes the step further by executing the necessary steps in creating * a GLES1 sample. There are also some useful helper functions created for loading textures and * maintaining the render loop, pausing and resuming as necessary. */ public abstract class NvGLESActivity extends NvActivity { EGL10 egl = null; GL11 gl = null; private boolean ranInit = false; private boolean paused = false; protected EGLSurface eglSurface = null; protected EGLDisplay eglDisplay = null; protected EGLContext eglContext = null; protected EGLConfig eglConfig = null; private Runnable initRunnable = null; private Runnable painter = null; private int surfaceWidth = 0; private int surfaceHeight = 0; private TextView fpsText = null; protected SurfaceView surfaceView = null; /** * Helper class used to pass raw data around. */ public class RawData { /** The actual data bytes. */ public byte[] data; /** The length of the data. */ public int length; } /** * Helper class used to pass a raw texture around. */ public class RawTexture extends RawData { /** The width of the texture. */ public int width; /** The height of the texture. */ public int height; } /** * Helper function to load a file into a {@link NvGLESActivity.RawData} object. * It'll first try loading the file from "/data/" and if the file doesn't * exist there, it'll try loading it from the assets directory inside the * .APK file. This is to allow the files inside the apk to be overridden * or not be part of the .APK at all during the development phase of the * application, decreasing the size needed to be transmitted to the device * between changes to the code. * * @param filename The file to load. * @return The RawData object representing the file's fully loaded data, * or null if loading failed. */ public RawData loadFile(String filename) { InputStream is = null; RawData ret = new RawData(); try { try { is = new FileInputStream("/data/" + filename); } catch (Exception e) { try { is = getAssets().open(filename); } catch (Exception e2) { } } int size = is.available(); ret.length = size; ret.data = new byte[size]; is.read(ret.data); } catch (IOException ioe) { } finally { if (is != null) { try { is.close(); } catch (Exception e) {} } } return ret; } /** * Helper function to load a texture file into a {@link NvGLESActivity.RawTexture} object. * It'll first try loading the texture from "/data/" and if the file doesn't * exist there, it'll try loading it from the assets directory inside the * .APK file. This is to allow the files inside the apk to be overridden * or not be part of the .APK at all during the development phase of the * application, decreasing the size needed to be transmitted to the device * between changes to the code. * * The texture data will be flipped and bit-twiddled to fit being loaded directly * into OpenGL ES via the glTexImage2D call. * * @param filename The file to load. * @return The RawTexture object representing the texture's fully loaded data, * or null if loading failed. */ public RawTexture loadTexture(String filename) { RawTexture ret = new RawTexture(); try { InputStream is = null; try { is = new FileInputStream("/data/" + filename); } catch (Exception e) { try { is = getAssets().open(filename); } catch (Exception e2) { } } Bitmap bmp = BitmapFactory.decodeStream(is); ret.width = bmp.getWidth(); ret.height = bmp.getHeight(); int[] pixels = new int[bmp.getWidth() * bmp.getHeight()]; bmp.getPixels(pixels, 0, bmp.getWidth(), 0, 0, bmp.getWidth(), bmp.getHeight()); // Flip texture int[] tmp = new int[bmp.getWidth()]; final int w = bmp.getWidth(); final int h = bmp.getHeight(); for (int i = 0; i < h>>1; i++) { System.arraycopy(pixels, i*w, tmp, 0, w); System.arraycopy(pixels, (h-1-i)*w, pixels, i*w, w); System.arraycopy(tmp, 0, pixels, (h-1-i)*w, w); } // Convert from ARGB -> RGBA and put into the byte array ret.length = pixels.length * 4; ret.data = new byte[ret.length]; int pos = 0; int bpos = 0; for (int y = 0; y < h; y++) { for (int x = 0; x < w; x++, pos++) { int p = pixels[pos]; ret.data[bpos++] = (byte) ((p>>16)&0xff); ret.data[bpos++] = (byte) ((p>> 8)&0xff); ret.data[bpos++] = (byte) ((p>> 0)&0xff); ret.data[bpos++] = (byte) ((p>>24)&0xff); } } } catch (Exception e) { e.printStackTrace(); } return ret; } @Override protected void onPause() { super.onPause(); handler.removeCallbacks(painter); paused = true; } @Override protected void onResume() { super.onResume(); paused = false; handler.post(painter); } @Override protected boolean systemInit() { final NvActivity act = this; //nvAcquireTimeExtension(); initRunnable = new Runnable() { public void run() { ranInit = true; if (!init()) { handler.post(new Runnable() { public void run() { new AlertDialog.Builder(act) .setMessage("Application initialization failed. The application will exit.") .setPositiveButton("Ok", new DialogInterface.OnClickListener () { public void onClick(DialogInterface i, int a) { finish(); } } ) .setCancelable(false) .show(); } }); } else { painter = new Runnable() { //long timeStart = nvGetSystemTime(); int count = 0; long start = -1; public void run() { //if (start == -1) // start = nvGetSystemTime(); //float time = (nvGetSystemTime() - start) * 0.001f; //if (render(time, surfaceWidth, surfaceHeight, true)) // TODO if (render(surfaceWidth, surfaceHeight, true)) // TODO swap(); if (!paused) handler.post(this); /* if (fpsText != null && ++count == 100) { long end = nvGetSystemTime(); fpsText.setText(String.format("%.2f fps", (100*1000.0/(end-timeStart)))); timeStart = nvGetSystemTime(); count = 0; } */ } }; handler.post(painter); } } }; // Setting up layouts and views SurfaceView view = new SurfaceView(this); SurfaceHolder holder = view.getHolder(); holder.setType(SurfaceHolder.SURFACE_TYPE_GPU); surfaceView = view; holder.addCallback(new Callback() { // @Override public void surfaceCreated(SurfaceHolder holder) { boolean eglInitialized = true; boolean firstRun = eglContext == null; if (eglContext == null) { eglInitialized = initEGL(); } if (eglInitialized) createEGLSurface(holder); if (firstRun) { if (eglInitialized) handler.post(initRunnable); else { handler.post(new Runnable() { public void run() { new AlertDialog.Builder(act) .setMessage("EGL Initialization failed, the application will exit.") .setPositiveButton("Ok", new DialogInterface.OnClickListener () { public void onClick(DialogInterface i, int a) { finish(); } } ) .setCancelable(false) .show(); } }); } } } // @Override public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) { System.out.println("Surface changed: " + width + ", " + height); surfaceWidth = width; surfaceHeight = height; } // @Override public void surfaceDestroyed(SurfaceHolder holder) { destroyEGLSurface(); } }); setContentView(view); return true; } /** * Call this function to enable an on screen fps counter. */ public void enableOnScreenFPS() { if (fpsText == null) { fpsText = new TextView(this); addContentView(fpsText, new ViewGroup.LayoutParams(100, 100)); } } /** The number of bits requested for the red component */ protected int redSize = 5; /** The number of bits requested for the green component */ protected int greenSize = 6; /** The number of bits requested for the blue component */ protected int blueSize = 5; /** The number of bits requested for the alpha component */ protected int alphaSize = 0; /** The number of bits requested for the stencil component */ protected int stencilSize = 0; /** The number of bits requested for the depth component */ protected int depthSize = 16; /** Attributes used when selecting the EGLConfig */ protected int[] configAttrs = null; /** Attributes used when creating the context */ protected int[] contextAttrs = null; /** * Called to initialize EGL. This function should not be called by the inheriting * activity, but can be overridden if needed. * * @return True if successful */ protected boolean initEGL() { if (configAttrs == null) configAttrs = new int[] {EGL10.EGL_NONE}; int[] oldConf = configAttrs; configAttrs = new int[13 + oldConf.length-1]; int i = 0; for (i = 0; i < oldConf.length-1; i++) configAttrs[i] = oldConf[i]; configAttrs[i++] = EGL10.EGL_RED_SIZE; configAttrs[i++] = redSize; configAttrs[i++] = EGL10.EGL_GREEN_SIZE; configAttrs[i++] = greenSize; configAttrs[i++] = EGL10.EGL_BLUE_SIZE; configAttrs[i++] = blueSize; configAttrs[i++] = EGL10.EGL_ALPHA_SIZE; configAttrs[i++] = alphaSize; configAttrs[i++] = EGL10.EGL_STENCIL_SIZE; configAttrs[i++] = stencilSize; configAttrs[i++] = EGL10.EGL_DEPTH_SIZE; configAttrs[i++] = depthSize; configAttrs[i++] = EGL10.EGL_NONE; egl = (EGL10) EGLContext.getEGL(); egl.eglGetError(); eglDisplay = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY); System.out.println("eglDisplay: " + eglDisplay + ", err: " + egl.eglGetError()); int[] version = new int[2]; boolean ret = egl.eglInitialize(eglDisplay, version); System.out.println("EglInitialize returned: " + ret); if (!ret) { return false; } int eglErr = egl.eglGetError(); if (eglErr != EGL10.EGL_SUCCESS) return false; System.out.println("eglInitialize err: " + eglErr); final EGLConfig[] config = new EGLConfig[20]; int num_configs[] = new int[1]; egl.eglChooseConfig(eglDisplay, configAttrs, config, config.length, num_configs); System.out.println("eglChooseConfig err: " + egl.eglGetError()); int score = 1<<24; // to make sure even worst score is better than this, like 8888 when request 565... int val[] = new int[1]; for (i = 0; i < num_configs[0]; i++) { boolean cont = true; int currScore = 0; int r, g, b, a, d, s; for (int j = 0; j < (oldConf.length-1)>>1; j++) { egl.eglGetConfigAttrib(eglDisplay, config[i], configAttrs[j*2], val); if ((val[0] & configAttrs[j*2+1]) != configAttrs[j*2+1]) { cont = false; // Doesn't match the "must have" configs break; } } if (!cont) continue; egl.eglGetConfigAttrib(eglDisplay, config[i], EGL10.EGL_RED_SIZE, val); r = val[0]; egl.eglGetConfigAttrib(eglDisplay, config[i], EGL10.EGL_GREEN_SIZE, val); g = val[0]; egl.eglGetConfigAttrib(eglDisplay, config[i], EGL10.EGL_BLUE_SIZE, val); b = val[0]; egl.eglGetConfigAttrib(eglDisplay, config[i], EGL10.EGL_ALPHA_SIZE, val); a = val[0]; egl.eglGetConfigAttrib(eglDisplay, config[i], EGL10.EGL_DEPTH_SIZE, val); d = val[0]; egl.eglGetConfigAttrib(eglDisplay, config[i], EGL10.EGL_STENCIL_SIZE, val); s = val[0]; System.out.println(">>> EGL Config ["+i+"] R"+r+"G"+g+"B"+b+"A"+a+" D"+d+"S"+s); currScore = (Math.abs(r - redSize) + Math.abs(g - greenSize) + Math.abs(b - blueSize) + Math.abs(a - alphaSize)) << 16; currScore += Math.abs(d - depthSize) << 8; currScore += Math.abs(s - stencilSize); if (currScore < score) { System.out.println("--------------------------"); System.out.println("New config chosen: " + i); for (int j = 0; j < (configAttrs.length-1)>>1; j++) { egl.eglGetConfigAttrib(eglDisplay, config[i], configAttrs[j*2], val); if (val[0] >= configAttrs[j*2+1]) System.out.println("setting " + j + ", matches: " + val[0]); } score = currScore; eglConfig = config[i]; } } eglContext = egl.eglCreateContext(eglDisplay, eglConfig, EGL10.EGL_NO_CONTEXT, contextAttrs); System.out.println("eglCreateContext: " + egl.eglGetError()); gl = (GL11) eglContext.getGL(); return true; } /** * Called to create the EGLSurface to be used for rendering. This function should not be called by the inheriting * activity, but can be overridden if needed. * * @param surface The SurfaceHolder that holds the surface that we are going to render to. * @return True if successful */ protected boolean createEGLSurface(SurfaceHolder surface) { eglSurface = egl.eglCreateWindowSurface(eglDisplay, eglConfig, surface, null); System.out.println("eglSurface: " + eglSurface + ", err: " + egl.eglGetError()); egl.eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext); System.out.println("eglMakeCurrent err: " + egl.eglGetError()); return true; } /** * Destroys the EGLSurface used for rendering. This function should not be called by the inheriting * activity, but can be overridden if needed. */ protected void destroyEGLSurface() { if (eglDisplay != null && eglSurface != null) egl.eglMakeCurrent(eglDisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, eglContext); if (eglSurface != null) egl.eglDestroySurface(eglDisplay, eglSurface); eglSurface = null; } /** * Called to clean up egl. This function should not be called by the inheriting * activity, but can be overridden if needed. */ protected void cleanupEGL() { destroyEGLSurface(); if (eglDisplay != null) egl.eglMakeCurrent(eglDisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT); if (eglContext != null) egl.eglDestroyContext(eglDisplay, eglContext); if (eglDisplay != null) egl.eglTerminate(eglDisplay); eglDisplay = null; eglContext = null; eglSurface = null; } /** * Called to swap buffers. This function should not be called by the inheriting activity, but * but can be overridden if needed. */ protected void swap() { if (eglSurface != null) egl.eglSwapBuffers(eglDisplay, eglSurface); } /** * When the activity is running, this function will be continuously called to render * to the screen. * * @param time The current time in seconds. * @param drawWidth The current width o the render surface. * @param drawHeight The current height of the render surface. * @param forceRedraw Set to true if the system requests a forced redraw, * upon for example changing the resolution. If this is set to true * the application should render and return true from the function * to ensure that the framebuffer is swapped. If set to false * it's up to the implementation to decide whether to render or not. * @return True if buffers should be swapped, otherwise false. */ public abstract boolean render(int drawWidth, int drawHeight, boolean forceRedraw); @Override protected void systemCleanup() { if (ranInit) cleanup(); handler.removeCallbacks(painter); cleanupEGL(); } }