This release only contains bug-fixes, there are no new APIs or features.
See below for the corresponding change log. The most important things, being:

- no more crashes of code linked to gnustl_static on Eclair and older platforms.
- gdbserver no longer crashes on Honeycomb devices like the Motorola Xoom

Android NDK ChangeLog:

----------------------------------------------------------------
android-ndk-r5c

This release fixes a few bugs in r5b. There are no new features.

IMPORTANT BUG FIXES:

- Fixed a typo that prevented LOCAL_WHOLE_STATIC_LIBRARIES to work correctly with the new toolchain. Also properly document this variable in docs/ANDROID-MK.html.

- Fixed a bug where code linked against gnustl_static would crash when run on Android platform releases older than 2.2.

- : Two functions in this header file, introduced by API level 9 (a.k.a. 2.3) were incorrect and have been fixed. While this breaks the source API, the binary interface to the system is unchanged.

The functions missing a third 'history_index' parameter. They correct definition is now:

float AMotionEvent_getHistoricalRawX(const AInputEvent* motion_event,
size_t pointer_index,
size_t history_index);

float AMotionEvent_getHistoricalRawY(const AInputEvent* motion_event,
size_t pointer_index,
size_t history_index);

- Updated the android-9 C library arm binary to correctly expose at link time new functions that were added to it in Gingerbread (e.g. pthread_rwlock_init).

- Fixed a bug that made gdbserver crash on misc. Honeycomb devices (e.g. the Motorola Xoom).

OTHER FIXES & CHANGES:

- Object files are now always linked in the order they appear in LOCAL_SRC_FILES. This was not the case previously because the files were grouped by source extensions instead.

- download-toolchain-sources.sh: Fixed a silly bug that prevented the --git-date option to work properly when downloading the master branch.

- Fix an issue where a module could import itself, resulting in an infinite loop in GNU Make.

- When import-module fails, it now prints the list of directories that were searched. This is useful to check that the NDK_MODULE_PATH definition used by the build system is correct.

- When import-module succeeds, it now prints the directory where the module was found to the log (visible with NDK_LOG=1).

-<pthread.h>: Fixed the definition of PTHREAD_RWLOCK_INITIALIZER for android-9 API level and higher.

- Fixed a bug where LOCAL_ARM_NEON was defined to true would make the build fail (typo in build/core/build-binary.mk)

- Fixed a bug that prevented the compilation of .s assembly files (.S files were ok).

- Speed-up the build of debuggable applications when there is a very large number of include directories in a project.

- ndk-gdb: Better detection of 'adb shell' failures (improves error messages).

- ndk-build: Fix a rare bug that appeared when trying to perform parallel builds of debuggable projects.

Error generating final archive:Debug certificate expired on ...

