From the Office of Jacqueline Whalley, Professor 
COMP612 Computer Graphics Programming 
Semester 2, 2024 
Project: Helicopter Scene 
 
This is an individual assignment. All work you submit must be entirely your own. The assignment is 
worth 70% and will be marked out of 100. 
• You must work from the provided animationcontroller-lights.c template. 
• You must complete the assignment in procedural C and freeGLUT (NOT C++). 
• You must not use any external libraries other than freeGLUT. 
• You must use Visual Studio 2022 and build/release an x86 (Win**) project. 
• Your final submitted code must compile, have graphical output, and run. 
• All the above criteria must be met for the assignment to be graded. 
It is expected that you will work consistently on this assignment, from hand out to due date. Time 
will be allocated in class each week for you to ask questions, get help, and work on your assignment. 
Please be aware that this is not an assignment that can be completed at the last minute. Each class 
you will be exposed to new concepts, and as we work through these concepts you will be able to 
progress your assignment. 
Assignment Due Date: Friday 25 October, 10:00am (Week 13) 
Submission: 
You must submit your final project via the link provided on Canvas. Your submission must be a ZIP 
file containing the following: 
• Your Visual Studio 2022 solution, including all files necessary to build and run the animation 
and a working release executable. 
• Your logbook entries, either as 
o Scanned pages (as a single PDF file) from your handwritten logbook, or 
o Your digital logbook saved as a PDF file. 
Generative AI Policy: 
You must not use generative AI (e.g. ChatGPT) for any part of this assignment. This includes 
research, code, ideas, text, design notes and creative assets such as images and icons. 
Where your implementation idea or inspiration has been taken or adapted from other published 
sources (e.g. a tutorial on drawing teardrops) those sources must be acknowledged appropriately in 
the C file header comments and detailed fully in your developer’s logbook. 
Late Policy: 
Late assignments, without an approved extension, will be subject to a deduction of 5% (one grade e.g. 
from C+ to C) of the total mark available for each 24-hour period, or part thereof, up to a maximum 
of five calendar days. Assignments over five days late will not normally be accepted or marked and 
students will receive a DNC (Did Not Complete) for that assessment.  
From the Office of Jacqueline Whalley, Professor 
<jwhalley@aut.ac.nz> | <+64 9 9219999 ext. 5203> Page 2 of 7 
Unauthorised Collaboration: 
Unauthorised collaboration means joint effort between students or students and others, in 
preparing material submitted for assessment, except where this has been pre-approved by the 
paper programme. Students are encouraged to discuss matters covered in classes, but the 
expression of ideas and arguments must be the student’s own work. 
Plagiarism: 
Please be aware that any piece of your assessment may be tested with plagiarism 
prevention software. 
Marking: 
You can find the marking rubric for this assignment on Canvas. Marking not only considers this 
assignment specification, but also: 
• the quality of the design of your code 
• creativity, difficulty, and quality of your additional scene objects 
• the quality of the animation and user control of the helicopter 
• appropriate use of the template with code placed in the correct sections and functions as 
documented in the template code and described in Modules 5 and 14. 
Assignment Objectives: 
Conceptualise, specify, and develop a significant OpenGL interactive animation in 3D, and: 
 Appropriately scale an environment. 
 Create a track-and-follow camera. 
 Create and animate a hierarchical model. 
 Effectively use lighting, materials, texturing, display lists, and fog. 
 Implement smooth user interaction using keyboard controls. 
  
From the Office of Jacqueline Whalley, Professor 
<jwhalley@aut.ac.nz> | <+64 9 9219999 ext. 5203> Page 3 of 7 
Project Requirements 
1. Getting Started 
Download the animation template from Canvas (animationcontroller-lights.c). This 
provides the lighting needed for 3D rendering and the FPS timing and key handling that is needed: 
• for smooth animation 
• to avoid overworking your CPUs and GPUs (this is especially important if your machine is a 
gaming laptop – without it you will use one full core of the CPU and ~**%+ of your GPU). 
You must work from this template and add your code in the appropriate sections as per the 
template comments. Submissions not in the template will receive a D grade (see grading rubric). 
The template contains a function that sets-up basic OpenGL lighting for you. This is supplied because 
when you start your project, we will not have covered lighting yet and lighting makes everything 
look nice in 3D. Because we have lighting, we must use the GL_COLOR_MATERIAL mode for the 
objects to be rendered using our usual RGB(A) colours. By default, GL_COLOR_MATERIAL is disabled. 
You must in your final submission have changed the default lighting setup to your own as specified 
in this document in Point 5. 
On Canvas there is an executable file of my basic helicopter that you can download and run to see 
how your animation should behave. You may wish to extend and improve on this. 
2. Basic Scene Settings 
You should ensure that: 
 you are using depth buffering and double buffering for your project. 
 you are using a perspective projection and handling window reshape properly. 
