src/com/replica/replicaisland/GameRenderer.java - platform/external/replicaisland - Git at Google

 /*
  * Copyright (C) 2010 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.replica.replicaisland;

 import android.content.Context;
 import android.os.Build;
 import android.os.SystemClock;

 import javax.microedition.khronos.egl.EGLConfig;
 import javax.microedition.khronos.opengles.GL10;

 import com.replica.replicaisland.RenderSystem.RenderElement;

 /**
  * GameRenderer the top-level rendering interface for the game engine.  It is called by
  * GLSurfaceView and is responsible for submitting commands to OpenGL.  GameRenderer receives a
  * queue of renderable objects from the thread and uses that to draw the scene every frame.  If
  * no queue is available then no drawing is performed.  If the queue is not changed from frame to
  * frame, the same scene will be redrawn every frame.
  * The GameRenderer also invokes texture loads when it is activated.
  */
 public class GameRenderer implements GLSurfaceView.Renderer {
     private static final int PROFILE_REPORT_DELAY = 3 * 1000;

     private int mWidth;
     private int mHeight;
     private int mHalfWidth;
     private int mHalfHeight;

     private float mScaleX;
     private float mScaleY;
     private Context mContext;
     private long mLastTime;
     private int mProfileFrames;
     private long mProfileWaitTime;
     private long mProfileFrameTime;
     private long mProfileSubmitTime;
     private int mProfileObjectCount;

     private ObjectManager mDrawQueue;
     private boolean mDrawQueueChanged;
     private Game mGame;
     private Object mDrawLock;

     float mCameraX;
     float mCameraY;

     boolean mCallbackRequested;

     public GameRenderer(Context context, Game game, int gameWidth, int gameHeight) {
         mContext = context;
         mGame = game;
         mWidth = gameWidth;
         mHeight = gameHeight;
         mHalfWidth = gameWidth / 2;
         mHalfHeight = gameHeight / 2;
         mScaleX = 1.0f;
         mScaleY = 1.0f;
         mDrawQueueChanged = false;
         mDrawLock = new Object();
         mCameraX = 0.0f;
         mCameraY = 0.0f;
         mCallbackRequested = false;
     }

     public void onSurfaceCreated(GL10 gl, EGLConfig config) {
         /*
          * Some one-time OpenGL initialization can be made here probably based
          * on features of this particular context
          */
         gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_FASTEST);

         gl.glClearColor(0.0f, 0.0f, 0.0f, 1);
         gl.glShadeModel(GL10.GL_FLAT);
         gl.glDisable(GL10.GL_DEPTH_TEST);
         gl.glEnable(GL10.GL_TEXTURE_2D);
         /*
          * By default, OpenGL enables features that improve quality but reduce
          * performance. One might want to tweak that especially on software
          * renderer.
          */
         gl.glDisable(GL10.GL_DITHER);
         gl.glDisable(GL10.GL_LIGHTING);

         gl.glTexEnvx(GL10.GL_TEXTURE_ENV, GL10.GL_TEXTURE_ENV_MODE, GL10.GL_MODULATE);

         gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);

         String extensions = gl.glGetString(GL10.GL_EXTENSIONS);
         String version = gl.glGetString(GL10.GL_VERSION);
         String renderer = gl.glGetString(GL10.GL_RENDERER);
         boolean isSoftwareRenderer = renderer.contains("PixelFlinger");
         boolean isOpenGL10 = version.contains("1.0");
         boolean supportsDrawTexture = extensions.contains("draw_texture");
         // VBOs are standard in GLES1.1
         // No use using VBOs when software renderering, esp. since older versions of the software renderer
         // had a crash bug related to freeing VBOs.
         boolean supportsVBOs = !isSoftwareRenderer && (!isOpenGL10 || extensions.contains("vertex_buffer_object"));
         ContextParameters params = BaseObject.sSystemRegistry.contextParameters;
         params.supportsDrawTexture = supportsDrawTexture;
         params.supportsVBOs = supportsVBOs;

         hackBrokenDevices();

         DebugLog.i("Graphics Support", version + " (" + renderer + "): " +(supportsDrawTexture ?  "draw texture," : "") + (supportsVBOs ? "vbos" : ""));

         mGame.onSurfaceCreated();

     }

     private void hackBrokenDevices() {
     	// Some devices are broken.  Fix them here.  This is pretty much the only
     	// device-specific code in the whole project.  Ugh.
         ContextParameters params = BaseObject.sSystemRegistry.contextParameters;


     	if (Build.PRODUCT.contains("morrison")) {
     		// This is the Motorola Cliq.  This device LIES and says it supports
     		// VBOs, which it actually does not (or, more likely, the extensions string
     		// is correct and the GL JNI glue is broken).
     		params.supportsVBOs = false;
     		// TODO: if Motorola fixes this, I should switch to using the fingerprint
     		// (blur/morrison/morrison/morrison:1.5/CUPCAKE/091007:user/ota-rel-keys,release-keys)
     		// instead of the product name so that newer versions use VBOs.
     	}
     }

     public void loadTextures(GL10 gl, TextureLibrary library) {
         if (gl != null) {
             library.loadAll(mContext, gl);
             DebugLog.d("AndouKun", "Textures Loaded.");
         }
     }

     public void flushTextures(GL10 gl, TextureLibrary library) {
         if (gl != null) {
             library.deleteAll(gl);
             DebugLog.d("AndouKun", "Textures Unloaded.");
         }
     }

     public void loadBuffers(GL10 gl, BufferLibrary library) {
         if (gl != null) {
             library.generateHardwareBuffers(gl);
             DebugLog.d("AndouKun", "Buffers Created.");
         }
     }

     public void flushBuffers(GL10 gl, BufferLibrary library) {
         if (gl != null) {
             library.releaseHardwareBuffers(gl);
             DebugLog.d("AndouKun", "Buffers Released.");
         }
     }

     public void onSurfaceLost() {
         mGame.onSurfaceLost();
     }

     public void requestCallback() {
     	mCallbackRequested = true;
     }

     /** Draws the scene.  Note that the draw queue is locked for the duration of this function. */
     public void onDrawFrame(GL10 gl) {

         long time = SystemClock.uptimeMillis();
         long time_delta = (time - mLastTime);

         synchronized(mDrawLock) {
             if (!mDrawQueueChanged) {
                 while (!mDrawQueueChanged) {
                     try {
                     	mDrawLock.wait();
                     } catch (InterruptedException e) {
                         // No big deal if this wait is interrupted.
                     }
                 }
             }
             mDrawQueueChanged = false;
         }

         final long wait = SystemClock.uptimeMillis();

         if (mCallbackRequested) {
         	mGame.onSurfaceReady();
         	mCallbackRequested = false;
         }

         DrawableBitmap.beginDrawing(gl, mWidth, mHeight);

         synchronized (this) {
             if (mDrawQueue != null && mDrawQueue.getObjects().getCount() > 0) {
                 OpenGLSystem.setGL(gl);
                 FixedSizeArray<BaseObject> objects = mDrawQueue.getObjects();
                 Object[] objectArray = objects.getArray();
                 final int count = objects.getCount();
                 final float scaleX = mScaleX;
                 final float scaleY = mScaleY;
                 final float halfWidth = mHalfWidth;
                 final float halfHeight = mHalfHeight;
                 mProfileObjectCount += count;
                 for (int i = 0; i < count; i++) {
                     RenderElement element = (RenderElement)objectArray[i];
                     float x = element.x;
                     float y = element.y;
                     if (element.cameraRelative) {
                     	x = (x - mCameraX) + halfWidth;
                     	y = (y - mCameraY) + halfHeight;
                     }
                     element.mDrawable.draw(x, y, scaleX, scaleY);
                 }
                 OpenGLSystem.setGL(null);
             } else if (mDrawQueue == null) {
                 // If we have no draw queue, clear the screen.  If we have a draw queue that
                 // is empty, we'll leave the frame buffer alone.
                 gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
             }
         }

         DrawableBitmap.endDrawing(gl);

         long time2 = SystemClock.uptimeMillis();
         mLastTime = time2;

         mProfileFrameTime += time_delta;
         mProfileSubmitTime += time2 - time;
         mProfileWaitTime += wait - time;

         mProfileFrames++;
         if (mProfileFrameTime > PROFILE_REPORT_DELAY) {
         	final int validFrames = mProfileFrames;
             final long averageFrameTime = mProfileFrameTime / validFrames;
             final long averageSubmitTime = mProfileSubmitTime / validFrames;
             final float averageObjectsPerFrame = (float)mProfileObjectCount / validFrames;
             final long averageWaitTime = mProfileWaitTime / validFrames;

             DebugLog.d("Render Profile",
             		"Average Submit: " + averageSubmitTime
             		+ "  Average Draw: " + averageFrameTime
             		+ " Objects/Frame: " + averageObjectsPerFrame
             		+ " Wait Time: " + averageWaitTime);

             mProfileFrameTime = 0;
             mProfileSubmitTime = 0;
             mProfileFrames = 0;
             mProfileObjectCount = 0;
         }

     }

     public void onSurfaceChanged(GL10 gl, int w, int h) {
         DebugLog.d("AndouKun", "Surface Size Change: " + w + ", " + h);

         //mWidth = w;0
         //mHeight = h;
     	// ensure the same aspect ratio as the game
     	float scaleX = (float)w / mWidth;
     	float scaleY =  (float)h / mHeight;
     	final int viewportWidth = (int)(mWidth * scaleX);
     	final int viewportHeight = (int)(mHeight * scaleY);
         gl.glViewport(0, 0, viewportWidth, viewportHeight);
         mScaleX = scaleX;
         mScaleY = scaleY;


         /*
          * Set our projection matrix. This doesn't have to be done each time we
          * draw, but usually a new projection needs to be set when the viewport
          * is resized.
          */
         float ratio = (float) mWidth / mHeight;
         gl.glMatrixMode(GL10.GL_PROJECTION);
         gl.glLoadIdentity();
         gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10);


         mGame.onSurfaceReady();
     }

     public synchronized void setDrawQueue(ObjectManager queue, float cameraX, float cameraY) {
 		mDrawQueue = queue;
 		mCameraX = cameraX;
 		mCameraY = cameraY;
     	synchronized(mDrawLock) {
     		mDrawQueueChanged = true;
     		mDrawLock.notify();
     	}
     }

     public synchronized void onPause() {
     	// Stop waiting to avoid deadlock.
     	// TODO: this is a hack.  Probably this renderer
     	// should just use GLSurfaceView's non-continuious render
     	// mode.
     	synchronized(mDrawLock) {
     		mDrawQueueChanged = true;
     		mDrawLock.notify();
     	}
     }

     /**
      * This function blocks while drawFrame() is in progress, and may be used by other threads to
      * determine when drawing is occurring.
      */

     public synchronized void waitDrawingComplete() {
     }

     public void setContext(Context newContext) {
         mContext = newContext;
     }


 }
	/*
	* Copyright (C) 2010 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.replica.replicaisland;

	import android.content.Context;
	import android.os.Build;
	import android.os.SystemClock;

	import javax.microedition.khronos.egl.EGLConfig;
	import javax.microedition.khronos.opengles.GL10;

	import com.replica.replicaisland.RenderSystem.RenderElement;

	/**
	* GameRenderer the top-level rendering interface for the game engine. It is called by
	* GLSurfaceView and is responsible for submitting commands to OpenGL. GameRenderer receives a
	* queue of renderable objects from the thread and uses that to draw the scene every frame. If
	* no queue is available then no drawing is performed. If the queue is not changed from frame to
	* frame, the same scene will be redrawn every frame.
	* The GameRenderer also invokes texture loads when it is activated.
	*/
	public class GameRenderer implements GLSurfaceView.Renderer {
	private static final int PROFILE_REPORT_DELAY = 3 * 1000;

	private int mWidth;
	private int mHeight;
	private int mHalfWidth;
	private int mHalfHeight;

	private float mScaleX;
	private float mScaleY;
	private Context mContext;
	private long mLastTime;
	private int mProfileFrames;
	private long mProfileWaitTime;
	private long mProfileFrameTime;
	private long mProfileSubmitTime;
	private int mProfileObjectCount;

	private ObjectManager mDrawQueue;
	private boolean mDrawQueueChanged;
	private Game mGame;
	private Object mDrawLock;

	float mCameraX;
	float mCameraY;

	boolean mCallbackRequested;

	public GameRenderer(Context context, Game game, int gameWidth, int gameHeight) {
	mContext = context;
	mGame = game;
	mWidth = gameWidth;
	mHeight = gameHeight;
	mHalfWidth = gameWidth / 2;
	mHalfHeight = gameHeight / 2;
	mScaleX = 1.0f;
	mScaleY = 1.0f;
	mDrawQueueChanged = false;
	mDrawLock = new Object();
	mCameraX = 0.0f;
	mCameraY = 0.0f;
	mCallbackRequested = false;
	}

	public void onSurfaceCreated(GL10 gl, EGLConfig config) {
	/*
	* Some one-time OpenGL initialization can be made here probably based
	* on features of this particular context
	*/
	gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_FASTEST);

	gl.glClearColor(0.0f, 0.0f, 0.0f, 1);
	gl.glShadeModel(GL10.GL_FLAT);
	gl.glDisable(GL10.GL_DEPTH_TEST);
	gl.glEnable(GL10.GL_TEXTURE_2D);
	/*
	* By default, OpenGL enables features that improve quality but reduce
	* performance. One might want to tweak that especially on software
	* renderer.
	*/
	gl.glDisable(GL10.GL_DITHER);
	gl.glDisable(GL10.GL_LIGHTING);

	gl.glTexEnvx(GL10.GL_TEXTURE_ENV, GL10.GL_TEXTURE_ENV_MODE, GL10.GL_MODULATE);

	gl.glClear(GL10.GL_COLOR_BUFFER_BIT \| GL10.GL_DEPTH_BUFFER_BIT);

	String extensions = gl.glGetString(GL10.GL_EXTENSIONS);
	String version = gl.glGetString(GL10.GL_VERSION);
	String renderer = gl.glGetString(GL10.GL_RENDERER);
	boolean isSoftwareRenderer = renderer.contains("PixelFlinger");
	boolean isOpenGL10 = version.contains("1.0");
	boolean supportsDrawTexture = extensions.contains("draw_texture");
	// VBOs are standard in GLES1.1
	// No use using VBOs when software renderering, esp. since older versions of the software renderer
	// had a crash bug related to freeing VBOs.
	boolean supportsVBOs = !isSoftwareRenderer && (!isOpenGL10 \|\| extensions.contains("vertex_buffer_object"));
	ContextParameters params = BaseObject.sSystemRegistry.contextParameters;
	params.supportsDrawTexture = supportsDrawTexture;
	params.supportsVBOs = supportsVBOs;

	hackBrokenDevices();

	DebugLog.i("Graphics Support", version + " (" + renderer + "): " +(supportsDrawTexture ? "draw texture," : "") + (supportsVBOs ? "vbos" : ""));

	mGame.onSurfaceCreated();

	}

	private void hackBrokenDevices() {
	// Some devices are broken. Fix them here. This is pretty much the only
	// device-specific code in the whole project. Ugh.
	ContextParameters params = BaseObject.sSystemRegistry.contextParameters;


	if (Build.PRODUCT.contains("morrison")) {
	// This is the Motorola Cliq. This device LIES and says it supports
	// VBOs, which it actually does not (or, more likely, the extensions string
	// is correct and the GL JNI glue is broken).
	params.supportsVBOs = false;
	// TODO: if Motorola fixes this, I should switch to using the fingerprint
	// (blur/morrison/morrison/morrison:1.5/CUPCAKE/091007:user/ota-rel-keys,release-keys)
	// instead of the product name so that newer versions use VBOs.
	}
	}

	public void loadTextures(GL10 gl, TextureLibrary library) {
	if (gl != null) {
	library.loadAll(mContext, gl);
	DebugLog.d("AndouKun", "Textures Loaded.");
	}
	}

	public void flushTextures(GL10 gl, TextureLibrary library) {
	if (gl != null) {
	library.deleteAll(gl);
	DebugLog.d("AndouKun", "Textures Unloaded.");
	}
	}

	public void loadBuffers(GL10 gl, BufferLibrary library) {
	if (gl != null) {
	library.generateHardwareBuffers(gl);
	DebugLog.d("AndouKun", "Buffers Created.");
	}
	}

	public void flushBuffers(GL10 gl, BufferLibrary library) {
	if (gl != null) {
	library.releaseHardwareBuffers(gl);
	DebugLog.d("AndouKun", "Buffers Released.");
	}
	}

	public void onSurfaceLost() {
	mGame.onSurfaceLost();
	}

	public void requestCallback() {
	mCallbackRequested = true;
	}

	/** Draws the scene. Note that the draw queue is locked for the duration of this function. */
	public void onDrawFrame(GL10 gl) {

	long time = SystemClock.uptimeMillis();
	long time_delta = (time - mLastTime);

	synchronized(mDrawLock) {
	if (!mDrawQueueChanged) {
	while (!mDrawQueueChanged) {
	try {
	mDrawLock.wait();
	} catch (InterruptedException e) {
	// No big deal if this wait is interrupted.
	}
	}
	}
	mDrawQueueChanged = false;
	}

	final long wait = SystemClock.uptimeMillis();

	if (mCallbackRequested) {
	mGame.onSurfaceReady();
	mCallbackRequested = false;
	}

	DrawableBitmap.beginDrawing(gl, mWidth, mHeight);

	synchronized (this) {
	if (mDrawQueue != null && mDrawQueue.getObjects().getCount() > 0) {
	OpenGLSystem.setGL(gl);
	FixedSizeArray<BaseObject> objects = mDrawQueue.getObjects();
	Object[] objectArray = objects.getArray();
	final int count = objects.getCount();
	final float scaleX = mScaleX;
	final float scaleY = mScaleY;
	final float halfWidth = mHalfWidth;
	final float halfHeight = mHalfHeight;
	mProfileObjectCount += count;
	for (int i = 0; i < count; i++) {
	RenderElement element = (RenderElement)objectArray[i];
	float x = element.x;
	float y = element.y;
	if (element.cameraRelative) {
	x = (x - mCameraX) + halfWidth;
	y = (y - mCameraY) + halfHeight;
	}
	element.mDrawable.draw(x, y, scaleX, scaleY);
	}
	OpenGLSystem.setGL(null);
	} else if (mDrawQueue == null) {
	// If we have no draw queue, clear the screen. If we have a draw queue that
	// is empty, we'll leave the frame buffer alone.
	gl.glClear(GL10.GL_COLOR_BUFFER_BIT \| GL10.GL_DEPTH_BUFFER_BIT);
	}
	}

	DrawableBitmap.endDrawing(gl);

	long time2 = SystemClock.uptimeMillis();
	mLastTime = time2;

	mProfileFrameTime += time_delta;
	mProfileSubmitTime += time2 - time;
	mProfileWaitTime += wait - time;

	mProfileFrames++;
	if (mProfileFrameTime > PROFILE_REPORT_DELAY) {
	final int validFrames = mProfileFrames;
	final long averageFrameTime = mProfileFrameTime / validFrames;
	final long averageSubmitTime = mProfileSubmitTime / validFrames;
	final float averageObjectsPerFrame = (float)mProfileObjectCount / validFrames;
	final long averageWaitTime = mProfileWaitTime / validFrames;

	DebugLog.d("Render Profile",
	"Average Submit: " + averageSubmitTime
	+ " Average Draw: " + averageFrameTime
	+ " Objects/Frame: " + averageObjectsPerFrame
	+ " Wait Time: " + averageWaitTime);

	mProfileFrameTime = 0;
	mProfileSubmitTime = 0;
	mProfileFrames = 0;
	mProfileObjectCount = 0;
	}

	}

	public void onSurfaceChanged(GL10 gl, int w, int h) {
	DebugLog.d("AndouKun", "Surface Size Change: " + w + ", " + h);

	//mWidth = w;0
	//mHeight = h;
	// ensure the same aspect ratio as the game
	float scaleX = (float)w / mWidth;
	float scaleY = (float)h / mHeight;
	final int viewportWidth = (int)(mWidth * scaleX);
	final int viewportHeight = (int)(mHeight * scaleY);
	gl.glViewport(0, 0, viewportWidth, viewportHeight);
	mScaleX = scaleX;
	mScaleY = scaleY;


	/*
	* Set our projection matrix. This doesn't have to be done each time we
	* draw, but usually a new projection needs to be set when the viewport
	* is resized.
	*/
	float ratio = (float) mWidth / mHeight;
	gl.glMatrixMode(GL10.GL_PROJECTION);
	gl.glLoadIdentity();
	gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10);


	mGame.onSurfaceReady();
	}

	public synchronized void setDrawQueue(ObjectManager queue, float cameraX, float cameraY) {
	mDrawQueue = queue;
	mCameraX = cameraX;
	mCameraY = cameraY;
	synchronized(mDrawLock) {
	mDrawQueueChanged = true;
	mDrawLock.notify();
	}
	}

	public synchronized void onPause() {
	// Stop waiting to avoid deadlock.
	// TODO: this is a hack. Probably this renderer
	// should just use GLSurfaceView's non-continuious render
	// mode.
	synchronized(mDrawLock) {
	mDrawQueueChanged = true;
	mDrawLock.notify();
	}
	}

	/**
	* This function blocks while drawFrame() is in progress, and may be used by other threads to
	* determine when drawing is occurring.
	*/

	public synchronized void waitDrawingComplete() {
	}

	public void setContext(Context newContext) {
	mContext = newContext;
	}


	}