Mandatory features

• Perspective camera
• Textured models
• Ambient, diffuse and specular lightning
• First person camera

Optional features

Required amount of features are in brackets

Core techniques (1)

• Deferred Rendering #2
• Basic deferred rendering, with at least one light pass at the end rendering a full-screen quad
• Basic Phong shading with a point light (ambient, diffuse, specular)
• Verify that removing each term of the lighting equation produces the expected result
• Skeletal Animation
• Get the animation to play, and correctly interpolate the poses.
• If you load an m3d for animation, this would also count as "Parsing and rendering of a existing model format"

Geometry (2)

• Parse and rendering existing model format
• Should support at least one basic material with at least one texture. A material can be simply a color.
  The material has to come from the mesh or material file, not hardcoded in the code
• The mesh does not necessarily have to be "in parts"
• Displacement mapping using Tessellation shader
• This should be a coarse mesh, that gets tessellation applied in the GPU pipeline and then displaced using a displacement map.
• The tessellation level can be fixed (hardcoded)
• To show this, you need to be able to disable the tessellation and the displacement
• Height-map terrain rendering, user can walk on the terrain
• The "walking" on the terrain feature does not have to be smooth
• The terrain map can be fully regular (same size of triangles everywhere)
• Level of Detail (LOD) using Tessellation shader
• Can be terrain, or a basic model
• The criteria for simplifying the mesh can be camera distance or controlled by the keyboard
• If it is terrain, does not have to "perfect" alignment between patches.
• Morph-based vertex animation
• Any form of Morphing between keyframes for a set of vertices.
• The key part is having a set of keyframes, along a time line, and being able to specify a time between 2 keyframes and
  get the vertices linearly interpolated. This can be done in the CPU every frame, or store the keyframes in a buffer in the GPU
  and interpolate in the vertex or geometry shader (preferred)

Texturing and Lightning (1)

• Normal mapping
• You can reuse existing maps from other sources.
• You need to understand how the TBN (tangent, bi-tangent, normal) matrix is built and used to adjust the normals
• Screen Space Ambient Occlusion
• *Blend mapping (multi-texturing)
• Show the blending working correctly, the render state settings, blending equations and the shader sampling the textures.

Projection Techniques (1)

• Shadow mapping
  This questions can come up when presenting this techique:
  • Do you know how to change the shadow map resolution?
  • Do you use PCF? If yes, do you understand the basic idea?
  • Do you suffer from self-shadowing or acne, do you understand the reason?
  • Do you understand why the "perspective divide" applied to the position projected with the light MVP?
  • Do you know how is the transformation from projected position pos to (u,v) space in the shadow map?
• Shadow volumes
• Compute the shadow volumes, can be in CPU or GPU
• Understand the algorithm presented in the lectures
• Dynamic cubic environment mapping
• Reflections have to be updated dynamically as the camera moves on the objects that have this feature.
• Dynamic paraboloid mapping
• Reflections have to be updated dynamically as the camera moves on the objects that have this feature.

Acceleration Techniques (2)

• View frustum culling against a quadtree
• You can build the quadtree when the application starts
• Ideally you should work on bounding volumes (spheres or AABB) surrounding your objects
• The depth of the quad-tree has to have at least 4 levels (use recursion)
• It can be sparse or regular (a sparse would be a quadtree that has not been further subdivided in certain branches because there
  is no geometry there
• You have to show that the culling is happening outside the frustum.
• This can be shown in several ways, but the best way is to have a separate camera, looking from the top downwards at the scene,
  and be able to move the camera used for culling with the keys to see the geometry being culled.
• Front to Back rendering
• Occlusion Culling
• Back face culling using Geometry Shader
• Need to prove that work correctly! Not just eye-balling the code
• For example, can make a triangle to rotate and face back towards the camera

Acceleration Techniques (2)

• Particle systems with Billboarded particles
• Particles update can be in the CPU, unless the particles are always at the same height of the camera, they should be aligned to
  the camera looking direction, and not just one up axis (Y)
• Guassian filter
• Bilateral filter
• Mouse Picking
• Some feedback that the picking works. Picking against any shape will do it, but it has to work properly not just in the center
  of a big sphere.
• Screen-Space Antialiasing
• We only covered FXAA, but in any case you should have a basic understanding of how the technique works.
• Water-effect
• Water movement, there are many ways to achieve some water-like movement
• We do not care how it looks in therms of refraction and caustics, or collisions with other objects in the water.
• Glow-effect
• Should be able to adjust the intensity of the glow (it sis possible to recompile to change)
• Solve any technique listed in this category using Compute Shader (count as 2!)
• Combiation of Compute shaders and any of the previous listed tasks will give you 2 points. Eg. blurring using CS will give you 2
  points in this section.
• If you find another task not listed above then using Compute shaders will count only as 1 point (ask the teacher before
  implementing!)
• Make a small game with the engine
• The game should be minimal, but playable. You can re-run the application to restart the game. The game should have some basic
  goal, and the user should be able to affect in some way the surroundings.

• Basic deferred rendering, with at least one light pass at the end rendering a full-screen quad
• Basic Phong shading with a point light (ambient, diffuse, specular)
• Verify that removing each term of the lighting equation produces the expected result