Introduction

So far in the class, weve learned how to model, transform, and display shapes using a simple OpenGL-based toolkit. Game studios, movie studios, and others programming sophisticated interactive computer graphics applications regularly combine the graphics toolkits they use with other toolkits to support physics simulation, sound, and other effects. In this assignment, well do the same thing: youll learn how to combine OpenGL with a physics engine, and in the process, youll create a program that you should feel quite pleased showing off to friends and family!

Physics engines appear in graphics programs of all types, ranging from games such as Angry Birds to advanced modeling tools such as Maya. For simulating 3D physics, one of the most popular toolkits today is Bullet3D (http://bulletphysics.org/). In this assignment, were going to simplify the physics a bit by limiting ourselves to physics within a plane (i.e., 2D physics), so well work with the Box2D physics toolkit, which is probably the current best / most popular 2D physics engine.

In this assignment, you will learn:

• how to create an interface between a graphics toolkit and another helpful library such as a physics engine,
• how to link physics with graphics, including dynamically creating and destroying physics objects and having them be reflected on the display, and
• how to interactively manipulate physics objects by translating user interaction into physical forces and/or constraints.

Requirements

For this assignment, youll be hooking up the Box2D physics engine to the OpenGL-based starter code we provide for you. The aim of the assignment is to create a simple physicsbased game which will drop circles and boxes on the scene, which the player must guide towards the white goal while avoiding the red circle. To do so, the user can draw curves on the scene to create static obstacles, and can also switch to a mode where they can move the circles and boxes around directly. The controls for the game are as follows:

• B: add box
• C: add circle
• Tab: switch from draw mode (where dragging creates obstacle curves) to move mode (where dragging moves objects around) and vice versa Backspace: reset scene

In the starter code, we have already implemented enough of the user interface code to allow you to draw curves and add circles and boxes. The user input handling is encapsulated in the UIHelper class, which calls various methods like addCircle() etc. on the main program depending on user input. We have also added a new Draw class that lets you draw simple shapes such as circles, boxes, and curves (actually polylines) under an arbitrary geometric transformation represented as a mat4. What remains for you to do is to hook up the physics simulation to the program to make the added circles and boxes move.

The specific requirements and suggested approach are as follows.

Link your program with Box2D

For this assignment, youll be working with Box2D, so you need to change the way that you build your program to make it include the Box2D header files and link with the Box2D library file. This is similar to the examples weve done in class.

Set up the physics simulation

Your main task here is to figure out how communicate between Box2D and the shapes weve implemented already. For example, when a new circle is added to the scene, youll need to add a corresponding object to your physics simulation. Then, youll need to keep the physics and graphics in sync by advancing the physics simulation once each graphics frame, and changing the way each shape is drawn to use the current pose of the corresponding physics object.

One way to do this is to change the definitions of all the shapes so that they keep track of a Box2D body associated with them. Then, when you want to draw a shape, you can look up the state of the body and use that as the transformation passed to the draw call.

Interaction

Using the provided interface code, the user should be able to create any number of different obstacle curves and dynamic circles and boxes in the world. You may assume that the user will not draw self-intersecting curves. Pressing Backspace should reset the simulation to the same state it was in when the program started, i.e. it should delete all the user-added objects in the scene.

The last thing you need to implement is support for moving objects around interactively. When the user presses Tab, the program switches to move mode, and UIHelper will call the methods attachMouse(), moveMouse(), and detachMouse() when the user presses down, drags the mouse, and releases the mouse respectively. To make the chosen object move, we will create a b2MouseJoint which acts as a spring pulling the object to a target location (in our case, the mouse position). So you will have to do the following:

1. Find the object that contains the world-space point where the mouse is, if any. To do so, update the contains() method of the shapes to account for the pose of the Box2D object. You may want to use the b2Body::GetLocalPoint() method for this purpose.
2. Create a mouse joint to the object, and set its target to the mouse location. Look up the documentation for joints in the Box2D manual to learn how to create a joint, and see the comments in the starter code for the parameters to use.
3. When the mouse is moved, update the joints target using SetTarget() to the new mouse location.
4. When the mouse is released, destroy the joint.

Above and Beyond

All the assignments in the course will include great opportunities for students to go beyond the requirements of the assignment and do cool extra work. We dont offer any extra credit for this work if youre going beyond the assignment, then chances are you are already kicking butt in the class. However, we do offer a chance to show off While grading the assignments the TAs will identify the best 4 or 5 examples of people doing cool stuff with computer graphics. After each assignment, the selected students will get a chance to demonstrate their programs to the class!

Ideas for extra work include:

1. Detecting whether an object collides with the red circle or the white goal, deleting the colliding object, and showing a win/lose condition somehow.
2. Allowing the user to create dynamic circles and boxes at arbitrary positions and sizes by dragging the mouse like in a real drawing program.
3. Making more interesting levels, in the spirit of Crayon Physics or other physics-based games.
4. Improving the rendering to look (in some way) more impressive, such as drawing thicker lines and applying a crayon-like texture.

If your ideas for going beyond the requirements would make your code more difficult for the TAs to grade, please help them out by submitting a standard version of your assignment first through the normal website link, and then email the TAs the fancier version of your assignment.

Support Code

The webpage where you downloaded this assignment description also has a download link for support code to help you get started. The support code for this assignment is a simple program using the SDL-based engine, similar to the ones we have used before.

The support code defines a program structure and everything you need to read the mesh data. To make locating the shaders simpler, we have a header file called config.hpp that contains absolute paths to your shader files. You should edit this file with the full

path (e.g. C:UsersTuringa6code or /home/turing/a6/code) where

youve placed the shaders. We will modify this file appropriately when grading your assignment.

Handing It In

When you submit your assignment, you should include a README file. This file should contain, at a minimum, your name and descriptions of design decisions you made while working on this project. If you attempted any above and beyond work, you should note that in this file and explain what you attempted.

When you have all your materials together, zip up the source files and the README, and upload the zip file to the assignment hand-in link on our Moodle site. Any late work should be handed in the same way, and points will be docked as described in our syllabus.