Assignment 1 Quadcopter

Topics covered:

? Drawing 2D meshes

? 2D transformations: rotation, translation, scale

? Scene graph

? 2D camera: view and projection matrices, aspect

Task Description

Your task is to implement a simple scene with a landscape of houses and a quadcopter

drone that flies overhead (following the mouse). The drone includes a spy camera that can

be activated to get a close-up view of the map below.

Figure 1: World camera

Figure 2: Drone spy camera

Framework

For this assignment, you will need the Eclipse project containing the JOGL and JOML

libraries that we have been using in the workshop. See the week 1 workshop for instructions

to download and install this project.

A basic framework for the assignment has been provided in GitHub Classroom:

https://classroom.github.com/a/0sOe5CgT

Clone this framework into your own Github account.

It contains the files:

? Ass1.java – the main class implementing a JFrame and a GLEventListener

? House.java – a class that draws a house

? InputManager.java – a class that provides a simple interface for keyboard and mouse input

? Transform.java – a class that provides methods to create 2D translation, rotation and scale

matrices.

? vertex.glsl / fragment.glsl – a very simple shader

To complete the assignment, you will need to edit these files and add further classes of your

own (although you probably shouldn’t need to change the InputManager and Transform

classes).

Components

You are required to complete each of the components below. Each component contributes

a percentage towards your Completeness mark, as described below.

Houses (10%)

The basic house provided should be modified so that the roof is a different colour to the

main building, as shown in the screenshots above. Choose whatever colours you like.

Landscape (10%)

The world should be 20x20 square field with 20 houses randomly positioned in it. The

background should be a suitable shade of colour.

World camera (20%)

The basic world camera should show the entire 20x20 world, regardless of the size of the

window. The world should look square and not be stretched. If the window is not square,

the shortest axis should fit the size of the world, and the world should be centred in the

window, as shown below.

Figure 3: World camera. Window is wider than it is tall.

Figure 4: World camera. Window is wider than it is tall.

Drone (20%)

The drone has a body and four rotors (in a different colour). The rotors are animated to spin

at a constant speed. Neighbouring rotors spin in opposite directions, as shown below.

Figure 5: The quadcopter drone. Arrows show the direction of spin.

Mouse control (20%)

The drone is controlled using the mouse:

? It rotates (at a constant speed) so that the front of the drone faces the mouse pointer.

? It moves forward (at a constant speed) until it is within some threshold of the mouse

pointer, then stops.

Hint: InputManager.getMousePosition() returns the mouse position in NDC coordinates.

You need to convert this to a different coordinate frame.

Spy camera (20%)

If the mouse button is held down, the view switches to the spy camera. This camera is

centred at the drone’s position and shows a 2x2 area of the world underneath the drone

(the drone itself should not be shown). If the window is not square, the image should be

centred in the window, and the area outside the 2x2 field of view should be black:

Figure 6: The spy camera. The area outside the 2x2 field of view should be black.

Submission

Files will be submitted using Github Classroom. Your most recent commit to the repository

before the assignment deadline will be marked. No late submissions will be accepted,

except in the case of special consideration (which requires a formal application). Last minute

problems with Git are not an excuse for late submission. Remember to commit and push

your work regularly as you go.

Marks

Your marks will be calculated using three components:

? Completeness: The total value of the components (listed above) that have been attempted.

? Correctness: Whether your code is correctly implemented (according to the rubric below)

? Clarity: Whether your code is easy to understand (according to the rubric below)

The final mark will be calculated as:

Final mark = Completeness * (60 * Completeness + 40 * Correctness)

So, for example if you attempt 80% of the features above, with perfect correctness (100%)

and slightly sloppy code (70%), your mark would be:

Final mark = 80%* (60 * 100% + 40 * 70%) = 70.4

Rubric

Grade Correctness Clarity

A+

(100%)

Excellent work. Code is free from any

apparent errors. Problems are solved in

a suitable fashion.

Good consistent style. Well structured &

commented code. Appropriate division into

classes and methods, to make

implementation clear.

B

(80%)

Very good work. Code has minor errors

which do not significantly affect

performance.

Code is readable with no significant codesmell.

Code architecture is adequate but

could be improved.

C

(70%)

Good work. Code has one or two minor

errors that affect performance.

Problems may be solved in ways that

are convoluted or otherwise show lack

of understanding.

Code is readable but has some code-smell

that needs to be addressed. Code

architecture is adequate but could be

improved.

D

(60%)

Poor. Code is functional but contains

major flaws

Significant issues with code quality.

Inconsistent application of style. Poor

readability with code-smell issues. Code

architecture could be improved.

F

(40%)

Code compiles and run, but major

elements are not functional.

Significant issues with code quality.

Inconsistent application of style. Poor

readability with code

-smell issues. Messy

code architecture with significant

encapsulation violations.

0

% Code does not compile

.

Major issues with code quality. Major

readability problems and code smell

throughout. Messy code architecture with

significant encapsulation violations.