After searching on Google, this post(http://stackoverflow.com/questions/2194808/debug-certificate-expired-error-in-eclipse-android-plugins)helps a lot.

Upon installation, the Android SDK generates a "debug" signing certificate for you in a keystore called debug.keystore. The Eclipse plug-in uses this certificate to sign each application build that is generated.

Unfortunately a debug certificate is only valid for 365 days. To generate a new one you must delete the existing debug.keystore file.

For Linux user: Delete your debug certificate (debug.keystore and ddms.cfg) under ~/.android/debug.keystore

For Windows user: Delete your debug certificate (debug.keystore and ddms.cfg) under C:\Documents and Settings\Administrator\.android

Followings are the introductions of handyCalc from it's website http://handycalc.wordpress.com/

-------------------------------------

handyCalc is first be designed a symbolic calculate system to handle some complicated mathematica features. You can:

* Solve equation and equation set
* Define variables
* Define your own functions
* Plot graph

Solve equations

The most common situation is solve one equation with one symbol. For example, x+1=2. Of course you know what x is. So let’s try something.

Notice that there is a equals inside that expression. Don’t press your big equals button on your keypad. Flip to the next keypad and there is a smaller equals.

There are two equals on your second keypad. They are different. The big one means “Solve it and give me the answer”. While the smaller one is the real equals. It gives you a “=” on your input. And that is essential to solve equations.

Now after you input your equation, just press the big equals button. The result will be shown directly.

Try another.

This equation is more complicated than the first one. handyCalc use a method based on Newton method to find it’s root (since v0.3). But as you see, there is a chance that some roots are left behind. In such cases, you can just click the “Show graph and explicit root area” and aim at the cross point of two graphs as shown below. handyCalc will find the most nearest root as you give.

Okay, now let’s try some equation sets.

Notice you have three lines, each line contains one equation. Goto a newline by press the return button on the second keypad or return key on your keyboard. And again, when you finish input, press the equals to solve it.

Variables

Variable is a symbol that you store a value in it. Like the [M+] function on most calculators. The “ans” mentioned in Basic tutorial is a variable, too.

With variables, you can do a lot of things in an easier way.

It’s the Einstein’s famous formula. The first line define the variable m, and the second line define the variable c. c is a constant of light speed in m/s. You probably do not change it. m is the mess. Each time I want to change the mess, I just have to go to the first line, and change it instead of change the formula in the third line. Notice that there is a forth line with a single symbol E. that means just output the E as the answer. Of course you can delete it, but the handyCalc will output every single variable you have defined which is not what you want at this time.

The variable will be existed even you flip to the next page or a previous page. But how to remove that variable? Two ways, you can go to the Document menu and press [New], and you get a new document. And you can go to the Tools menu and press [Variable & Function].

And you have all your variables.

The [x] icon on the rightside means it’s a variable, and the F(x) icon means it’s a function you defined.

Functions

You can define your own functions. It’s similar with define a variable. Let’s try it.

It’s a physics formula which calculate the speed when an object fall from h meters height and hit the ground. The g(gravity)=9.8, and V(3) give you the speed when it’s fall from 3 meters height.

And now you have the V(h) function, and you have the acceleration(g=9.8). You can make a T(h) function which calculate how many time it takes to fall to the ground from h meters height.

Simple and powerful, isn’t it.

Graph

Graph is easy in handyCalc. Just type your expression and there will be a [Draw graph] below.

Press it and the graph is shown. It maybe a bit small in the first time to plot more areas of the graph. You can zoom in (just click the graph or the zoom in button)  to make the graph clear and drag the graph to navigate as you wish.

Also, you can plot multi-graph in one time. Just input multi-line expressions and the graph will be shown in different colors.

NOTICE: when graphing, handyCalc needs a lot of calculation which will slow down your handset.

handyCalc is free. You can donate the developer by purchasing the donation version.

Explosion Particle in Happy Fruit 3D

My base class in this post is not virtual nor doing noting, it is rendering Explosions.

First let's see how to initialize the system:

void Particle::init()
{
	char gVertexShader[] =
		  "uniform mat4 u_mvpMatrix;                            \n"
	      "uniform float u_time;		                        \n"
	      "uniform vec3 u_centerPosition;                       \n"
	      "attribute float a_lifetime;                          \n"
	      "attribute vec3 a_startPosition;                      \n"
	      "attribute vec3 a_endPosition;                        \n"
	      "varying float v_lifetime;                            \n"
	      "void main()                                          \n"
	      "{                                                    \n"
	      "  if ( u_time <= a_lifetime )                        \n"
	      "  {                                                  \n"
	      "    gl_Position.xyz = a_startPosition + 				\n"
	      "                      (u_time * a_endPosition);   	\n"
		  "    gl_Position=(u_mvpMatrix*gl_Position);			\n"
	      "  }                                                  \n"
	      "  v_lifetime = 1.0 - ( u_time / a_lifetime );        \n"
	      "  v_lifetime = clamp ( v_lifetime, 0.0, 1.0 );       \n"
	      "  gl_PointSize =sin( v_lifetime*v_lifetime *3.1416 ) \n"
		  "						* 80.0; 						\n"
	      "}";

	char gFragmentShader[] =
	      "precision mediump float;                             \n"
	      "uniform vec4 u_color;		                        \n"
	      "varying float v_lifetime;                            \n"
	      "uniform sampler2D s_texture;                         \n"
	      "void main()                                          \n"
	      "{                                                    \n"
	      "  vec4 texColor;                                     \n"
	      "  texColor = texture2D( s_texture, gl_PointCoord );  \n"
	      "  gl_FragColor =  texColor;      					\n"
	      "  gl_FragColor.a *= (v_lifetime);}					\n";

	if(gFragmentShader!=0 && gVertexShader!=0)
	{
		gProgram = createProgram(gVertexShader, gFragmentShader);
	}
	if (!gProgram)
	{
		LOGE("Could not create program for particle.");
		return;
	}
	LOGI("particle program ok");

	lifetimeLoc = glGetAttribLocation ( gProgram, "a_lifetime" );
	startPositionLoc = glGetAttribLocation ( gProgram, "a_startPosition" );
	endPositionLoc = glGetAttribLocation ( gProgram, "a_endPosition" );

	// Get the uniform locations
	mvpLoc = glGetUniformLocation ( gProgram, "u_mvpMatrix" );
	timeLoc = glGetUniformLocation ( gProgram, "u_time" );
	centerPositionLoc = glGetUniformLocation ( gProgram, "u_centerPosition" );
	colorLoc = glGetUniformLocation ( gProgram, "u_color" );
	samplerLoc = glGetUniformLocation ( gProgram, "s_texture" );

	LOGI("glGetAttribLocation(\"a_lifetime\") = %d\n",lifetimeLoc);
	LOGI("glGetAttribLocation(\"a_startPosition\") = %d\n",startPositionLoc);
	LOGI("glGetAttribLocation(\"a_endPosition\") = %d\n",endPositionLoc);
	LOGI("glGetAttribLocation(\"u_mvpMatrix\") = %d\n",mvpLoc);
	LOGI("glGetAttribLocation(\"u_time\") = %d\n",timeLoc);
	LOGI("glGetAttribLocation(\"u_centerPosition\") = %d\n",centerPositionLoc);
	LOGI("glGetAttribLocation(\"u_color\") = %d\n",colorLoc);
	LOGI("glGetAttribLocation(\"s_texture\") = %d\n",samplerLoc);
	LOGI("values ok");

	// Use tightly packed data
	//glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

	//LOGI("Particle Tex:%s",tex_name);
	int texidx=texmng->getIndex(tex_name);
	//LOGI("Particle Tex:%s   id %d",tex_name,texidx);
	if(texmng->tex_id[texidx]==-1)
	{
		int w=texmng->tex_w[texidx];
		int h=texmng->tex_h[texidx];
		glGenTextures(1, &tex_id);
		tex_id = createSimpleTexture2D(tex_id, texmng->pixels[texidx],w, h, 4);
		texmng->tex_id[texidx]=tex_id;
		LOGI("Particle Tex ID %d",tex_id);
	}
	else
	{
		tex_id=texmng->getID(tex_name);
		LOGI("Already Loaded:Particle Tex ID %d",tex_id);
	}

	srand ( 0 );
	for ( int i = 0; i < NUM_PARTICLES; i++ )
	{
		float *particleData =&mParticleData[i * PARTICLE_SIZE];

		// Lifetime of particle
		(*particleData++) = 1.0f*( (float)(rand() % 10000) / 10000.0f );
		// End position of particle
		(*particleData++) = 30.000f*(( (float)(rand() % 10000) / 5000.0f ) - 1.0f);
		(*particleData++) = 30.000f*(( (float)(rand() % 10000) / 5000.0f ) - 1.0f);
		(*particleData++) = 30.000f*(( (float)(rand() % 10000) / 5000.0f ) - 1.0f);

		// Start position of particle
		(*particleData++) = 5.000f*(( (float)(rand() % 10000) / 40000.0f ) - 0.125f);//40000 0.125
		(*particleData++) = 5.000f*(( (float)(rand() % 10000) / 40000.0f ) - 0.125f);
		(*particleData++) = 5.000f*(( (float)(rand() % 10000) / 40000.0f ) - 0.125f);

	}

	// Initialize time to cause reset on first update
	time = 1.0f;
	LOGI("Particle init OK");

}

Note the startPosition and endPosition: the explosion particles start at startPosition and are heading to the endPosition. So to make it real, startPosition should be limited in a smaller space than the endPosition. In every rendering loop, we move the particle to the endPostion a little bit.

The particle size is related to it's existing time :

gl_PointSize =sin( v_lifetime*v_lifetime *3.1416 )

Why sine here? Simply because explosion particles are small at begin, bigger in it's middle age and small again when it's going to fade.

Now turn to the update method of a particle:

void Particle::Update(float timeDelta)
{
	time+=0.01f*timeDelta;

	if ( time >= 1.0f )
	{
		time = 0.0f;
	}

}

It's quite easy, a simple particle effect doesn't need complex updating computing, here I just add a time delta to the particle's existing time. You may override this to achieve more flexible effects.

Rendering:

void Particle::Render(ESMatrix &mvp)
{
	checkGlError("Render");
	glUseProgram ( gProgram );
	checkGlError("glUseProgram");
	glUniformMatrix4fv( mvpLoc, 1, GL_FALSE, (GLfloat*) &mvp.m[0][0] );
	glUniform1f ( timeLoc, time );
	checkGlError("glUniformMatrix4fv");
	glEnableVertexAttribArray ( lifetimeLoc );
	glEnableVertexAttribArray ( endPositionLoc );
	glEnableVertexAttribArray ( startPositionLoc );
	checkGlError("glEnableVertexAttribArray");
	glUniform1i ( samplerLoc, 0 );
	checkGlError("samplerLoc");
	// Load the vertex attributes
	glVertexAttribPointer ( lifetimeLoc, 1, GL_FLOAT,
							GL_FALSE, PARTICLE_SIZE * sizeof(GLfloat),
							&mParticleData[0] );
	checkGlError("lifetimeLoc");
	glVertexAttribPointer ( endPositionLoc, 3, GL_FLOAT,
							GL_FALSE, PARTICLE_SIZE * sizeof(GLfloat),
							&mParticleData[1] );
	checkGlError("endPositionLoc");
	glVertexAttribPointer ( startPositionLoc, 3, GL_FLOAT,
							GL_FALSE, PARTICLE_SIZE * sizeof(GLfloat),
							&mParticleData[4] );
	checkGlError("startPositionLoc");

	// Blend particles
	glEnable ( GL_BLEND );
	glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
	glDisable(GL_DEPTH_TEST);
	// Bind the texture
	glActiveTexture ( GL_TEXTURE0 );
	int texidx=texmng->getIndex(tex_name);
	glBindTexture(GL_TEXTURE_2D, texmng->tex_id[texidx]);
	checkGlError("Particle glBindTexture");

	// Set the sampler texture unit to 0

	glDrawArrays( GL_POINTS, 0, NUM_PARTICLES*time*time );

	glDisable(GL_BLEND);
}

Why glDisable(GL_DEPTH_TEST)?
Particles are transparent, if didn't glDisable(GL_DEPTH_TEST), the explosion looks bad. When rendering transparent object, we need disable z-testing and render all these object from far to near.

Happy Fruit 3D is a 3D game developed by AndroGeek.
Different kinds of fruits are falling down from the tree！Hurry up! You need to catch them with your basket!
Control your basket by tilting your phone(put your phone horizontally before start).
It's fun and challenging, enjoy yourself!

See at Android Market:http://market.android.com/details?id=com.billhsu.fruit3d

APP SCREENSHOTS:

QR code:

REQUIRES ANDROID:2.1 and up;

CATEGORY:Arcade & Action;

SIZE:5.1M;

PRICE:$0.99

Demo Video:

いろんな果物は木の上から落ちて、情況は緊急で、あなたは農民のおじさんに代わって、それらをしっかり受け取らなければなりません！

携帯電話を傾くことによってかごをコントロールすることができます（始まる時携帯電話を平面に保たせてください）

ゲームはとてもすばらしくて、ぜひ試してみてください！

開心水果(Happy Fruit 3D)是一個接水果的3D遊戲。不同的水果正在從樹上掉下來，情況緊急，你需要幫助農民伯伯借接住它們！通過傾斜手機來控制籃子（開始時請平放手機）。遊戲很精彩，快來試試看吧！

vs-android (by Gavin) is intended to provide a collection of scripts and utilities to support integrated development of Android NDK C/C++ software under Microsoft Visual Studio.

Currently vs-android only works under Visual Studio 2010. Earlier versions lack the MSBuild integration with the C/C++ compilation systems.

The only required component is the Android NDK. Neither Cygwin, Java, nor the full Android SDK are needed to compile and link C/C++ code.

Features

• Compile and link Android C/C++ projects within Visual Studio.
• Integrated development, no makefiles. Works as another 'Platform' type.
• Android settings co-exist within the same VS projects as other platforms.
• Supports static library projects, and links them in if marked as project dependencies.
• Intellisense and 'External Dependencies' correctly pull in Android NDK headers.
• Cygwin install is not required.
• Around twice as fast as using ndk-build under Cygwin. For full rebuilds, and incremental changes.
• Ctrl-F7: compile single file functions, has no dependency checking wait.
• Supports invoking ant after linking, such that you end up with a packaged ready-to-deploy .apk file.

You can download it from here:
http://code.google.com/p/vs-android/
Really a good news for NDK developers !

In the game Fruit3D ,I used gettimeofday() to get time deltas to calculate objects'  movements, but I'm not really pleased with the performance. Here is the code I used then:

static long getTime(void)
{
    struct timeval  now;
    gettimeofday(&now, NULL);
    return (long)(now.tv_sec*1000 + now.tv_usec/1000);
}

Recently I read a mail list, some guys talked about

int clock_gettime(clockid_t clk_id, struct timespect *tp);

clock_gettime is nanosecond accuracy, so it's a good choice for game timing.
I rewrite my getTime() as below and Fruit3D runs better now:

static long _getTime(void)
{
	struct timespec now;
	clock_gettime(CLOCK_MONOTONIC, &now);
	return now.tv_sec*1000000 + now.tv_nsec/1000;

}

• The r5 binaries required glibc 2.11, but the r5b binaries are generated with a special toolchain that targets glibc 2.7 or higher instead. The Linux toolchain binaries now run on Ubuntu 8.04 or higher.
• Fixes a compiler bug in the arm-linux-androideabi-4.4.3 toolchain. The previous binary generated invalid thumb instruction sequences when dealing with signed chars.
• Adds missing documentation for the "gnustl_static" value for APP_STL, that allows you to link against a static library version of GNU libstdc++.
• The following ndk-build issues are fixed:
  • A bug that created inconsistent dependency files when a compilation error occured on Windows. This prevented a proper build after the error was fixed in the source code.
  • A Cygwin-specific bug where using very short paths for the Android NDK installation or the project path led to the generation of invalid dependency files. This made incremental builds impossible.
  • A typo that prevented the cpufeatures library from working correctly with the new NDK toolchain.
  • Builds in Cygwin are faster by avoiding calls to cygpath -m from GNU Make for every source or object file, which caused problems with very large source trees. In case this doesn't work properly, define NDK_USE_CYGPATH=1 in your environment to use cygpath -m again.
  • The Cygwin installation now notifies the user of invalid installation paths that contain spaces. Previously, an invalid path would output an error that complained about an incorrect version of GNU Make, even if the right one was installed.
• Fixed a typo that prevented the NDK_MODULE_PATH environment variable from working properly when it contained multiple directories separated with a colon.
• The prebuilt-common.sh script contains fixes to check the compiler for 64-bit generated machine code, instead of relying on the host tag, which allows the 32-bit toolchain to rebuild properly on Snow Leopard. The toolchain rebuild scripts now also support using a 32-bit host toolchain.
• A missing declaration for INET_ADDRSTRLEN was added to <netinet/in.h>.
• Missing declarations for IN6_IS_ADDR_MC_NODELOCAL and IN6_IS_ADDR_MC_GLOBAL were added to <netinet/in6.h>.
• 'asm' was replaced with '__asm__' in <asm/byteorder.h> to allow compilation with -std=c99.

See http://developer.android.com/sdk/ndk/index.html

Via nVidia Blog

APK is some like a ZIP file. So we need libzip to help us reading resources from the APK file.

Luckily, I found someone from anddev had packed libzip and libpng for android NDK,  you can download it from here.

We need to add libpng and libzip to Application.mk:

APP_ABI := armeabi armeabi-v7a
APP_PROJECT_PATH := $(call my-dir)/project
APP_MODULES      := libpng libzip YOU_PROJECT_NAME

Add these to Android.mk
LOCAL_LDLIBS+=-L$(SYSROOT)/usr/lib -ldl
LOCAL_LDLIBS+=-L$(SYSROOT)/usr/lib -lz

Here is a snippet for loading apk file, if it works, it will list all files contained in the apk.

	static void loadAPK (const char* apkPath) {
	LOGI("Loading APK %s", apkPath);
	APKArchive = zip_open(apkPath, 0, NULL);
	if (APKArchive == NULL) {
		LOGE("Error loading APK");
	return;
  }

	//Just for debug, print APK contents
	int numFiles = zip_get_num_files(APKArchive);
	for (int i=0; i<numFiles; i++) {
		const char* name = zip_get_name(APKArchive, i, 0);
		if (name == NULL) {
		LOGE("Error reading zip file name at index %i : %s", zip_strerror(APKArchive));
		return;
    }
	LOGI("File %i : %s\n", i, name);
  }
}

There is something to say about apkPath, it is where your apk is. You can generate it in Java and pass it to native code.

String apkFilePath = null;
ApplicationInfo appInfo = null;
PackageManager packMgmr = this.getPackageManager();
try {
	    appInfo = packMgmr.getApplicationInfo("com.yourpackage", 0);
    } catch (NameNotFoundException e) {
 e.printStackTrace();
throw new RuntimeException("Unable to locate assets, aborting...");
    }
apkFilePath = appInfo.sourceDir;
 jni.init(apkFilePath);//pass it to NDK

Now it's time to load PNGs!

int TexMng::LoadPNG(char* filename,bool _alpha)
{
	LOGI("Loading %s",filename);

	for(int i=0;i<nTex;++i)
	{
		if(strcmp(tex_name[i],filename)==0)
		{
			LOGI("Already Loaded");
			return -1;
		}

	}

	if(nTex>=MAX_TEXS)
	{
		LOGI("Too many textures!");
		return -1;
	}

  file = zip_fopen(APKArchive, filename, 0);
  if (!file) {
    LOGE("Error opening %s from APK", filename);
    return TEXTURE_LOAD_ERROR;
  }

  //header for testing if it is a png
  png_byte header[8];

  //read the header
  zip_fread(file, header, 8);

  //test if png
  int is_png = !png_sig_cmp(header, 0, 8);
  if (!is_png) {
    zip_fclose(file);
    LOGE("Not a png file : %s", filename);
    return TEXTURE_LOAD_ERROR;
  }

  //create png struct
  png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL,
      NULL, NULL);
  if (!png_ptr) {
    zip_fclose(file);
    LOGE("Unable to create png struct : %s", filename);
    return (TEXTURE_LOAD_ERROR);
  }

  //create png info struct
  png_infop info_ptr = png_create_info_struct(png_ptr);
  if (!info_ptr) {
    png_destroy_read_struct(&png_ptr, (png_infopp) NULL, (png_infopp) NULL);
    LOGE("Unable to create png info : %s", filename);
    zip_fclose(file);
    return (TEXTURE_LOAD_ERROR);
  }

  //create png info struct
  png_infop end_info = png_create_info_struct(png_ptr);
  if (!end_info) {
    png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp) NULL);
    LOGE("Unable to create png end info : %s", filename);
    zip_fclose(file);
    return (TEXTURE_LOAD_ERROR);
  }

  //png error stuff, not sure libpng man suggests this.
  if (setjmp(png_jmpbuf(png_ptr))) {
    zip_fclose(file);
    LOGE("Error during setjmp : %s", filename);
    png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
    return (TEXTURE_LOAD_ERROR);
  }

  //init png reading
  //png_init_io(png_ptr, fp);
  png_set_read_fn(png_ptr, NULL, png_zip_read);

  //let libpng know you already read the first 8 bytes
  png_set_sig_bytes(png_ptr, 8);

  // read all the info up to the image data
  png_read_info(png_ptr, info_ptr);

  //variables to pass to get info
  int bit_depth, color_type;
  png_uint_32 twidth, theight;

  // get info about png
  png_get_IHDR(png_ptr, info_ptr, &twidth, &theight, &bit_depth, &color_type,
      NULL, NULL, NULL);

  //update width and height based on png info
  tex_w[nTex] = twidth;
  tex_h[nTex] = theight;

  // Update the png info struct.
  png_read_update_info(png_ptr, info_ptr);

  // Row size in bytes.
  int rowbytes = png_get_rowbytes(png_ptr, info_ptr);

  // Allocate the image_data as a big block, to be given to opengl
  png_byte *image_data = new png_byte[rowbytes * theight];
  if (!image_data) {
    //clean up memory and close stuff
    png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
    LOGE("Unable to allocate image_data while loading %s ", filename);
    zip_fclose(file);
    return TEXTURE_LOAD_ERROR;
  }

  //row_pointers is for pointing to image_data for reading the png with libpng
  png_bytep *row_pointers = new png_bytep[theight];
  if (!row_pointers) {
    //clean up memory and close stuff
    png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
    delete[] image_data;
    LOGE("Unable to allocate row_pointer while loading %s ", filename);
    zip_fclose(file);
    return TEXTURE_LOAD_ERROR;
  }
  // set the individual row_pointers to point at the correct offsets of image_data
  for (int i = 0; i < theight; ++i)
    row_pointers[theight - 1 - i] = image_data + i * rowbytes;

  //read the png into image_data through row_pointers
  png_read_image(png_ptr, row_pointers);

  alpha[nTex]=_alpha;
  pixels[nTex]=image_data;
  strcpy(tex_name[nTex],filename);
  ++nTex;
  png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
  //delete[] image_data;
  delete[] row_pointers;
  zip_fclose(file);

  return nTex;

}