Updated Market Application

So the market application has been updated a while back to include some of the great work that was done. We implemented Vertex Buffer Objects to increase speed dramatically while using shaders to color the fluid simulation!

We are at almost 2,000 downloads for the application and rank at 38th overall for Top Free Software Libraries!

We are hoping we can get this to the top 20 by the end of June and speak to some developers on getting them to incorporate it into their applications.

The next post will include the work we will be doing in the summer. We lost one of our teammates but have more time now to push on with having a full fledged visualization library by summer's end

On Marketplace

Yo,

If you're interested, a quick and dirty version of our current build of droidViz is on the marketplace for a free download.

If you have a Nexus One, or the new HTC Incredible, let us know how it performs. We're still working out bugs and adding features and visual splendor.

Just search "droidViz" on the marketplace.

End of line.

-Griff

GitHub Up and Running

Hey everyone,

So we decided to get our source up on GitHub so the word on droidViz can get out faster and be expanded upon. Right now, the most up-to-date source is located at:

http://github.com/seanpaulaustin/droidViz

Go ahead and fork it, get involved and enjoy!

We will be posting an update to our progress on the source in the coming days.

Touch Input Working for Density

So we said we would do it and we did! The touch input is now spawning the density sources on the screen. This is great progress and puts the visualizer on track for a full demo with multiple effects by the end of the semester. Check out the video below or on the youtube link provided.




http://goo.gl/PVwy

And the for Android users to use the QR code which will open a youtube video.


The group will now be working on modulating color based upon the velocity vectors and creating a particle/jet generator that will emit particles into the fluid simulation. We're all very optimistic on having a great demo application to showcase the library that can be released on the market by semesters end!

Density Rendering!

Also available here -> http://goo.gl/XvrO
and those Android users out there who want a QR code -> http://goo.gl/XvrO.qr




Basically, the video says it all. The fluid solver is now rendering the smoke in real-time on the G1 and the Droid. YES! This is without any optimizations so the future look very bright. Moreover, we should have the touch input working within the day so look for that video in the very near future.

Progress!

Well, after midterms and some other tough schoolwork, we've finally made some progress on DroidViz.

Most notably, the vector fields are now rendering in fullscreen. In the fluidsolver project referenced earlier, the window's bottom corner is (1,1) and the top opposite corner is (0,0). For some reason, the default window size in GLES on the android is from -1 to 1, with (0,0) directly in the center of the window. After adjusting our calculations, we now have things rendering in fullscreen.

Most importantly, the code in svn now compiles and runs. We were running this code in a separate project hosted elsewhere until we could get our stuff together. I've just spent the last few hours cleaning up the Google Code SVN, formatting code, porting stuff, etc. Things are finally current on the SVN. Feel free to check it out if you want.

Most exciting, Google has just released the NDK, revision 3. With this release, we now have access to OpenGL ES 2.0, and with that - FRAGMENT AND VERTEX SHADERS. OMFG. We'll be able to make droidViz DROP DEAD GORGEOUS. We're pretty psyched here, so we'll be spending more time on development to get this out sooner than later.

Keep it real,

-Griff

F*** YEAH SEAKING

Well, we finally have something interesting rendering!

We are running un-optimized fluid code (read: using floating point numbers (eew) ) on the android, and we're able to render a simple vector field. YAY!

The changes needed for Jos Stam's code were simple. Instead of using GL in immediate mode, we needed to give GL ES a vertex array and tell it how many entries within this vertex array to render.

CODE:

static void draw_velocity ( void )

{

int i, j, k;

float x, y, h;

h = 1.0f/N;

// This Disable Client State is not needed every frame. (OPTIMIZATION)

glDisableClientState( GL_COLOR_ARRAY );

glColor4f ( 1.0f, 1.0f, 1.0f, 1.0f );

glLineWidth ( 1.0f );

// An index for the vertex array

k = 0;

// Update the vert array

for ( i=1 ; i<=N ; i++ ) {

x = (i-0.5f)*h;

for ( j=1 ; j<=N ; j++ ) {

y = (j-0.5f)*h;

line_verts[k++] = x;

line_verts[k++] = y;

line_verts[k++] = x+u[IX(i,j)];

line_verts[k++] = y+v[IX(i,j)];

}

}

// Draw the new array

glVertexPointer( 2, GL_FLOAT, 0, line_verts );

glDrawArrays( GL_LINES, 0, ( N * N * 4 ) );

}

Because input will be coming from the touch screen, we need to figure out how to handle this at the NDK level, or simply pass it in to the NDK level from the Java level. Currently, we're just setting the input variables at compile time. This is producing good results.

Unfortunately, the algorithm is not stable. I blame the floating point numbers, but this remains to be seen. We'll be investigating in deeper detail later.

This code will be uploaded to SVN within a day or two (intermittent internet connection problems ahoy...)

-Griff