Topic: OpenGL4.0 C++ GLSL

Detailed Question: Please have a look at this YouTube tutorial first, you need to create a similar Sonic the hedgehog 3D Graphics Game using OpenGL4.0 version only, C++ and GLSL.

https://www.youtube.com/watch?v=u9Ocuv6TzdA

Lab 3 solution:

Please run this solution in Microsoft Visual Studio 2013

Template: http://www.filedropper.com/lab3

Replace the CatmullRom.cpp and CatmullRom.h files that are attached in the Lab 3 solution (Template). The template contains old CatmullRom files. Your starting point is to work on PathstartingGuide.pdf first, see attached. You will need the template (Lab 3), follow all the steps in this guide and make sure there is a path first.

The next step is to work on the tasks attached. Please have a look at that for the game requirements.

Task:

Your task is to create a 3D graphics scene using OpenGL matching the theme described above. Your creation will include a path following a non-linear path on which the game or simulation will occur. There will be a series of camera views.

Technology:
You are to use OpenGL, C++, and GLSL for this coursework, using the Windows API. It is recommended that you use OpenGL 4.0 or higher, although you are permitted to use OpenGL

3.3 (if your development hardware does not support OpenGL 4.0). The rendering context must be confgured as a core context.

You are to program the game using Visual Studio, either 2013 (recommended) or 2015. You are welcome to include other libraries as long as they are sufciently packaged with both the source code and the fnal deployed executables. Deprecated fxed function programming through use of a compatibility context is prohibited and will receive zero marks - this is a module on modern OpenGL programming.

Source code to be commented and follow a logical design, organisation, and coding style (i.e., use of classes).

Path and camera (25%):
Path (15%)
o Create a 3D non-linear centreline for your path, based on splines with C1 or higher continuity. Create primitives to generate a path on which the gameplay / simulation will occur.
o Ensure your primitives have correctly oriented normals and texture coordinates. Render the path with appropriate texturing and lighting.
o Note: the path must be generated programmatically, using OpenGL primitives. Building the path geometry in 3D modelling software and loading it as a mesh is not permitted.

Camera / viewing (10%)

o The graphics template code allows the user to control camera movement in a "free view" mode. Retain this type of camera movement as an option (useful for debugging and visualisation).
o Implement at least two of the following camera modes:

1. First person: Add a keyboard control to place the camera so that it provides a frst person view allowing the player to move along the path.

2. Third person: Add a keyboard control to place the camera either in or behind the player (rendered as a mesh).

3. Side view: Add a keyboard control to place the camera to the side of the player character (mesh) moving along the path.

4. Top view: Add a keyboard control to place the camera so that it provides a top view of your scene, but follows the player moving along the path.

o You will likely fnd it helpful to use a TNB frame for specifying the camera viewing geometry.

3. Basic objects, meshes, and lighting (30%)

- Basic objects (10%)
o Create at least two diferent basic objects from primitives. Examples could include a cube, tetrahedron, torus, cylinder, cone, disk (other surfaces are possible). Render these objects using triangle primitive types (GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN). Note that the basic objects (plane, sphere) given in the template code do not count towards this requirement; nor do meshes loaded into the scene. However, shapes created in labs can count towards this section.

o Apply appropriate texture coordinates and normals for your objects. Render these objects using texture mapping and lighting.
o Transform the models to have an appropriate location, orientation and scale within the scene.

- Meshes (10%)
o Load at least two diferent texture-mapped mesh models (with appropriate normals) to the scene using the model loader code provided in template code. Populate the scene with objects that match your theme. Note the mesh models (horse, barrel) already provided in the template do not count towards these models.
o Transform the models to have an appropriate location, orientation and scale within the scene.
o Create parts of your scene using repeated mesh objects (e.g.rows of pickups, obstacles, etc.).
- Lighting (10%)
o The OpenGL template has a general lighting for all objects. Implement at least one additional dynamic light in your scene.

4. Head's up display (HUD), gameplay, and advanced rendering (30%)
- HUD (5%)o Include a head's up display to provide information to user (time, speed, score, fuel, place, etc.).
- Gameplay (5%)
o Implement control of the player position on the path using the mouse or keyboard. Animate the player movement.
o Implement gameplay to make the game interesting to play. You're free to design the gameplay as you wish, but it should not be trivial to play. Some suggestions include:
- Time-trial racing: The player seeks to get from the start to fnish as fast as possible. Obstacles and/or speed-ups enhance gameplay.
- Points: The player seeks to achieve as high a score as possible, by collecting pick-ups. Obstacles may cause damage or lower score.
- Shooter: The player defeats enemies by shooting at them.
o Utilise basic collision detection using standard techniques (e.g., distance between player and object).
- Advanced rendering (20%)
o Implement at least two advanced rendering techniques. At least one of these techniques should involve shader coding. Some ideas for this include the following:

- Easier:
- Blinking (e.g. Lab 1; or rendering/not rendering an object using a timer)
- Wobble
- Fog
- Animation using discard in the fragment shader
- Toon shader
- Camera shake
- Instanced rendering
- Multi-texturing
- Harder:
- Particle animation
- Environment mapping
- Render to texture
- Blur
- Perlin (or related) noise
- Bump mapping
- Bloom
- Shadows
- Use of a geometry , tessellation, or compute shader

- In your report, be sure to describe the techniques implemented, and how they work.

Notes:
All source code should be commented. Clearly mark any code that you have written and any code that is externally produced. Use appropriate naming conventions and display an organised code strategy (header fles etc).

If additional libraries are used, make sure that these are sufciently packaged with both the source code and the fnal publicly deployed executables to allow the code to be run on any lab machine.

Attachment:- catmullrom.zip