You must identify the scale of your objects and environment and mapping of real-world units to 
OpenGL units. e.g.: if moving 1.0 units in the application what does this map to in the “real” world? 1 
metre, 1 cm? Thinking about this now will make the positioning and animation of your objects 
(including the camera) in the environment, and the projection parameters, easier to implement. This 
scale must be detailed and rationalised at the start of your logbook (e.g. “1.0 GL units = 1 metre”) 
based on your chosen scene. 
3. Basic Ground/Terrain 
Construct a function that creates a grid of squares on the X-Z plane centred at the origin. The size of 
the grid and the squares that make up the grid should be easy to change. The template includes a 
key handler that toggles global variable renderFillEnabled whenever the ‘l’ key is pressed, to 
allow the user to toggle between the scene been drawn wire-framed or filled. To make this work, 
you must draw your scene wire-framed when renderFillEnabled is 0 and filled when 
renderFillEnabled is 1.  
From the Office of Jacqueline Whalley, Professor 
<jwhalley@aut.ac.nz> | <+64 9 9219999 ext. 5203> Page 4 of 7 
 
Set the clear colour to be a suitable colour for your sky. 
4. Basic Helicopter – a Hierarchical Model 
Use the built-in GLUT and GLU geometric shapes, and shapes specified by a vertex array, as well as 
hierarchical modelling techniques to build a helicopter. That is, instead of just using an absolute 
transformation from the world origin for each individual part, you should use a relative 
transformation between an object and its parent in the hierarchy. For example, the tail should be 
placed relative to the helicopter body coordinate system and the tail rotor should be placed relative 
to the tail as should the sphere which caps the tail. 
This hierarchical structure is critical in the long run for both modelling and animation, even if it might 
seem like extra work at first! If you plan this carefully before you start coding you should have no 
trouble. 
 
Only use the OpenGL matrix transformations. Do not try to manipulate the model-view matrix 
yourself. In the past students who have ignored this recommendation have not been able to 
correctly view their model. 
You do not have to make your helicopter look exactly like mine – just make sure you have at least 
two rotors. You might want to look at various helicopter designs and choose one (e.g.: The SA330 
Puma or an AutoGyro MT-03). 
 
Ground (Grid on XZ plane) 
Hint: If you are using a perspective projection and have trouble positioning the parts of 
your helicopter switch to an orthographic camera and implement key handlers that 
allow you to view your chopper from all 6 sides by rotating using glRotated. 
 
Hint: Draw your helicopter facing up the Z axis (i.e. so in the default orthographic 
projection, the cockpit faces out of the screen toward you). This will make it much 
simpler to use the keyboard controls built into the template.  
From the Office of Jacqueline Whalley, Professor 
5. Animating Your Helicopter Rotors 
Now get your two rotors rotating at a reasonable RPM. Note the details of improved rotors in 6 
below. 
 
6. Helicopter Control & Tracking Camera 
Make your helicopter fly: 
• Surge  move forwards and backwards 
• Sway  move from side to side (left and right—in game terms, “strafe”) 
• Heave  move directly up and down 
• Yaw  adjust its heading (turn left and right) 
Whenever your helicopter moves your camera should move too (relative to the helicopter) so that 
the camera is following the helicopter. Your Helicopter functions should be set up so that it can 
easily be translated (moved) by using its variables (speed, heading, location etc.) and GL matrix 
transforms. Unlike my demo, your helicopter should: 
• not be able to move down below the ground. 
• not leave the ground until the rotors are turning fast enough. 
• slow the rotors on landing until they stop, or the user opts to take off again. 
• start in the first instance with its rotors switched off. 
Your control system must use the keys already defined in the template: 
Key mapping: 
-------------------------------------------- 
UP/DOWN ARROWS: Increase (move up) or decrease (move down) altitude (heave). 
LEFT/RIGHT ARROWS: Turn left/right (yaw). 
w/s: Move forward/backward (surge). 
a/d: Strafe left/right (sway). 
 
All of the movement controls must work simultaneously (e.g. if you hold down UP, W, and A, then 
your helicopter must simultaneously move up, forward, and left). The template provides all of the 
keyboard handling code required to do this, but you must work out how to move your helicopter in 
the think() function. 
 
Hint: Don’t forget to translate your rotor to the origin, then rotate, then translate back 
(if necessary) or draw your rotor at the origin to rotate about a fixed (pivot) point and 
then translate. If your rotors wobble when rotating, then they are not at the origin. 
Hint: Use gluLookAt to focus on the helicopter and set the camera’s eye position relative 
to the helicopter’s current location. For the camera to track the helicopter you need to 
manage two things: the camera eye position must follow the helicopter in space, and 
the camera must face toward the helicopter. As your helicopter rotates, the camera 
should rotate with it – so if your camera looks along the tail toward the front, it should 
stay looking along the tail as your helicopter turns left or right. 
  
