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
