Well the current title is telling everything no?
I know some people believing really hard that D3DX customizable structures and functionnalities aren't associable with fast reply to some problems and low-level access to data. That was the case of this module when I wrote it. Even if it's better for applications to have pre-processed informations to decrease loading time, sometime you might need to rebuild a few data from other informations. That's the case of smooth groups which influences a mesh normals calculations.
What we'll be available in this demo is a simple 3DS file loader with vertices/material/smooth groups informations and a module to translate the loaded file into a D3DXMesh (D3DX contains so much unknown/unused power ) and then compute the tangent space with smooth-grouped normals using almost only D3DX code.
The module is ready to roll but I'll post it as a small demo including a simple typical 3ds mesh to demonstrate the importance of good normals…but it'll postponed a little bit since Sourcenext finally put out a patch for RE4 that makes it worth of being call PC games (at least it has the minimum)
Time for a new demo that I had in mind for some times, but since I was kinda busy lately I never done them before.
I wanted to build a simple layering system with each layers supporting a list of objecs and see what kind of result it could bring; that's what I've done for this one, completing in the same pass the previous post-process demo, because this one support antialiasing. Since I wanted to do something else (and better) than the "standard DirectX sample", I completly redesigned my source code. I think it would make it a bit harder to understand for people when I'll do some demo, but I'll always keep documenting code as I always do and make it the simpliest possible.
So, now I've designed a new demo and rewrote the postprocess sample demo with a bit more of flexibility too. Currently the engine is featuring some nice things such as :
Per object effects
Layering with inter-layer blending by shaders (still searching to optimize this, and maybe will be derivated as a rendering-job system)
MRT rendering in one or multiple passes (automatically detected by analyzing the scene's real-time shaders output semantic and the hardware caps)
Post processing support for each layer (layering and AA puts quite hell of an impact on performances so I'm currently trying to optimize the thing the best way possible)
Full antialiasing support (currently using a simple smart surface downsampling method but will try to put another one like simply disabling AA for post-processing operations which will boost the thing a little bit and should make a neat memory usage economy for a near-0 difference rendering).
A bunch of new post process effects (emboss, deformation, radial blur…)
A new real-time effect to fake background deformation, using mesh normals projected into screen-space
Whereas the base idea is nice (I can directly think of a nice effect like a wiggling edge blured+distorded ghost floating in a dark room), I think it's kinda impratical for a few reasons:
- The first one is the impact performance if we would have to post process a lot of layers and blend them each time
- The antialiasing generates a silouhette for each objects on upper layers, and I think there is no way to avoid this since it's directly linked to alpha values
- Same thing for blur effects that don't samples anything from the previous layers because it would double the number of texture sampling calls.
The demo is available here
The source are available here
It sounds like I'll not have the time to put a better source code for the PostProcess sample in the next days. I'll upload the current one now, but as it have the vocation to be a simple but performant engine it'll change a lot and sometimes radically. To be straight, I didn't really planed what "I'll do next", and since I've got some other important things to do at the moment, I don't know what'll be done and when (but most likely to support multi-passes rendering and antialiasing).
You can download the source code here
The PostProcess Framework article as also been updated with the source code.
Another school project, since it's a commercial one I won't be able to give you the sources. Put simply, it's a real-time terrain viewer based on the R.O.A.M technique, build to run on multiple plateforms (Win32/64, Linux, MacOS) and centered on low-end machines (at least when I did it). The demo uses a sonar raw data to generate the terrain and includes many classic techniques and effects like : caustics using animated multitexturing, alpha blending (for underwater flora for example), 3DS mesh imports for objects like fishes or rocks, skyboxes, frustum culling, selective patches level of subdivision, z-sorting…
The powerpoint presentation (PPS) is available here
Here I'll put the demo of a software I wrote as a school project that simplify meshes using multiples criteria and approches:
Vertex to vertex magnitude
Vertex weight (increasing/decreasing)
Quadric error metric
Vertices reduction control using number and percentage factors
I don't think I'll not put the sources since there were wrote using the "La Rache" method (http://www.la-rache.com/) for fast, ugly and inneficiently programming thanks to a lot of pizza, beer and a small amount of time!
The demo is Win32 (of course, Windows for the win!) compiled with VS2003 Toolkit
You can download it here
You can download the powerpoint presentation by clicking here