libs/surfaceflinger/BootAnimation.cpp - LeafOS-Project/android_frameworks_base - Gitiles

 /*
  * 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.
  */

 #define LOG_TAG "BootAnimation"

 #include <stdint.h>
 #include <sys/types.h>
 #include <math.h>
 #include <fcntl.h>
 #include <utils/misc.h>

 #include <utils/threads.h>
 #include <utils/Atomic.h>
 #include <utils/Errors.h>
 #include <utils/Log.h>
 #include <utils/AssetManager.h>

 #include <ui/PixelFormat.h>
 #include <ui/Rect.h>
 #include <ui/Region.h>
 #include <ui/DisplayInfo.h>
 #include <ui/ISurfaceComposer.h>
 #include <ui/ISurfaceFlingerClient.h>
 #include <ui/EGLNativeWindowSurface.h>

 #include <core/SkBitmap.h>
 #include <images/SkImageDecoder.h>

 #include <GLES/gl.h>
 #include <GLES/glext.h>
 #include <EGL/eglext.h>

 #include "BootAnimation.h"

 namespace android {

 // ---------------------------------------------------------------------------

 BootAnimation::BootAnimation(const sp<ISurfaceComposer>& composer) :
     Thread(false) {
     mSession = SurfaceComposerClient::clientForConnection(
             composer->createConnection()->asBinder());
 }

 BootAnimation::~BootAnimation() {
 }

 void BootAnimation::onFirstRef() {
     run("BootAnimation", PRIORITY_DISPLAY);
 }

 const sp<SurfaceComposerClient>& BootAnimation::session() const {
     return mSession;
 }

 status_t BootAnimation::initTexture(Texture* texture, AssetManager& assets,
         const char* name) {
     Asset* asset = assets.open(name, Asset::ACCESS_BUFFER);
     if (!asset)
         return NO_INIT;
     SkBitmap bitmap;
     SkImageDecoder::DecodeMemory(asset->getBuffer(false), asset->getLength(),
             &bitmap, SkBitmap::kNo_Config, SkImageDecoder::kDecodePixels_Mode);
     asset->close();
     delete asset;

     // ensure we can call getPixels(). No need to call unlock, since the
     // bitmap will go out of scope when we return from this method.
     bitmap.lockPixels();

     const int w = bitmap.width();
     const int h = bitmap.height();
     const void* p = bitmap.getPixels();

     GLint crop[4] = { 0, h, w, -h };
     texture->w = w;
     texture->h = h;

     glGenTextures(1, &texture->name);
     glBindTexture(GL_TEXTURE_2D, texture->name);

     switch (bitmap.getConfig()) {
         case SkBitmap::kA8_Config:
             glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, w, h, 0, GL_ALPHA,
                     GL_UNSIGNED_BYTE, p);
             break;
         case SkBitmap::kARGB_4444_Config:
             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA,
                     GL_UNSIGNED_SHORT_4_4_4_4, p);
             break;
         case SkBitmap::kARGB_8888_Config:
             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA,
                     GL_UNSIGNED_BYTE, p);
             break;
         case SkBitmap::kRGB_565_Config:
             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB,
                     GL_UNSIGNED_SHORT_5_6_5, p);
             break;
         default:
             break;
     }

     glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);
     glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
     glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
     return NO_ERROR;
 }

 status_t BootAnimation::readyToRun() {
     mAssets.addDefaultAssets();

     DisplayInfo dinfo;
     status_t status = session()->getDisplayInfo(0, &dinfo);
     if (status)
         return -1;

     // create the native surface
     sp<Surface> s = session()->createSurface(getpid(), 0, dinfo.w, dinfo.h,
             PIXEL_FORMAT_RGB_565);
     session()->openTransaction();
     s->setLayer(0x40000000);
     session()->closeTransaction();

     // initialize opengl and egl
     const EGLint attribs[] = { EGL_RED_SIZE, 5, EGL_GREEN_SIZE, 6,
             EGL_BLUE_SIZE, 5, EGL_DEPTH_SIZE, 0, EGL_NONE };
     EGLint w, h, dummy;
     EGLint numConfigs;
     EGLConfig config;
     EGLSurface surface;
     EGLContext context;
     EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
     eglChooseConfig(display, attribs, &config, 1, &numConfigs);

     mNativeWindowSurface = new EGLNativeWindowSurface(s);
     surface = eglCreateWindowSurface(display, config,
             mNativeWindowSurface.get(), NULL);

     context = eglCreateContext(display, config, NULL, NULL);
     eglQuerySurface(display, surface, EGL_WIDTH, &w);
     eglQuerySurface(display, surface, EGL_HEIGHT, &h);
     eglMakeCurrent(display, surface, surface, context);
     mDisplay = display;
     mContext = context;
     mSurface = surface;
     mWidth = w;
     mHeight = h;
     mFlingerSurface = s;

     // initialize GL
     glShadeModel(GL_FLAT);
     glEnable(GL_DITHER);
     glEnable(GL_TEXTURE_2D);
     glEnable(GL_SCISSOR_TEST);
     glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

     return NO_ERROR;
 }

 void BootAnimation::requestExit() {
     mBarrier.open();
     Thread::requestExit();
 }

 bool BootAnimation::threadLoop() {
     bool r = android();
     eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
     eglDestroyContext(mDisplay, mContext);
     eglDestroySurface(mDisplay, mSurface);
     mNativeWindowSurface.clear();
     return r;
 }

 bool BootAnimation::android() {
     initTexture(&mAndroid[0], mAssets, "images/android_320x480.png");
     initTexture(&mAndroid[1], mAssets, "images/boot_robot.png");
     initTexture(&mAndroid[2], mAssets, "images/boot_robot_glow.png");

     // erase screen
     glDisable(GL_SCISSOR_TEST);
     glBindTexture(GL_TEXTURE_2D, mAndroid[0].name);

     // clear screen
     glClear(GL_COLOR_BUFFER_BIT);
     eglSwapBuffers(mDisplay, mSurface);

     // wait ~1s
     usleep(800000);

     // fade in
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
     const int steps = 8;
     for (int i = 1; i < steps; i++) {
         float fade = i / float(steps);
         glColor4f(1, 1, 1, fade * fade);
         glClear(GL_COLOR_BUFFER_BIT);
         glDrawTexiOES(0, 0, 0, mAndroid[0].w, mAndroid[0].h);
         eglSwapBuffers(mDisplay, mSurface);
     }

     // draw last frame
     glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
     glDisable(GL_BLEND);
     glDrawTexiOES(0, 0, 0, mAndroid[0].w, mAndroid[0].h);
     eglSwapBuffers(mDisplay, mSurface);

     // update rect for the robot
     const int x = mWidth - mAndroid[1].w - 33;
     const int y = (mHeight - mAndroid[1].h) / 2 - 1;
     const Rect updateRect(x, y, x + mAndroid[1].w, y + mAndroid[1].h);

     // draw and update only what we need
     mNativeWindowSurface->setSwapRectangle(updateRect.left,
             updateRect.top, updateRect.width(), updateRect.height());

     glEnable(GL_SCISSOR_TEST);
     glScissor(updateRect.left, mHeight - updateRect.bottom, updateRect.width(),
             updateRect.height());

     const nsecs_t startTime = systemTime();
     do {
         // glow speed and shape
         nsecs_t time = systemTime() - startTime;
         float t = ((4.0f / (360.0f * us2ns(16667))) * time);
         t = t - floorf(t);
         const float fade = 0.5f + 0.5f * sinf(t * 2 * M_PI);

         // fade the glow in and out
         glDisable(GL_BLEND);
         glBindTexture(GL_TEXTURE_2D, mAndroid[2].name);
         glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
         glColor4f(fade, fade, fade, fade);
         glDrawTexiOES(updateRect.left, mHeight - updateRect.bottom, 0,
                 updateRect.width(), updateRect.height());

         // draw the robot
         glEnable(GL_BLEND);
         glBindTexture(GL_TEXTURE_2D, mAndroid[1].name);
         glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
         glDrawTexiOES(updateRect.left, mHeight - updateRect.bottom, 0,
                 updateRect.width(), updateRect.height());

         // make sure sleep a lot to not take too much CPU away from
         // the boot process. With this "glow" animation there is no
         // visible difference.
         usleep(16667 * 4);

         eglSwapBuffers(mDisplay, mSurface);
     } while (!exitPending());

     glDeleteTextures(1, &mAndroid[0].name);
     glDeleteTextures(1, &mAndroid[1].name);
     glDeleteTextures(1, &mAndroid[2].name);
     return false;
 }

 bool BootAnimation::cylon() {
     // initialize the textures...
     initTexture(&mLeftTrail, mAssets, "images/cylon_left.png");
     initTexture(&mRightTrail, mAssets, "images/cylon_right.png");
     initTexture(&mBrightSpot, mAssets, "images/cylon_dot.png");

     int w = mWidth;
     int h = mHeight;

     const Point c(w / 2, h / 2);
     const GLint amplitude = 60;
     const int scx = c.x - amplitude - mBrightSpot.w / 2;
     const int scy = c.y - mBrightSpot.h / 2;
     const int scw = amplitude * 2 + mBrightSpot.w;
     const int sch = mBrightSpot.h;
     const Rect updateRect(scx, h - scy - sch, scx + scw, h - scy);

     // erase screen
     glDisable(GL_SCISSOR_TEST);
     glClear(GL_COLOR_BUFFER_BIT);

     eglSwapBuffers(mDisplay, mSurface);

     glClear(GL_COLOR_BUFFER_BIT);

     mNativeWindowSurface->setSwapRectangle(updateRect.left,
             updateRect.top, updateRect.width(), updateRect.height());

     glEnable(GL_SCISSOR_TEST);
     glEnable(GL_BLEND);
     glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

     // clear the screen to white
     Point p;
     float t = 0;
     float alpha = 1.0f;
     const nsecs_t startTime = systemTime();
     nsecs_t fadeTime = 0;

     do {
         // Set scissor in interesting area
         glScissor(scx, scy, scw, sch);

         // erase screen
         glClear(GL_COLOR_BUFFER_BIT);

         // compute wave
         const float a = (t * 2 * M_PI) - M_PI / 2;
         const float sn = sinf(a);
         const float cs = cosf(a);
         GLint x = GLint(amplitude * sn);
         float derivative = cs;

         glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

         if (derivative > 0) {
             // vanishing trail...
             p.x = (-amplitude + c.x) - mBrightSpot.w / 2;
             p.y = c.y - mLeftTrail.h / 2;
             float fade = 2.0f * (0.5f - t);
             //fade *= fade;
             glColor4f(fade, fade, fade, fade);
             glBindTexture(GL_TEXTURE_2D, mLeftTrail.name);
             glDrawTexiOES(p.x, p.y, 0, mLeftTrail.w, mLeftTrail.h);

             // trail...
             p.x = (x + c.x) - (mRightTrail.w + mBrightSpot.w / 2) + 16;
             p.y = c.y - mRightTrail.h / 2;
             fade = t < 0.25f ? t * 4.0f : 1.0f;
             fade *= fade;
             glColor4f(fade, fade, fade, fade);
             glBindTexture(GL_TEXTURE_2D, mRightTrail.name);
             glDrawTexiOES(p.x, p.y, 0, mRightTrail.w, mRightTrail.h);
         } else {
             // vanishing trail..
             p.x = (amplitude + c.x) - (mRightTrail.w + mBrightSpot.w / 2) + 16;
             p.y = c.y - mRightTrail.h / 2;
             float fade = 2.0f * (0.5f - (t - 0.5f));
             //fade *= fade;
             glColor4f(fade, fade, fade, fade);
             glBindTexture(GL_TEXTURE_2D, mRightTrail.name);
             glDrawTexiOES(p.x, p.y, 0, mRightTrail.w, mRightTrail.h);

             // trail...
             p.x = (x + c.x) - mBrightSpot.w / 2;
             p.y = c.y - mLeftTrail.h / 2;
             fade = t < 0.5f + 0.25f ? (t - 0.5f) * 4.0f : 1.0f;
             fade *= fade;
             glColor4f(fade, fade, fade, fade);
             glBindTexture(GL_TEXTURE_2D, mLeftTrail.name);
             glDrawTexiOES(p.x, p.y, 0, mLeftTrail.w, mLeftTrail.h);
         }

         const Point p(x + c.x - mBrightSpot.w / 2, c.y - mBrightSpot.h / 2);
         glBindTexture(GL_TEXTURE_2D, mBrightSpot.name);
         glColor4f(1, 0.5, 0.5, 1);
         glDrawTexiOES(p.x, p.y, 0, mBrightSpot.w, mBrightSpot.h);

         // update animation
         nsecs_t time = systemTime() - startTime;
         t = ((4.0f / (360.0f * us2ns(16667))) * time);
         t = t - floorf(t);

         eglSwapBuffers(mDisplay, mSurface);

         if (exitPending()) {
             if (fadeTime == 0) {
                 fadeTime = time;
             }
             time -= fadeTime;
             alpha = 1.0f - ((float(time) * 6.0f) / float(s2ns(1)));

             session()->openTransaction();
             mFlingerSurface->setAlpha(alpha * alpha);
             session()->closeTransaction();
         }
     } while (alpha > 0);

     // cleanup
     glFinish();
     glDeleteTextures(1, &mLeftTrail.name);
     glDeleteTextures(1, &mRightTrail.name);
     glDeleteTextures(1, &mBrightSpot.name);
     return false;
 }

 // ---------------------------------------------------------------------------

 }
 ; // namespace android
	/*
	* 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.
	*/

	#define LOG_TAG "BootAnimation"

	#include <stdint.h>
	#include <sys/types.h>
	#include <math.h>
	#include <fcntl.h>
	#include <utils/misc.h>

	#include <utils/threads.h>
	#include <utils/Atomic.h>
	#include <utils/Errors.h>
	#include <utils/Log.h>
	#include <utils/AssetManager.h>

	#include <ui/PixelFormat.h>
	#include <ui/Rect.h>
	#include <ui/Region.h>
	#include <ui/DisplayInfo.h>
	#include <ui/ISurfaceComposer.h>
	#include <ui/ISurfaceFlingerClient.h>
	#include <ui/EGLNativeWindowSurface.h>

	#include <core/SkBitmap.h>
	#include <images/SkImageDecoder.h>

	#include <GLES/gl.h>
	#include <GLES/glext.h>
	#include <EGL/eglext.h>

	#include "BootAnimation.h"

	namespace android {

	// ---------------------------------------------------------------------------

	BootAnimation::BootAnimation(const sp<ISurfaceComposer>& composer) :
	Thread(false) {
	mSession = SurfaceComposerClient::clientForConnection(
	composer->createConnection()->asBinder());
	}

	BootAnimation::~BootAnimation() {
	}

	void BootAnimation::onFirstRef() {
	run("BootAnimation", PRIORITY_DISPLAY);
	}

	const sp<SurfaceComposerClient>& BootAnimation::session() const {
	return mSession;
	}

	status_t BootAnimation::initTexture(Texture* texture, AssetManager& assets,
	const char* name) {
	Asset* asset = assets.open(name, Asset::ACCESS_BUFFER);
	if (!asset)
	return NO_INIT;
	SkBitmap bitmap;
	SkImageDecoder::DecodeMemory(asset->getBuffer(false), asset->getLength(),
	&bitmap, SkBitmap::kNo_Config, SkImageDecoder::kDecodePixels_Mode);
	asset->close();
	delete asset;

	// ensure we can call getPixels(). No need to call unlock, since the
	// bitmap will go out of scope when we return from this method.
	bitmap.lockPixels();

	const int w = bitmap.width();
	const int h = bitmap.height();
	const void* p = bitmap.getPixels();

	GLint crop[4] = { 0, h, w, -h };
	texture->w = w;
	texture->h = h;

	glGenTextures(1, &texture->name);
	glBindTexture(GL_TEXTURE_2D, texture->name);

	switch (bitmap.getConfig()) {
	case SkBitmap::kA8_Config:
	glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, w, h, 0, GL_ALPHA,
	GL_UNSIGNED_BYTE, p);
	break;
	case SkBitmap::kARGB_4444_Config:
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA,
	GL_UNSIGNED_SHORT_4_4_4_4, p);
	break;
	case SkBitmap::kARGB_8888_Config:
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA,
	GL_UNSIGNED_BYTE, p);
	break;
	case SkBitmap::kRGB_565_Config:
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB,
	GL_UNSIGNED_SHORT_5_6_5, p);
	break;
	default:
	break;
	}

	glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);
	glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	return NO_ERROR;
	}

	status_t BootAnimation::readyToRun() {
	mAssets.addDefaultAssets();

	DisplayInfo dinfo;
	status_t status = session()->getDisplayInfo(0, &dinfo);
	if (status)
	return -1;

	// create the native surface
	sp<Surface> s = session()->createSurface(getpid(), 0, dinfo.w, dinfo.h,
	PIXEL_FORMAT_RGB_565);
	session()->openTransaction();
	s->setLayer(0x40000000);
	session()->closeTransaction();

	// initialize opengl and egl
	const EGLint attribs[] = { EGL_RED_SIZE, 5, EGL_GREEN_SIZE, 6,
	EGL_BLUE_SIZE, 5, EGL_DEPTH_SIZE, 0, EGL_NONE };
	EGLint w, h, dummy;
	EGLint numConfigs;
	EGLConfig config;
	EGLSurface surface;
	EGLContext context;
	EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
	eglChooseConfig(display, attribs, &config, 1, &numConfigs);

	mNativeWindowSurface = new EGLNativeWindowSurface(s);
	surface = eglCreateWindowSurface(display, config,
	mNativeWindowSurface.get(), NULL);

	context = eglCreateContext(display, config, NULL, NULL);
	eglQuerySurface(display, surface, EGL_WIDTH, &w);
	eglQuerySurface(display, surface, EGL_HEIGHT, &h);
	eglMakeCurrent(display, surface, surface, context);
	mDisplay = display;
	mContext = context;
	mSurface = surface;
	mWidth = w;
	mHeight = h;
	mFlingerSurface = s;

	// initialize GL
	glShadeModel(GL_FLAT);
	glEnable(GL_DITHER);
	glEnable(GL_TEXTURE_2D);
	glEnable(GL_SCISSOR_TEST);
	glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

	return NO_ERROR;
	}

	void BootAnimation::requestExit() {
	mBarrier.open();
	Thread::requestExit();
	}

	bool BootAnimation::threadLoop() {
	bool r = android();
	eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
	eglDestroyContext(mDisplay, mContext);
	eglDestroySurface(mDisplay, mSurface);
	mNativeWindowSurface.clear();
	return r;
	}

	bool BootAnimation::android() {
	initTexture(&mAndroid[0], mAssets, "images/android_320x480.png");
	initTexture(&mAndroid[1], mAssets, "images/boot_robot.png");
	initTexture(&mAndroid[2], mAssets, "images/boot_robot_glow.png");

	// erase screen
	glDisable(GL_SCISSOR_TEST);
	glBindTexture(GL_TEXTURE_2D, mAndroid[0].name);

	// clear screen
	glClear(GL_COLOR_BUFFER_BIT);
	eglSwapBuffers(mDisplay, mSurface);

	// wait ~1s
	usleep(800000);

	// fade in
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	const int steps = 8;
	for (int i = 1; i < steps; i++) {
	float fade = i / float(steps);
	glColor4f(1, 1, 1, fade * fade);
	glClear(GL_COLOR_BUFFER_BIT);
	glDrawTexiOES(0, 0, 0, mAndroid[0].w, mAndroid[0].h);
	eglSwapBuffers(mDisplay, mSurface);
	}

	// draw last frame
	glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
	glDisable(GL_BLEND);
	glDrawTexiOES(0, 0, 0, mAndroid[0].w, mAndroid[0].h);
	eglSwapBuffers(mDisplay, mSurface);

	// update rect for the robot
	const int x = mWidth - mAndroid[1].w - 33;
	const int y = (mHeight - mAndroid[1].h) / 2 - 1;
	const Rect updateRect(x, y, x + mAndroid[1].w, y + mAndroid[1].h);

	// draw and update only what we need
	mNativeWindowSurface->setSwapRectangle(updateRect.left,
	updateRect.top, updateRect.width(), updateRect.height());

	glEnable(GL_SCISSOR_TEST);
	glScissor(updateRect.left, mHeight - updateRect.bottom, updateRect.width(),
	updateRect.height());

	const nsecs_t startTime = systemTime();
	do {
	// glow speed and shape
	nsecs_t time = systemTime() - startTime;
	float t = ((4.0f / (360.0f * us2ns(16667))) * time);
	t = t - floorf(t);
	const float fade = 0.5f + 0.5f * sinf(t * 2 * M_PI);

	// fade the glow in and out
	glDisable(GL_BLEND);
	glBindTexture(GL_TEXTURE_2D, mAndroid[2].name);
	glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glColor4f(fade, fade, fade, fade);
	glDrawTexiOES(updateRect.left, mHeight - updateRect.bottom, 0,
	updateRect.width(), updateRect.height());

	// draw the robot
	glEnable(GL_BLEND);
	glBindTexture(GL_TEXTURE_2D, mAndroid[1].name);
	glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
	glDrawTexiOES(updateRect.left, mHeight - updateRect.bottom, 0,
	updateRect.width(), updateRect.height());

	// make sure sleep a lot to not take too much CPU away from
	// the boot process. With this "glow" animation there is no
	// visible difference.
	usleep(16667 * 4);

	eglSwapBuffers(mDisplay, mSurface);
	} while (!exitPending());

	glDeleteTextures(1, &mAndroid[0].name);
	glDeleteTextures(1, &mAndroid[1].name);
	glDeleteTextures(1, &mAndroid[2].name);
	return false;
	}

	bool BootAnimation::cylon() {
	// initialize the textures...
	initTexture(&mLeftTrail, mAssets, "images/cylon_left.png");
	initTexture(&mRightTrail, mAssets, "images/cylon_right.png");
	initTexture(&mBrightSpot, mAssets, "images/cylon_dot.png");

	int w = mWidth;
	int h = mHeight;

	const Point c(w / 2, h / 2);
	const GLint amplitude = 60;
	const int scx = c.x - amplitude - mBrightSpot.w / 2;
	const int scy = c.y - mBrightSpot.h / 2;
	const int scw = amplitude * 2 + mBrightSpot.w;
	const int sch = mBrightSpot.h;
	const Rect updateRect(scx, h - scy - sch, scx + scw, h - scy);

	// erase screen
	glDisable(GL_SCISSOR_TEST);
	glClear(GL_COLOR_BUFFER_BIT);

	eglSwapBuffers(mDisplay, mSurface);

	glClear(GL_COLOR_BUFFER_BIT);

	mNativeWindowSurface->setSwapRectangle(updateRect.left,
	updateRect.top, updateRect.width(), updateRect.height());

	glEnable(GL_SCISSOR_TEST);
	glEnable(GL_BLEND);
	glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

	// clear the screen to white
	Point p;
	float t = 0;
	float alpha = 1.0f;
	const nsecs_t startTime = systemTime();
	nsecs_t fadeTime = 0;

	do {
	// Set scissor in interesting area
	glScissor(scx, scy, scw, sch);

	// erase screen
	glClear(GL_COLOR_BUFFER_BIT);

	// compute wave
	const float a = (t * 2 * M_PI) - M_PI / 2;
	const float sn = sinf(a);
	const float cs = cosf(a);
	GLint x = GLint(amplitude * sn);
	float derivative = cs;

	glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

	if (derivative > 0) {
	// vanishing trail...
	p.x = (-amplitude + c.x) - mBrightSpot.w / 2;
	p.y = c.y - mLeftTrail.h / 2;
	float fade = 2.0f * (0.5f - t);
	//fade *= fade;
	glColor4f(fade, fade, fade, fade);
	glBindTexture(GL_TEXTURE_2D, mLeftTrail.name);
	glDrawTexiOES(p.x, p.y, 0, mLeftTrail.w, mLeftTrail.h);

	// trail...
	p.x = (x + c.x) - (mRightTrail.w + mBrightSpot.w / 2) + 16;
	p.y = c.y - mRightTrail.h / 2;
	fade = t < 0.25f ? t * 4.0f : 1.0f;
	fade *= fade;
	glColor4f(fade, fade, fade, fade);
	glBindTexture(GL_TEXTURE_2D, mRightTrail.name);
	glDrawTexiOES(p.x, p.y, 0, mRightTrail.w, mRightTrail.h);
	} else {
	// vanishing trail..
	p.x = (amplitude + c.x) - (mRightTrail.w + mBrightSpot.w / 2) + 16;
	p.y = c.y - mRightTrail.h / 2;
	float fade = 2.0f * (0.5f - (t - 0.5f));
	//fade *= fade;
	glColor4f(fade, fade, fade, fade);
	glBindTexture(GL_TEXTURE_2D, mRightTrail.name);
	glDrawTexiOES(p.x, p.y, 0, mRightTrail.w, mRightTrail.h);

	// trail...
	p.x = (x + c.x) - mBrightSpot.w / 2;
	p.y = c.y - mLeftTrail.h / 2;
	fade = t < 0.5f + 0.25f ? (t - 0.5f) * 4.0f : 1.0f;
	fade *= fade;
	glColor4f(fade, fade, fade, fade);
	glBindTexture(GL_TEXTURE_2D, mLeftTrail.name);
	glDrawTexiOES(p.x, p.y, 0, mLeftTrail.w, mLeftTrail.h);
	}

	const Point p(x + c.x - mBrightSpot.w / 2, c.y - mBrightSpot.h / 2);
	glBindTexture(GL_TEXTURE_2D, mBrightSpot.name);
	glColor4f(1, 0.5, 0.5, 1);
	glDrawTexiOES(p.x, p.y, 0, mBrightSpot.w, mBrightSpot.h);

	// update animation
	nsecs_t time = systemTime() - startTime;
	t = ((4.0f / (360.0f * us2ns(16667))) * time);
	t = t - floorf(t);

	eglSwapBuffers(mDisplay, mSurface);

	if (exitPending()) {
	if (fadeTime == 0) {
	fadeTime = time;
	}
	time -= fadeTime;
	alpha = 1.0f - ((float(time) * 6.0f) / float(s2ns(1)));

	session()->openTransaction();
	mFlingerSurface->setAlpha(alpha * alpha);
	session()->closeTransaction();
	}
	} while (alpha > 0);

	// cleanup
	glFinish();
	glDeleteTextures(1, &mLeftTrail.name);
	glDeleteTextures(1, &mRightTrail.name);
	glDeleteTextures(1, &mBrightSpot.name);
	return false;
	}

	// ---------------------------------------------------------------------------

	}
	; // namespace android