COMP3016 IMMERSIVE

Coursework 2023-24 MODULE CODE: COMP3016
COMP3016 IMMERSIVE
GAME TECHNOLOGIES
20 CREDIT MODULE/100% COURSEWORK SUBMISSION
MODULE TUTOR: Sebastian Outram
MODULE AIMS:
- To gain and apply programming concepts and techniques that are used in
demanding real-world industrial settings, e.g. programming in an unmanaged
environment.
- To gain experience in software design and engineering working from concept
to finished prototype.
- To gain experience with different programming languages and environments.
- To establish the mathematical concepts required for the development and
programming of high-performance real-time graphics, such as vector and
matrix maths.
- To provide experience using a graphical API such as OPENGL.
ASSESSED LEARNING OUTCOMES:
1. Apply core programming principles (including mathematical concepts within
a high-performance real-time environment such as graphical
programming/game-engine programming.
2. Design, conceptualise and implement a working prototype with clearly
defined features.
3. Articulate method of approach and rational for solution.
OVERVIEW
This module introduces concepts & programming techniques for working with un‐managed code, i.e.,
using graphical APIs like OpenGL through C++. It provides industry relevant skills for domains such as
high-performance real‐time graphics or closer‐to‐the‐metal programming. The module uses a bottom‐
up approach; it is not about the use of game engines and high‐level prototyping tools. Students will
gain highly transferrable software engineering skills.
Lectures, Seminars and Workshops are integrated into the module to introduce concepts and deepen
the understanding of topics as well as to guide the project work.
Coursework 2023-24 MODULE CODE: COMP3016
P a g e 2 of 9
Coursework elements include an Individual research presentation to inform the development of a
prototype and individual projects with supporting documentation.
100% Coursework Comprising Two Individual Elements
Assignment A: Text-based Game 30% Working individually on a text-based game using OOP design
paradigms and programming skills in C++.
Assignment B: Individual Software Project 70% Working individually on a project, find, defend &
agree a topic with staff. Research and produce a short industry standard portfolio piece (polished
GitHub page) and a video presenting your product/research.
MODULE DELIVERY
Delivery format: Weekly 2hr lecture Thursday from 1pm – 3 pm
Weekly 2hr lab Thursday 11am ‐ 1 pm
Delivery staff: Ji-Jian Chin – ji-jian.chin@plymouth.ac.uk
Sebastian Outram – sebastian@outram.org
Duration: 12 weeks Semester 1
Assessment Offences:
For this assignment you may be using information from differing sources:
• Books, journal articles
• Course/module materials
• Websites
• Existing Open-Source Projects

It is very important for you to note that this assignment is an individual effort. It should make the
contributions from the student and the use of external resources, or an initial start base clear.
Thus, do not simply copy existing sources, i.e., other students work, interspersed with a few lines of
code or words of your own. This is paraphrasing, and it is not encouraged, it is not likely to get you a
good mark and, in some cases, it could be seen as plagiarism. In a similar vein, do not simply copy
material from elsewhere without citing it properly. For more information on how to write texts,
reference source material and plagiarism in general, see:
https://www.plymouth.ac.uk/student-life/your-studies/essential-information/regulations/plagiarism
If you have any doubt as to what constitutes ‘an individual effort and in your own words’ then either
see your student handbook or see me.
Coursework 2023-24 MODULE CODE: COMP3016
P a g e 3 of 9
Coursework Part C1 – Console-based Game using C++ 30%
DESCRIPTION
This is an individual assignment. It will help us to estimate where you currently are in terms of
capabilities.
The ultimate aim is for you to demonstrate that you can understand writing unmanaged code in the
object-oriented paradigm, interacting with different data types and the underlying code for moving
things to and from memory, thus handling some of the complex aspects needed for writing game engine
code, at the same time having a hand at some creativity to develop your own flavour of a text-based
game in the terminal console.
For this assessment, you should use modern C++ without making use of C primitives and procedures
as much as possible (e.g. using string over char*).
Your source code should compile without errors with a working executable file that runs on its own,
accompanied by a suitable UML design document and a simple instruction manual on how it works.
Other than that, the other requirements should be that it is fun and accounts for quality e.g. passes as
many test cases as possible, difficult to crash with improper inputs).
To complement the development, you should write a brief introduction and description which details the
setup, usage and how the code fits together to be used in other cases, including a proper UML design
diagram for your game. For the video you may use this to walk us through your game. As part of the
video, you need to show how the software runs and compiles.
DLE DELIVERABLES
A single zip named “CPPGame.zip” containing:
o An executable version of the game which does not rely on VS. o Include any
resources such as extra assets that your project needs.
o A brief write-up in markdown format (*.md), describing:
o Visual Studio and Operating System version you used to test/write
the code locally?
o How does it play?
o UML design diagram
o Exception handling and test cases
o Further details that help us to understand how your prototype works.
o A link to the Video (unlisted YouTube)
o A link to the game git repository
Coursework 2023-24 MODULE CODE: COMP3016
P a g e 4 of 9
Deadlines:
Part Description Deadline Percentage
C1
Standalone CPP Game:
Demonstrate expertise in
working with unmanaged
code: C++
30%
Console-based game: Implement a game in C++ and
upload to your git repository, then share the link in the
readme. Your game needs to adhere to OOP concepts and
additionally be able to load file content during execution. Do
enough testing that it doesn’t crash upon unexpected input
and document these tests. Lastly, add in as many features
as you can to make it story rich and/or fun!
21
st November
Demo Video: Provide a UML and code walkthrough,
including functional playthrough in a short 10min video.
21
st November
Marking Rubric
Category Fail > 40% > 60% > 80%
CPP Game
(30%)
No submission
on classroom
for
Assessment.
Software does
not compile.
GitHub not
updated.
Plagiarising an
existing project
No Video
Provided.
Game performs as
described in
readme, without
much fun
factor/immersive
story included.
No Object-Oriented
design practised.
Game data loaded
from simple text
files.
Executable file
works on most
cases without
crashing.
Understandable
video with simple
writeup.
Game loads multiple
files with increased
format complexity
Game crashes
minimally with
proper documented
exception handling.
Some ObjectOriented design
practised.
Average fun factor/
mediocre story
presented.
A tidy
repository/DLE
submission without
additional redundant
files.
Comprehensive
readme report and
video walkthrough
Addition of complex
multimedia files and
playback to augment
gameplay.
New experiences and
augmented interactivity
provided with
integration with AI at
every new game
iteration.
Highly efficient OOP
design
High fun factor/
immersive story
Demonstration of high
programming skills in
development
Additional researchproven approaches with
proper references in
instructions.
Please refer to all the lecture content & further study resources on the DLE. A more
comprehensive rubrics will be uploaded on scoring system.
Coursework 2023-24 MODULE CODE: COMP3016
P a g e 5 of 9
Coursework Part C2 – Individual Topic: The Interactive Software Prototype 70%
DESCRIPTION
This is an individual piece of work. "Create something which does something in OpenGL”.
The actual project is negotiated based on the submitted proposal but has two strict additional
requirements:
• Key requirement A for this part is to develop your interactive software in C++
incorporating OpenGL.
• Key requirement B for the assessment is to have a meaningful original contribution of at
least two features to your project.
You must create a working prototype using OpenGL4.X which allows for real-time user interaction.
For the coursework you are required to use an unmanaged language (C++) and are not allowed to
use existing game engines such as Unity3D, UE, Godot or Ogre.
Please see the end of this document regarding the hand-in date, as well as the section on the
demonstration, which is mandatory, not desirable.
As a first step, start by filling in a proposal form. The proposal is giving you formative feedback; it is
intended to concentrate the mind and required for getting your project approved. It is also helpful for
us to know what you intend to do before you get too far into the production process. (Not having
accepted your project will cap the marks.)
You are also tasked with creating another GitHub page illustrating, discussing and presenting your
product as a portfolio piece.
Topics:
Your project must use OpenGL4 (which means you cannot use the fixed function pipeline, so the
software requires at least a fragment and vertex shader) and an unmanaged language as the basis of
your work. You may use other higher-level tools for assistance – for instance you may use
“Photoshop” to produce the textures files, and 3D modelling tools such as “3D Max”, “Blender” to
produce meshes, and ChatGPT for sample templates of code (but be careful do not lift the code in its
entirety!). And you can also use such resources from any legal source you like, but you must mention
it on your GitHub project page.
This is a COMP module, not a 3D modelling module so basic models and textures are fine. You can
also use other classes or frameworks you like (so long as your framework is not of such a high level
that it turns OpenGL into something completely different). See the rules of engagement.
We have done no more than scratch the surface of OpenGL. Almost all the material we have covered
is related to 3D graphics, but there is nothing that says that your assignment must be in 3D space.
You can use this assignment to explore parts of OpenGL including 3D space, sound, networking,
media player etc. We do not expect anybody to produce a product which includes all these elements!
Following suggestions for your prototype topics are by no means exhaustive:
• Build a model loader and renderer that contains a dynamic, moving light source, a way to
move around the model based on user input, utilizes a simple shader and colour rendering.
• An artificial life simulation. Examples might be:
Coursework 2023-24 MODULE CODE: COMP3016
P a g e 6 of 9
o A “boids” simulation (see here). This is probably too easy on its own.
o A variation on the (Artificial Life simulation) herbivores/predators theme (the herbivores
eat grass, which grows when you make it rain, the predators eat the herbivores. Both
reproduce when they meet another of their own kind).
o A game. Mini Counterstrike (CS was written in C++)?
• Experiment with different user interfaces virtually or build and program your own. For example,
using one or multiple phones as input devices or an Arduino/RPi with some sensors.
• Use procedural content generation to either create levels and then play them or dynamically
generate terrain/forests/caves while the player is moving.
• You could also use PCG to generate objects the player can use to interact with, these objects
can also be sounds.
• You can also write and experiment with different shaders and analyse their performance over
different surfaces and when combined but this is not mandatory.
Software Engineering Issues
In addition, you should demonstrate that you have considered some of the more mainstream
computing issues discussed in this module. You are also to work using TDD for making sure the file
loading works as anticipated. Performance (speed) is often the goal in graphics, but that is not always
compatible with conventional good practice in software engineering, such as OO, modularity,
encapsulation etc. You should demonstrate that you have considered this, and you should tell me
what compromises you have made (if any) to reconcile issues of performance against good software
engineering practice.
We would also like you to consider some more advanced performance optimisations, such as the
culling of non-visible objects.
Or, alternatively, if you have sacrificed some performance for the sake of a purer and more
general computing solution, say what you have done and why. Put this in your brief report.
Rules of Engagement
You may use any algorithm from any sources (i.e. “gamedev”, Nvidia) or program code which you can
adapt. But you must tell us what you started with and what you have done to it. If this is not done you
risk failing the assignment.
You can also use a wider range of 3rd party libraries but they must be approved in the pitch.
However, you are not to use any given game engine such as Unity3D, UE, Godot or Ogre. You
could also use a physics library such as a Bullet or PhysX. Be very careful about using 3rd party
libraries and frameworks that abstract you so far away that they make it look as if you are
programming in something completely different. If in doubt, ask!
There must also be a substantial contribution from yourself so plugging code together to create
something is not enough. For example, just taking an existing example demo and changing the
meshes is not enough. You should also integrate a Poly, glTF file reader to load data into your
software. Think carefully about how you incorporate it, though. And finally, during demonstration we
might ask you questions about the program code you submitted.
Coursework 2023-24 MODULE CODE: COMP3016
P a g e 7 of 9
DELIVERABLES
▪ Create a GitHub repository from the classroom invite (use the provided link) for
your submission which is documented with a markdown file explaining:
▪ How does the user interact with your executable? How do you open and control
the software you wrote (exe file)?
▪ How does the program code work? How do the classes and functions fit together
and who does what?
▪ What makes your program special and how does it compare to similar things?
(Where did you get the idea from? What did you start with? How did you make
yours unique? Did you start with a given project?)
▪ Include a link to a video report that details the above but also goes into more detail
on:
• The video should be 10 minutes (resolution 1080p).
• Anything else which will help us understand how your prototype works.
• What inspired your prototype?
• What are similar software pieces?
• Are there any software engineering issues, such as the trade-off between
performance and good practice?
• A (brief) evaluation of what you think you have achieved, and what (if
anything) you would do differently, knowing what you now know. Feel free
to blow your trumpet!
▪ Create a single “.zip” archive (max 150MB) containing a pdf of the GitHub
readme/report, the executable and required libraries to run it. Detail how to run
the executable (put that in the write-up below). Don’t forget to include any other
resources required; meshes, sounds etc. Submit your archive via the DLE
electronic submission system. And don’t forget to remove any unneeded files and
folders. Compress any additional resources or assets to stay within the
wechat codinghelp