Compute Shaders - Parallel reduction for luminance measurement

So, how do we actually use the HDR render target mentioned in the previous post? What can we actually DO with color values that are greater than 1.0, since the screen will ultimately display them as 1.0? And how do we use a compute shader to make our life easier?

HDR Lighting - Intro to HDR, and HDR render target

HDR lighting is a very very big subject, but in a graphics or gaming context it basically means using some kind of average luminance measurements or other heuristic to tone-map our image differently to the "classic" effect. The reason to do that is that the "classic", LDR format actually proves too restrictive to provide us with a very realistic or artistically beautiful image on a scene that is designed to be real-time created.

Compute Shaders - Overview and theory

The compute shaders in both DirectX and OpenGL allow us to use the GPU in a way that is not pipelined as object->primitive->pixel.
In one sentence, what they allow you to do is dispatch an arbitrary number of GPU computing threads that operate in an arbitrary way on resources.

GR Graphics - Post Processing

The conceptually and temporally final step before display on the screen, which is also optional but practically ever-present in modern graphics, is post-processing.

Post processing is basically any processing that happens after you create a ready - to - display 2D image from your 3D model data. HLSL and GLSL gives you a very convenient place to perform that post processing in the pixel shader.

Deferred shading - Dealing with low precision normal artifacts

While the G-Buffer format I described at the previous post was quite workable, after careful examination, in close-ups, some artifacts DID pop up.


As in most "real" detective stories, the culprit is really the "obvious" candidate. Obvious?

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.

Vesper 3D added

A page was added for Vesper3D, the first physics framework that I wrote as my postgraduate thesis in the University of Pireus. It was an attempt to design and implement a framework that would enable a programmer to prototype physics laws in as loose and arbitrary a way as possible.

Read more about Vesper3D

Welcome

First post in my blog. I intend to showcase various works and projects here as my portfolio, and follow the progress of some of them. The theme is Graphics and Physics.

The actual dates on the posts up until 15/4/2013 are not either the day of creation or the day of posting, but are laid out sequentially so that the posts are separated correctly.

If you wish to know more about me, please visit my profile on LinkedIn.