Announcements

1. Announcements • Hope you all had a good break! • It’s over now • The final project marathon begins! • Today we’re covering a variety of topics which may be useful • If there are any topics you’d like us to cover in the next few weeks, let us know!

2. Overview • Today: a variety of final project topics • Level editors • Particles • Portals • Last three lectures each cover a major final project topic • Networking • Game object systems • Advanced rendering • If we receive suggestions for additional topics we will try to cover them as extra topics within or as replacements for these lectures

3. Lecture 9 Particles Zoom is best snap to grid! Portals C++ Tip of the Week Level Editors

4. Level editor • Avoid reinventing what already exists • Rely on existing 3D modeling and rendering packages (3DS, Maya, UnrealEd, Blender), especially if you know how to use one already • Only provide "glue" to put pieces together • Or even do the gluing in the existing 3D editor • Users will import content and use editor to tweak and annotate for game use • Pick common file formats for exporting • May need to use other tools to transform data • XML, JSON, OBJ, ... • Be nice to users • Undo/redo is much easier if you design for it first • Use a framework designed for UI (e.g. Qt)

5. Level formats • Don't have to use XML! • Google Protocol Buffers • Fast binary format • Compile a schema to C++ serialization code • Automatically backwards compatible when changed • JSON • Text-based format • JsonCpp: A very nice C++ API: Json::Valuejson; Json::Reader().parse(file, json); float x = json["player"]["x"].asFloat();

6. Level editor: Command pattern • Command objects encapsulate modifications to a document (similar to a transaction) • Used by Qt (QCommand, QUndoStack) structInsertCommand : Command { Document &doc; char c; inti; void redo() { doc.text.insertAt(i, c); } void undo() { doc.text.removeAt(i); } };

7. Level editor: Command pattern • Operations on document use commands structDocument { std::stack<Command> stack; std::stringtext; void insert(inti, char c) { stack.push(newInsertCommand(i, c, this)); stack.top().redo(); } void undo() { stack.top().undo(); stack.pop(); } };

8. Level editor: Concurrent editing • Consider a document and two simultaneous operations by different users User A User B insert(0, x) delete(2) Document abc

9. Level editor: Concurrent editing • Order of execution gives different results • Operational transformation • Transform each operation by previous operations to achieve same effect regardless of execution order • Works well with command pattern Document Document Document Document Document Document User B User A User A User B xabc xac abc ab xab abc delete(3) delete(2) insert(0, x) delete(2) insert(0, x)

10. Lecture 9 Particles Also covered in 123! Portals C++ Tip of the Week Level Editors

11. Particles • Simulation of volumetric effects • Often undergo forces / damping / collisions • Parametric equations or force integration • Each particle has randomized properties • Particles achieve a global effect together

12. Type 1: Billboarded particles • Oriented to always face the camera • Can read camera parameters directly from OpenGL • Good for: smoke, fog, glow, ... float m[16]; glGetFloatv(GL_MODELVIEW_MATRIX, m); Vector3 dx = Vector3(m[0], m[4], m[8]); // left-right Vector3dy = Vector3(m[1], m[5], m[9]); // up-down Vector3dz = Vector3(m[2], m[6], m[10]); // front-back glBegin(GL_QUADS); glVertex3f(-dx.x, -dx.y, -dx.z); glVertex3f(-dy.x, -dy.y, -dy.z); glVertex3f(dx.x,dx.y, dx.z); glVertex3f(dy.x, dy.y, dy.z); glEnd();

13. Type 2: Axis-oriented particles • Rotates around an axis to face the camera • Use cross product to orient particle • Good for: lasers, sparks, trails, ... Vector3 a, b; // the end points of the axis Vector3 eye; // the eye of the camera Vector3 d = (b - a).cross(eye - a).unit(); glBegin(GL_QUADS); glVertex3fv((a - d).xyz); glVertex3fv((a + d).xyz); glVertex3fv((b + d).xyz); glVertex3fv((b - d).xyz); glEnd();

14. Type 3: Soft particles • Higher quality billboarded particles • Removes sharp line where particle intersects geometry • Implemented in a shader • Reads from the depth buffer (needs separate pass)

15. Type 3: Soft particles • Linearly interpolate alpha from front to back • alpha = (depth - front) / (back - front) Particle geometry Volume of effect Scene geometry Back depth Front depth Depth buffer value

16. Type 3: Soft particles • Linearly interpolate alpha from front to back float depth; // value from depth buffer float front, back; // front and back particle depths float alpha = clamp((min(back, depth) - max(0.0, front)) / (back - front), 0.0, 1.0);

17. Rendering particles • Sorting necessary if using non-associative blend mode • Overdrawing impacts performance • Number of times a pixel is rendered to • Use fewer, richer particles • e.g. animate a texture on one particle • Render particles onto a half-screen-resolution buffer and draw upscaled on top of screen • Need to be careful about depth discontinuities • Use opaque particles (don’t disable depth buffer modification) • Pixels behind opaque particles will be skipped

18. Lecture 9 Particles Now you’re thinking! Portals C++ Tip of the Week Level Editors

19. Implementing portals

20. Implementing portals • Need two polygons marked as portals • Need matrix transform between them • MAB = MA-1 • MB • Player needs separate coordinate system • Player may flip sideways or upside down • May want to rotate player upright over time • When player center crosses portal boundary • Transform player center and velocity by MAB or MBA

21. Implementing portals • Problem: collisions • Player won't be able to enter portal on wall • Player will be touch wall and stop • Solution: portal uses "negative" collision volume, allows players to pass through it like a tunnel • Problem: duplication • Player halfway through portal in two places at once • Solution: temporarily add player to world twice, once at each location

22. Rendering portals • Need to render room on other side of portal • Restrict drawing to inside portal using stencil buffer • Clear depth buffer • Draw the other side using stencil clipping • Recursively draw portals to fixed maximum depth • Be careful about near clipping plane • Player going through portal will intersect portal polygon • Solution: back the portal into the wall and fill the cracks (rendered to stencil) Fill the cracks Portal boundary Player

23. Lecture 9 Particles “Simple” APIs! Portals C++ Tip of the Week Level Editors

24. C++ tip of the week • Some of you will be using libraries for your final project • Some of them may have flawed APIs, especially C-based ones • Use of void* for user-data • Lack of const-correctness • Some of them may have incomplete APIs • No access to information which should be public

25. C++ tip of the week • Casting to/from void* is always a reinterpret_cast • Must cast back to the EXACT SAME pointer type, not superclass or subclass // bad library API voidregisterCallback(void (*callback)(void*), void *data); classAnimal { /*...*/ } classDog : publicAnimal{ /*...*/} registerCallback(myCallback, newDog()); voidmyCallback(void* data) { Animal *a = (Animal *) data; // Not an animal a->doSomething(); // Undefined Behavior™ }

26. C++ tip of the week • Many C-like APIs will not be const-correct • Have to circumvent with const_cast • Ideally, write const-correct wrappers to limit use of const_cast // bad library API floatgetMass(PhysicsObject *obj); // doesn’t modify obj, but isn’t const constPhysicsObjectworldGeom(/*args*/); void setup() { floatworldMass = getMass(&worldGeom); // compile error! // have to circumvent with const_cast floatworldMass = getMass(const_cast<PhysicsObject *>(&worldGeom)); }

27. C++ tip of the week • Some APIs will not expose functionality/information you need • You can use preprocessor hacks! • This is dangerous and extremely morally wrong #define private public #define protected public #define class struct #include <library.h> #undef private #undef protected #undef class

28. No playtesting or weeklies!Start implementing your final project instead!