Deferred Shading - First results

After two posts of theory, and some necessary changes to my classes, the first prototype deferred renderer is ready.

In this post we see the actual results of different G-Buffer formats.

Deferred Shading - The G-Buffer

From my point of view, most important aspect and point of interest so far in a classic deferred renderer is the G-Buffer.

As they say, the devil is in the details - while it is a quite simple and elegant idea (storing material properties per-pixel instead of calculating results at first pass), it can get quite involved as soon as you enter the real, performance-optimized, world.

Deferred shading - some theory

All right, this post will be a little incomplete due to extreme lack of time the past days.

Two words for theory, and a promise of an update to the post with some screenshots in the week.

Multiple shadow-casting lights, long overdue

Ok, I admit it. So far, I cheated. I only used a single light, with provision but without implementation for multiple lights, especially shadow-casting ones.

Screenshot first, talk later.

True displacement mapping with tessellation

Well, we are now officially in 2013+ territory.

The techniques implemented here actually will not work unless you have a new generation graphics card capable of OpenGL 4.2 or DirectX 11.

Displacement mapping, as a theory, is not new. It is in fact quite simpler in essence than bump mapping. But the implementation has a big problem.

Parallax Mapping (or, tangent space revisited)

The eye gets used to what it's seeing quite soon.

Normal mapping is actually an order of magnitude more realistic that classic texturing.

But the illusion is fragile. The illusion of depth is quite easy to see through as soon as the viewing angle changes - the real flatness of the surface becomes apparent, or at least easily detectable, soon enough.

Something more is needed, something basically unrelated to normal mapping, but ultimately similar in tools to it.

Parallax mapping, or, the simplest form of Virtual Displacement Mapping.

Spot the difference?

GR Graphics DX 11

GR Graphics GL

Don't bother, there isn't a difference, it's pixel-perfect. Or rather, it would be, but there are a  few pixel's worth of difference between OpenGL and DirectX is because the camera was positioned by hand.

DirectX takes shape

While it might not be the most efficient way to create to parallel libraries, the "Big Bang" technique sometimes has its merits. Here I describe the first steps of porting the GR Graphics library to DirectX.

Hello, DirectX

The biggest, step apart from the first, was putting my money where my mouth is.

Actually proving that GR Graphics design was Api - Agnostic.

That I could expose the same classes to use DirectX or OpenGl, even though I had not finished templatizing everything yet.

GR Graphics GL - A tesselated terrain

Ok, I admit, back then the first time I read about tessellation a few years ago, when I was still using OpenGl immediate mode and thought it was difficult, I was quite intimidated and thought it was some fancy black - magic thing that is impossible to grasp, let alone do.

Well, it turned out a lot less intimidating than I thought at first.

The road so far : Wows and Shadow Mapping

Creating a Graphics library is really a fun and creative project. The "oh-snap" moments, or "Wows" when you get to the next level of realism feature are just beautiful.

Or it might just be me, in which case, just substitute the "You" by "I" and the present tense with the past tense.

GR Graphics GL - Getting closer to the present with Normal maps

Features added, features enhanced, interfaces polished and others, it was a time to leave 1995 and simple texturing, and start with a few interesting features had to be implemented.

I downloaded a couple of free normalmaps, and implemented the NormalMap plugins and shaders half expecting it to be as dissapointingly easy as the texture ones.

I was in for a surprise.

Gr Graphics GL - Textures and Spotlights, plus the explanation of templated configurations

The next shader was for classic, old fashioned, simple texturing.

GR Graphics GL - The first shaders

In its initial creation, the GrGraphicsGl used client memory to store per-vertex attributes and uniform buffers for the per-object attributes.

Using just the positions and the normals plugins, the first toy example (PerVertexLighting_vs.glsl + PerVertexLighting_ps.glsl) were created.

GR Graphics gets graphics

This post describes the first steps and the main Shader class for the GR Graphics library, OpenGL binding.

GR Graphics begins, and loading objects

Gr Graphics began with re-shaping and re-adapting what I learned from GR-Collider to create a graphics-suitable Mesh.

I intend to merge the two classes again in the future, but rapid prototyping meant that this will have to be delegated to the future.

GR Graphics

A page for GR Graphics, my framework - agnostic, shader-flexible OpenGL/DirectX11 graphics engine/ graphics prototyping framework.

I will be spending quite some time updating it with screenshots, code samples and probably videos.


Read more about GR Graphics

GR Collider added

A page for my next, more advanced Physics Engine was added, GR-Collider. This was a completely independent creation, in the interest of creating a portfolio. I really like its demo, If you are interested in physics simulations, I would suggest to follow the link to download and run the demo.

This project was around 2 months worth of my free time. It was worth it.

Read more about GR-Collider.