Tuesday, May 24, 2011

Vliv support for WebP format

Now that WebP is supported widely, I have created the little plugin for Vliv that allows loading a webp image.
It is very simple, as only two API calls are necessary, WebPGetInfo and WebPDecodeBGRInto

On a sample image found on the web it seem to work fine, and is quite fast. The final plugin dll is only 106496 bytes thanks to a precompiled webp library for Windows (libwebp-0.1.2-windows).

Vliv framework is an ideal way of testing new formats as its API is very simple, the entire code for loading WebP images is 85 lines of C.

Source code is available on demand.

Wednesday, February 9, 2011

Google Art Project

Google Art Project is a collection of very high resolution images of paintings/photos.
Unfortunately it is only available through the Web...
So I made a quick hack to generate offline images suitable for display with my viewer, VLIV.
It is incredibly easy to get the data, but I will not disclose how, since the Google Art Project license prevents it.

Here is a screendump of Van Gogh's Starry Night in Vliv.

Friday, July 30, 2010

New world record for panoramic image

This one is 70 gigapixels (590508 x 120750).
Very impressive.
They are using Silverligh to display on the Web.
Such a large image should be viewable by VLIV, it just need the file (actual format is unknown, looks to be PPM) to be converted to TIFF (actually a 64 bit TIFF).
Final image size is about 200 Gigabytes, not something you download or store easily !

Wednesday, July 28, 2010

Download VLIV latest version 2.5.2

Here is the direct DropBox link, and some sample images :
These are tiff images that have pyramidal organization. You can also load normal Jpegs (preferably large ones), so that you can see virtual tiling in action.
Here is a medium one (15 megabytes)

Thursday, October 22, 2009

OpenGL Vertex Buffer Objects

I recently updated my 3d object rendering code to VBO, introduced in OpenGL 1.5. Using them is very simple, and only need 4 additional API calls. Basically, the vertex data, normals and indexes are sent to the graphics card, stored in there, and accessed through an ID. At draw time, only one or two call with IDs are sufficient and performance is very much improved over using previous Vertex Arrays API, because no data is transfered. My frame rate was multiplied by 2 at least and I can now display up to 150 000 000 tris/s on my GeForce 8800 GTS, hardly the fastest card these days.

I also found GLEW library during this work, very nice and useful to develop OpenGL applications, because of poor header support in MS SDK. It allows using API calls without bothering if they are in headers or not, thanks to clever dynamic loading features at runtime and extensive coverage of OpenGL extensions.

Update: After some tests, the number of tris/s is about 230 000 000 on my 8800 GTS.