COMP612 Computer Graphics Programming

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 isworth 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 (Win32) 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. Timewill 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 classyou will be exposed to new concepts, and as we work through these concepts you will be able toprogress 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 ZIPfile containing the following:

• Your Visual Studio 2022 solution, including all files necessary to build and run the animationand 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 includesresearch, 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 inthe C file header comments and detailed fully in your developer’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 plagiarismprevention software.

Marking:You can find the marking rubric for this assignment on Canvas. Marking not only considers thisassignment 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 asdocumented 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 ~90%+ of your GPU).You must work from this template and add your code in the appropriate sections as per theemplate 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 foryou. This is supplied becausewhen you start代 寫COMP612 Computer Graphics Programming 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 theobjects 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 specifiedin this document in Point 5.On Canvas there is an executable file of my basic helicopter that you can download and run to seehow your animation should behave. You may wish to extend and improve on this.

2. Basic Scene SettingsYou 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 toOpenGL units. e.g.: if moving 1.0 units in the application what does this map to in the “real” world? 1metre, 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. Thisscale 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 ofthe grid and the squares that make up the grid should be easy to change. The template includes akey 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 whenrenderFillEnabled is 1. From the Office of Jacqueline Whalley, Professor

4. Basic Helicopter – a Hierarchical Model

Use the built-in GLUT and GLU geometric shapes, and shapes specified by a vertex array, as well ashierarchical modelling techniques to build a helicopter. That is, instead of just using an absolutetransformation from the world origin for each individual part, you should use a relativetransformation between an object and its parent in the hierarchy. For example, the tail should beplaced relative to the helicopter body coordinate system and the tail rotor should be placed relativeto 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 mightseem like extra work at first! If you plan this carefully before you start coding you should have notrouble.

Only use the OpenGL matrix transformations. Do not try to manipulate the model-view matrixyourself. 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 leasttwo rotors. You might want to look at various helicopter designs and choose one (e.g.: The SA330Puma 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<jwhalley@aut.ac.nz> | <+64 9 9219999 ext. 5203>

Page 5 of 7

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 thatthe camera is following the helicopter. Your Helicopter functionsshould be set up so that it can

easily be translated (moved) by using its variables (speed, heading, location etc.) and GL matrixtransforms. 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 templateKey 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, theyour helicopter must simultaneously move up, forward, and left). Thetemplate provides all of thekeyboard 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 e 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 beadded to make the exploration of your environment interesting. At least one animated object (e.g. arotating windmill) or effect (e.g. a particle system for snow or rain) should be included. If you areunsure 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 formatand reading in simple OBJ files is available on Canvas. Note: you don’t have to use an OBJ model. Youcan 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 ison you to prove you are the creator of your project; thorough record keeping is essential to thisprocess. Your logbook should record dates, time spent, a record of bugs and fixes, and design details.Design ideation should be clearlydocumented with illustrations and notes. One recommendedindustry-based approach is to use story boarding as a means of planning and documenting yourscene and animation ideas. These can be hand illustrated – note yourdrawing ability is not being

assessed so focus on sketches that clearly convey the animation and idea rather than producing awork 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 theshortcomings 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, considerselecting or creating a smaller texture that is faster to load.