Visual Sketches Bootcamp

Course contents

1. Cross-platform setup and the first frame Verify the pinned openFrameworks and Project Generator versions before changing code; Explain the roles of main.cpp, ofApp.h, and ofApp.cpp; Map normalized screen positions to pixel coordinates; Build a first frame from color and primitive drawing calls; Use the first useful compiler diagnostic to repair one syntax error
2. A mark that moves Store position, rate, input, and pause state in variables with suitable numeric types; Explain how setup, update, draw, keyboard, and pointer callbacks divide responsibility; Convert a rate in pixels per second into fixed-step displacement; Compare variable-step motion with a fixed-step accumulator and clamp pause spikes; Build an accessible pointer-responsive traveler with wrap, fallback, pause, reset, and reduced motion
3. The Python-to-C++ survival kit Read a C++ function signature as parameter, return, value, and const-reference contracts; Build and return a deterministic std::vector of same-type mark values; Use indexed and range-based loops while explaining which form supplies the needed information; Describe scope, owned values, references, and why manual new/delete is deferred; Create an accessible learner-owned visual family by varying explicit parameters
4. Interlude — reading and writing the first C++ test Trace the no-window test executable from setup through process exit; Read one failure using arrange, act, and assert; Repair one focused assertion and author one independent deterministic known case; Compare floating-point results with explicit absolute and relative tolerances; Explain why renderer pixels and visual quality stay outside headless model tests
5. Map, clamp, and lerp Normalize a value, interpolate into a destination range, and clamp unsafe input; Preserve a target aspect ratio while recomputing layout after resize; Apply and explain one monotonic smoothstep easing curve; Separate responsive layout helpers from openFrameworks rendering; Test endpoints, midpoint, monotonicity, resize, bounds, and floating-point tolerance
6. Vectors, direction, and distance Read, initialize, and pass small vector and motion structs by value or const reference; Use glm::vec2 and point subtraction to obtain direction, magnitude, and distance; Normalize with an explicit zero-length guard and scale a unit direction; Apply velocity and acceleration in deterministic fixed-step seek, orbit, and bounce studies; Connect pointer and keyboard input to deterministic renderer-independent geometry; Test numerical oracles, boundaries, determinism, and learner parameters without pixels
7. Oscillation, circles, and phase Use a circle as a visual calculator for moving a point around a center; Explain sine, cosine, radians, amplitude, frequency, phase, and period in plain language; Convert between center/radius/angle and ordinary x/y coordinates with a documented zero policy; Build a repeated row/column field with deterministic phase offsets and fixed time; Test conversions, quarter-turns, periodicity, bounds, and learner choices without pixels
8. Controlled chance Use a random engine, explicit seed, uniform draws, and weighted tickets deliberately; Explain uniform, weighted, and center-biased distributions as visible shapes; Distinguish same-build seed replay from serialized cross-toolchain parameter replay; Build exactly six related editions from simple generated records; Test deterministic properties, malformed serialization, and stroke-aware bounds without pixels
9. Local coordinate systems Use lexical scope and a small RAII matrix guard to prevent transform leakage; Compose translation, rotation, and scale in positive-down screen coordinates; Explain local coordinates and parent-child transformed anchors; Predict why transform order is noncommutative; Test three deterministic frames, responsive bounds, and learner-owned design without pixels
10. Gesture as geometry Separate pointer and keyboard event capture from a deterministic gesture model; Grow, filter, prune, and clear a bounded std::vector safely; Apply time-aware exponential smoothing and guarded velocity and turning angle; Accumulate arc length and uniformly resample a polyline while preserving endpoints; Map speed to width and curvature to color without using pixels as a correctness gate
11. Particles with memory Construct a bounded vector of particle objects with inspectable invariants and update methods; Integrate velocity and position with fixed steps, acceleration, exponential drag, and boundary response; Track age, lifetime, and bounded oldest-to-newest history while removing many expired objects safely; Explain frame clamping, capped accumulator catch-up, dropped-time policy, pause, and deterministic spawning; Design an accessible history-trail emitter without making pixels the correctness gate
12. Forces, steering, and springs Accumulate small behavior forces, cap their sum, integrate once, and clear it for the next fixed step; Use a scoped behavior mode to switch a bounded system between seek and spring-chain composition; Calculate softened attraction or repulsion, arrival steering, Hooke-like restoring force, and axial damping safely; Explain dot product, force and speed limits, semi-implicit order, and fixed-step state transitions; Design an accessible two-mode chain or swarm whose correctness is inspectable without pixels
13. Noise and flow fields Store and safely index a bounded scalar field as one row-major two-dimensional grid; Generate coherent deterministic value noise from a course-pinned integer lattice mixer and smooth interpolation; Bilinearly sample grid corners and boundaries, then map one scalar to a finite unit direction; Advect bounded particles with fixed steps, wrapping, short histories, temporal change, and explicit dropped time; Design an accessible flow instrument whose deterministic evidence is separate from its pixels
14. Color, blending, and trails Represent straight RGBA colors and two endpoint palettes as checked data in the unit interval; Interpolate palette channels and calculate source-over alpha composition as weighted averages; Apply bounded exponential alpha decay to deterministic oldest-to-newest trail marks; Keep pure trail-plan output independent from renderer state and keep openFrameworks blend and style changes scoped; Design an accessible two-palette particle or gesture study whose geometry, decay, and overlap are learner-owned
15. Time as a drawable axis Implement and inspect a bounded ring buffer whose age zero is always the newest sample; Map normalized spatial position to a deterministic retained history age; Supply frame and time explicitly so model replay does not depend on a window clock; Check allocation arithmetic, byte budget, finite values, order, and counter overflow before mutation; Design an accessible spatial-temporal collage while keeping GPU appearance outside portable model evidence
16. Images and type as geometry Copy decoded image pixels into owned storage and compute checked row-major interleaved indices; Threshold a bounded sampling grid into points, then measure its bounds and centroid; Transform a point collection around its centroid while preserving count and predictable scaled distances; Report missing, malformed, empty, or overlarge assets explicitly before rendering; Create an accessible animated composition from an original phrase or redistributable image
17. Embodied audio input Route recorded amplitude, optional live microphone amplitude, and keyboard fallback through one deterministic input adapter; Smooth normalized amplitude, apply a dead zone, and predict the resulting inspectable geometry; Replay a synthetic amplitude fixture while bounding sample work and geometry counts; Build a consent-aware visual instrument whose louder-to-larger mapping reads within five seconds without sound or color; Distinguish automated core evidence from manual device and graphical evidence
18. Three cumulative sketch studies Complete three bounded studies that each combine two named technique families; Specify and test one deterministic model contract for each study; Compare divergent visual grammars without treating an exemplar as a target; Document each study with an accessible capture and an 80–120-word mechanism explanation
19. Original visual-instrument capstone Design one coherent visual instrument that combines at least three earlier concepts and deepens exactly one; Replay core behavior from recorded input while handling resize, reset, failures, and varying frame time; Evaluate technical behavior, creative coherence, originality, accessibility, and licensing with distinct evidence; Publish an accessible process record without copying a canonical finished capstone