From 40c445e9a4744edd228eba4aabd1b49a647a4849 Mon Sep 17 00:00:00 2001 From: saschawillems Date: Sat, 16 Jan 2016 19:23:15 +0100 Subject: [PATCH] Images aligned right for better readability --- README.md | 66 ++++++++++++++++++++++++++++++++++++------------------- 1 file changed, 44 insertions(+), 22 deletions(-) diff --git a/README.md b/README.md index 7c4bffa4..57fb43ed 100644 --- a/README.md +++ b/README.md @@ -23,119 +23,141 @@ All required headers and libs are included in the repository, building the examp ## Examples ### Triangle - +---- + Most basic example. Renders a colored triangle using an indexed vertex buffer, only one pipeline with very simple shaders. Uses a single uniform buffer for the matrices. This example won't make use of helper functions or initializers (like the other examples) and is much more of an explicit example then the others included in this repository. It contains lot's of boiler plate that you'd usually encapsulate in helper functions and classes. ### Texture mapping - +---- + Loads a single texture and displays it on a simple quad. Demonstrates loading a texture to host visible memory (linear tiling) and transforming it into an optimal (tiling) format for the GPU, including upload of available mip map levels. ### Cubemap - +---- + Building on the basic texture loading example a cubemap is loaded into host visible memory and then transformed into an optimal format for the GPU. The demo uses two different pipelines (and shader sets) to display the cubemap as a skybox (background) and as a source for reflections. ### Texture array - +---- + Texture arrays allow storing of multiple images in different layers without any interpolation between the layers. This example demonstrates the use of a 2D texture array with instanced rendering. Each instance samples from a different layer of the texture array. ### Pipelines - +---- + Pipelines replace the huge (and cumbersome) state machine of OpenGL. This example creates different pipelines with different states and shader setups. ### Gears - +---- + Vulkan interpretation of glxgears. Procedurally generates separate meshes for each gear, with every mesh having it's own uniform buffer object for animation. Also demonstrates how to use different descriptor sets. ### Mesh loading and rendering - +---- + Uses [assimp](https://github.com/assimp/assimp) to load and a mesh from a common 3D format including a color map. The mesh data is then converted to a fixed vertex layout matching the pipeline (and shader) layout descriptions. ### Mesh instancing - +---- + Shows the use of instancing for rendering the same mesh with differing uniforms with one single draw command. This saves performance if the same mesh has to be rendered multiple times. ### Push constants - +---- + Demonstrates the use of push constants for updating small blocks of shader data with high speed (and without having to use a uniform buffer). Displays several light sources with position updates through a push constant block in a separate command buffer. ### Offscreen rendering - +---- + Uses a separate framebuffer (that is not part of the swap chain) and a texture target for offscreen rendering. The texture is then used as a mirror. ### Radial blur - +---- + Demonstrates basic usage of fullscreen shader effects. The scene is rendered offscreen first, gets blitted to a texture target and for the final draw this texture is blended on top of the 3D scene with a radial blur shader applied. ### Bloom - +---- + Implements a bloom effect to simulate glowing parts of a 3D mesh. A two pass gaussian blur (horizontal and then vertical) is used to generate a blurred low res version of the scene only containing the glowing parts of th the 3D mesh. This then gets blended onto the scene to add the blur effect. ### Deferred shading - +---- + Demonstrates the use of multiple render targets to fill a G-Buffer for deferred shading. Deferred shading collects all values (color, normal, position) into different render targets in one pass thanks to multiple render targets, and then does all shading and lighting calculations based on these in scree space, thus allowing for much more light sources than traditional forward renderers. ### Omnidirectional shadow mapping - +---- + Uses a dynamic 32 bit floating point cube map for a point light source that casts shadows in all directions (unlike projective shadow mapping). The cube map faces contain thee distances from the light sources, which are then used in the scene rendering pass to determine if the fragment is shadowed or not. ### Spherical environment mapping - +---- + Uses a matcap texture (spherical reflection map) to fake complex lighting. It's based on [this article](https://github.com/spite/spherical-environment-mapping). ### Parallax mapping - +---- + Like normal mapping, parallax mapping simulates geometry on a flat surface. In addition to normal mapping a heightmap is used to offset texture coordinates depending on the viewing angle giving the illusion of added depth. ### (Tessellation shader) PN-Triangles - +---- + Generating curved PN-Triangles on the GPU using tessellation shaders to add details to low-polygon meshes, based on [this paper](http://alex.vlachos.com/graphics/CurvedPNTriangles.pdf). ### (Tessellation shader) Displacement mapping - +---- + Uses tessellation shaders to generate and displace geometry based on a displacement map (heightmap). ### (Compute shader) Particle system - +---- + Attraction based particle system. A shader storage buffer is used to store particle data and updated by a compute shader. The buffer is then used by the graphics pipeline for rendering. ### (Compute shader) Image processing - +---- + Demonstrates the use of a separate compute queue (and command buffer) to apply different convolution kernels on an input image. ### (Geometry shader) Normal debugging - +---- + Renders the vertex normals of a complex mesh with the use of a geometry shader. The mesh is rendered solid first and the a geometry shader that generates lines from the face normals is used in the second pass. ### Vulkan demo scene - +---- + More of a playground than an actual example. Renders multiple meshes with different shaders (and pipelines) including a background.