From the Office of Jacqueline Whalley, Professor 
<jwhalley@aut.ac.nz> | <+64 9 9219999 ext. 5203> Page 6 of 7 
7. Lighting 
Now it’s time to replace the simple lighting setup provided in the template with one that is 
appropriate for your scene. You must make full use of the OpenGL fixed pipeline lighting functions 
and include at least two different lights including: 
 An animated spotlight (e.g., this could be attached to your helicopter or a lighthouse’s 
rotating light) 
 One directional light source with appropriate position, ambient, specular, and diffuse levels 
All the objects in your scene, including your ground, must be affected by lighting. 
 
8. Texture Mapping 
You must use texture mapping to texture map at least two objects (one could be your floor/terrain). 
For example, you might texture map: your sky, a hedge, a mat/rug, or a pond. 
 You must use at least two different textures in your project. 
 You can use any image textures you like (subject to copyright). 
 You may not use an additional library to load the textures. You should use texture maps in 
Portable Pixelmap (PPM) format. Textures in other formats can be converted to PPM using 
IrfanView (a free image tool available at https://www.irfanview.com/ ). 
 Turn texture mapping on only for texture mapped objects. If the objects are not texture 
mapped, they should be drawn as shaded objects (using Materials as per point 9). 
 Use texture mipmapping. 
9. Materials 
Where you are not employing texture mapping you should use Materials (not glColor). Set the 
appropriate shininess, ambient, specular, and diffuse material properties for each object. 
 
Hint: Ensure that you have normal vectors set by-vertex for all your objects. And for 
your ground each vertex should have a normal attribute set so that lighting works. This 
is easy if your ground is flat as the normal vector to the ground plane in the XZ plane is 
simply (0,1,0) assuming that your camera has been set up correctly so that Y is up. 
 
Hint: For materials to work don’t forget to disable GL_COLOR_MATERIAL by removing 
the call to enable it in the template code. Remember with GL_COLOR_MATERIAL 
enabled a call to glColor3f (1.0f, 0.0f, 0.0f); is the same as the following code 
with GL_COLOR_MATERIAL disabled: 
GLfloat red [3] = {1.0f, 0.0f, 0.0f}; 
//change ambient and diffuse components to red 
glMaterialfv (GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red); 
  
From the Office of Jacqueline Whalley, Professor 
<jwhalley@aut.ac.nz> | <+64 9 9219999 ext. 5203> Page 7 of 7 
10. Fog 
Use fog in some effective way within your environment. Think carefully about your fog colour. Fog is 
typically used to do fading out/blend the scene into the distance and to hide edges. You might want 
to alter fog colour and density based on the camera position to get the best effect for your scene. 
11. A Complete Scene 
Complete your environment by adding appropriate objects to the scene. For example: a forest, 
buildings, lakes, etc. The objects you add will be dependent on your choice of scene and should be 
consistent with the aesthetic of your scene. Enough objects and different types of objects should be 
added to make the exploration of your environment interesting. At least one animated object (e.g. a 
rotating windmill) or effect (e.g. a particle system for snow or rain) should be included. If you are 
unsure please discuss with the course instructors in class before proceeding. 
 
You may wish to use low polygon OBJ mesh-models for some objects in your scene. This will not be 
covered in the course and is not required, but a self-directed learning module on the OBJ file format 
and reading in simple OBJ files is available on Canvas. Note: you don’t have to use an OBJ model. You 
can use the built-in 3D shapes and hierarchical modelling to build objects for your scene. 
12. Logbook 
You must hand in your logbook as it forms part of your proof of authorship. Remember, the onus is 
on you to prove you are the creator of your project; thorough record keeping is essential to this 
process. Your logbook should record dates, time spent, a record of bugs and fixes, and design details. 
Design ideation should be clearly documented with illustrations and notes. One recommended 
industry-based approach is to use story boarding as a means of planning and documenting your 
scene and animation ideas. These can be hand illustrated – note your drawing ability is not being 
assessed so focus on sketches that clearly convey the animation and idea rather than producing a 
work of art. 
You must provide a short statement in the last log entry that critically evaluates what you did well, 
what you found most challenging, what you might do differently next time and identifies the 
shortcomings of your application. 
Hint: If your animation is slow you should consider: 
Are you using multiple instances of the same object, like a tree? If yes, then you should 
consider placing the object into a pre-compiled display list to optimise your animation. 
Are you loading the same texture, or other assets, each render loop? Textures should only be 
loaded once at the start of your animation in the init() callback function. 
Are your texture files too big and slowing down the project loading time? If yes, consider 
selecting or creating a smaller texture that is faster to load. 
 
請加QQ：99515681  郵箱：99515681@qq.com   WX：codinghelp