Overview
This studio takes you through the full real-time art pipeline: build a 3D asset, wrap it in surface and light, rig and animate it, then make it move, respond, and ship as something a player can pick up and play. You bring the modeling foundation from your prerequisite; here you learn to make it interactive.
Read the full Fall 2026 syllabus → — the whole term in one page: grade breakdown, the fifteen-week grid, every project spec, the assessment rubric, and the course AI policy.
What's new this year
Unreal Engine 5.8
Epic's current release — Nanite virtualized geometry, Lumen dynamic global illumination, and Megalights are all production-ready in 5.8, and Blueprints give you visual scripting without leaving the editor. We use it for interactivity and playable builds.
Agents in the pipeline
For the first time, AI coding agents are part of the toolchain. Claude Code and OpenAI Codex wire Blueprints and write C++, build editor tooling, and — through the first-party Unreal MCP built into 5.8 plus Epic's UE skills plugin for Claude Code — can even act inside the editor. You direct; you verify; you keep the log.
Playable builds
Everything you make this semester is meant to be played. You'll package standalone builds (Windows, or a VR headset) and put your final piece on itch.io.
Course objectives
- Model game-ready 3D assets with clean topology, on a polycount budget, and unwrap them for texturing.
- Author PBR surface textures and build real-time materials in Unreal's Material Editor.
- Light real-time scenes using Lumen dynamic global illumination and Megalights, plus a Post Process Volume for exposure and grading.
- Rig and skin a character, then author animation clips — idle, locomotion, and action — for interactive playback.
- Drive animation with an Animation Blueprint and gameplay with Blueprints — plus a taste of C++ — and direct AI agents to help build it.
- Integrate assets into an Unreal project and package a standalone build.
- Use Claude Code and Codex responsibly: prompt, review, verify, and document AI-assisted work.
- Develop your own voice as a maker of interactive and playable work.
A week in studio
We meet twice a week for an hour and fifty minutes. Monday teaches; Wednesday practices and crits:
Demo + concepts. New territory introduced on the projector — a technique, a tool, a bit of the pipeline.
You build the same thing at your station, step by step.
Weeks 1–8: supervised practice on your own work, no new material. From Week 9 it becomes the agent lab — prompt, review, fix, log.
Screens up. Show progress, trade techniques, plan the week's homework.
Grade breakdown
| Component | Weight | Notes |
|---|---|---|
| Guided asset training | 25% | In-class practical exam (Week 7 · Oct 14) |
| Game-Ready Asset Kit | 10% | Weeks 3–6 |
| Rigged & Animated Character | 15% | Weeks 8–10 |
| Interactive Vertical Slice | 10% | Weeks 11–12 |
| Final Project | 40% | Weeks 12–16 · a playable build, exhibited in Week 16 |
Scale: 95–100 A · 89–94 A/B · 84–88 B · 77–83 B/C · 72–76 C · 66–71 C/D · 60–65 D · below 60 F. More than three unexcused absences: NF — excused absences are accommodated, see the syllabus. Every production project includes a process log; from Week 9, when the CLI opens, it also records the agent work as an AI development log.
Equipment & software
- No laptop required — every student has a lab PC in CCB-134 that runs Unreal Engine 5.8 and Blender. Your own laptop, or a gaming desktop at home between classes, works too (discrete GPU recommended).
- Free account: an Epic Games account (to install Unreal Engine 5.8).
- Blender (free); Maya is available in the lab and free with a student license if you prefer it for rigging.
- Claude Code and Codex CLI installed (setup in Week 9, when the CLI opens; see the AI Lab).
- Suggested: a three-button mouse, 1 TB external SSD, and a graphics tablet for texture painting.
- UT Adobe Creative Cloud is free for this class: creativecloud.adobe.com with your UT email.
University policies (Title IX, ADA, attendance, academic integrity, campus closure, disruption) are stated in full on the official syllabus in SpartanLearn / Canvas — that document governs.
Semester Map
Monday and Wednesday studio sessions (Aug 31 – Dec 9) plus a finals-week showcase, in four phases: build the asset, give it motion, make it interactive, then ship the playable final. Weeks 1–8 are hands-on only; the amber notes from Week 9 mark each week's agent lab. The green checkpoint under each week is the yardstick: the work you should have done by the end of that week to be on pace.
Phase 1 — Form by Hand · Weeks 1–6
Orientation: the real-time pipeline
- Course tour: how a 3D asset becomes a playable game, and where real-time art is in 2026.
- Install party: Epic Games Launcher + Unreal Engine 5.8, and Blender.
- Create your first Unreal project; make your first backup of it.
- Unreal Engine 5.8 and Blender installed and launching on the machine you'll use all term.
- A first Unreal project created — and you know where its folder lives on disk.
- A backup copy of that folder on storage you control. The end-of-session habit starts now.
Modeling I: topology & the polygon budget
- Game-ready vs. render-ready geometry: quads, clean edge flow, and why triangles are the real currency.
- Polycount budgets, modular kit thinking, and the grid you snap everything to.
- A game-ready object modeled in quads with clean, deliberate edge flow.
- You can state its triangle count and what the budget buys.
- You can look at a mesh and call it game-ready or render-ready — and say why.
Modeling II: building the modular kit
- UV unwrapping, texel density, and trim sheets — the economics of texture space.
- Import to Unreal; assemble a modular blockout and walk it at scale.
- First kit pieces modeled on the grid, with consistent origins and names.
- The export contract proven: one Blender meter lands as 100 Unreal units, transforms applied.
- A blockout assembled in Unreal and walked at player scale — Project 1 is underway.
UVs & unwrapping
- Mark seams you chose rather than seams that happened to you; unwrap without distortion.
- Measure texel density with a checker map — the ten-second diagnostic that settles arguments.
- Trim sheets versus unique unwraps, and knowing which you are making before you start.
- Kit pieces unwrapped with seams you chose — no visible stretching on a checker map.
- Texel density consistent across the whole kit.
- Every piece has a decision on record: trim sheet or unique unwrap.
Surface texturing: PBR materials
- The PBR mindset: albedo, metallic, roughness, normal — what each map really controls.
- Texture painting in Substance Painter / Blender; building Material Instances in Unreal's Material Editor.
- A full PBR set — base color, roughness, metallic, normal — on your hero pieces.
- A master material in Unreal with Material Instances driving the variants.
- Maps in the right color space: base color sRGB, everything else non-color.
Lighting in Unreal
- Lumen dynamic global illumination and reflections, Reflection Capture actors, and a Sky/SkyLight.
- Post Process Volume, exposure and tone mapping, and how mood is built from a handful of lights.
- Crit: Game-Ready Asset Kit.
- Your kit assembled in a Lumen-lit level with a Post Process Volume setting the mood.
- Project 1 submitted at crit: the kit, the budget sheet, and the process log.
Phase 2 — Character & Motion · Weeks 7–10
Guided asset training practical exam
- In-class, hands-on: unwrap, texture, light and import a supplied asset in Unreal, in 110 minutes.
- No AI agents during the exam: this is the skill floor the rest of the course stands on.
- After the break: the 12 principles of animation, seen through an interactive lens.
- The practical behind you: a supplied asset unwrapped, textured, lit and imported in 110 minutes, unaided.
- The 12 principles named — and spotted in a game you played this week.
Rigging: skeletons & skinning
- Joints, hierarchies, and the humanoid skeleton; Blender Rigify and Maya's rigging tools.
- Skinning and weight painting: making deformation believable.
- A character rigged: root bone at the origin, deform bones only, a clean hierarchy.
- Skin weights that survive extreme poses — shoulders and hips that deform instead of crumpling.
- The Skeletal Mesh imported into Unreal; Project 2 is underway.
Weeks 1–8 are hands-on only — you build in Blender and Unreal yourself, and Gary, the AI TA, answers questions but nothing else. From Week 9 the agent lab returns to the third block and runs to the end of term. You cannot judge whether an agent did good work until you can do the work.
Animation I: cycles & principles
- Keyframing a walk and run cycle; timing, spacing, weight, anticipation.
- Authoring loopable clips that read at gameplay speed and hold up from any angle.
- An idle and a walk or run cycle keyed, looping cleanly at gameplay speed.
- Claude Code or Codex CLI installed, and your first agent-lab session recorded in your AI development log.
Animation II: Animation Blueprints
- The Animation Blueprint: the AnimGraph, a State Machine, transitions, and Blend Spaces.
- Root motion, retargeting (Mixamo → the UE skeleton with the IK Retargeter), and driving state from variables in Event Blueprint Update Animation.
- Crit: Rigged & Animated Character.
- An Animation Blueprint with a working State Machine and Blend Space, driven by variables.
- Project 2 submitted at crit: the rig, three clips, and in-engine playback.
Phase 3 — Interactivity · Weeks 11–12
Blueprints I: input, and a character you can drive
- Actor Blueprints, the event graph, Event BeginPlay vs. Event Tick and its Delta Seconds; reading input with Enhanced Input and moving a Character.
- Driving your animation from Blueprints — input becomes motion.
- A character you can drive: Enhanced Input in, motion and animation states out.
- The agent-built controller traced node by node — and one behavior changed by hand.
Blueprints II: game feel, score, win state
- Event Dispatchers and Blueprint Interfaces, a simple UMG widget, and a minimal game loop (goal, feedback, state).
- Game feel: juice, timing, and the difference between "it works" and "it feels good."
- A minimal loop that plays: goal, feedback, win state, and a UMG widget keeping score.
- Project 3's vertical slice packaged, with three authored interactions.
- Your final project pitch written, presented, and approved.
Phase 4 — The Final · Weeks 13–16
Production sprint I
- Studio time on finals with instructor desk-crits; Sequencer and a Cine Camera Actor for trailers and documentation.
- A sprint goal set at 2 pm and demoed at 3:10 — plus a written list of what you cut.
- First trailer shots framed in Sequencer with a Cine Camera Actor.
Production sprint II & playtesting
- Structured playtests with classmates; triage what feedback to act on before ship.
- Building, packaging, and publishing to itch.io; the standalone build checklist.
- Two structured playtests run and triaged — every note acted on or rejected on purpose.
- The final packaged and running on a machine that isn't yours; the itch.io page drafted.
Ship it: lock, publish, rehearse
- The last teaching week. Lock the final build, publish it on itch.io, cut the 60–90 second trailer with Sequencer and the Movie Render Queue, finish the process book.
- Dress rehearsal: every station set up as it will be at the showcase, played by a classmate, with the controls sheet and the one-minute pitch timed.
- The final build locked and live on itch.io, with controls and screenshots on the page.
- The 60–90 second trailer cut with Sequencer and the Movie Render Queue; the process book finished.
- Your showcase station rehearsed: controls sheet printed, one-minute pitch timed.
Final crit & showcase
- Tuesday Dec 15, 1:30–3:30 pm — our final exam slot. Playable builds exhibited and played; invited guests take the controls.
- AI development log and process documentation submitted with the build.
- Your build exhibited and played by people who aren't you.
- The process book and the full-semester AI development log, with its one-page reflection, submitted.
- A playable build, a trailer, and a process record that together belong in your portfolio.
Projects
Four production projects, each building on the last, from a static asset to a playable game. Every project ships with a process log. From Week 9, when the CLI opens, that log also records the agent work — what you asked for, what it did, and what you had to fix or decided to reject.
01 · Game-Ready Asset Kit
10%Weeks 3–6A small modular set — a prop family or a piece of environment — modeled, unwrapped, textured, and lit in Unreal to a stated polycount and texel budget. The test: it looks intentional, reads at game distance, and stays on budget.
- 3–5 modular pieces with clean topology and non-overlapping UVs
- PBR materials with a considered wear/story pass
- A Lumen-lit Unreal level showing the kit assembled
- Budget sheet: polycount and texel density per piece
- AI development log (what the agent scripted or documented vs. what you authored)
02 · Rigged & Animated Character
15%Weeks 8–10A character — yours or a provided base mesh — rigged, skinned, and given a clip set that plays through an Animation Blueprint: an idle, a locomotion cycle, and one action. The test: the deformation holds up and the motion has weight and intent.
- Clean skeleton and skin weights that survive extreme poses
- Three authored clips: idle, walk/run, one action
- Animation Blueprint with a working State Machine and Blend Space, driven by variables
- A short turntable + in-engine playback clip
- AI development log
03 · Interactive Vertical Slice
10%Weeks 11–12A playable slice: the player controls your character, animation is driven by input, and at least three Blueprint interactions respond to the world. Stretch options, self-directed and unsupported: an OpenXR VR mode or a replicated multiplayer interaction. VR is taught properly in FMX 430.
- Packaged standalone build (Windows, or a VR headset)
- Input-driven character with animation states from Project 2
- At least three authored Blueprint interactions
- Playtest notes from at least two classmates
- AI development log
04 · Final Project
40%Weeks 12–16Your voice as a maker of interactive work: a complete playable game or interactive piece, pitched in Week 12, produced in the sprint weeks, exhibited and played in Week 16, and published as a build. Ambition is graded — so is finish.
- Written + visual pitch (approved Week 12)
- Published packaged Unreal build (itch.io standalone, or headset)
- A 60–90s trailer/documentation edit for your portfolio
- Process book: references, iterations, playtests
- Full-semester AI development log with a one-page reflection: where the agents made you faster, and where they made you worse
How production projects are assessed
| Criterion | Weight | What it looks like |
|---|---|---|
| Craft & technical execution | 30% | Clean models, UVs, materials, rigging, and code; it runs and stays on budget. |
| Concept & design | 25% | The work means something; composition, motion, and pacing are authored, not defaulted. |
| Interactivity / game feel | 20% | Interactions are discoverable and satisfying; the thing is fun to touch. |
| Process & AI development log | 15% | Honest record of prompts, agent output, your review and fixes. You can explain every asset and line in the build. |
| Crit participation | 10% | You show up, show work, and give your peers real feedback. |
AI Lab
The agents arrive in Week 9, not Week 1. Weeks 1–8 are hands-on only — you build in Blender and Unreal yourself, because you cannot judge whether an agent did good work until you can do the work. From Week 9: This course treats AI coding agents the way a studio treats any powerful tool: you are the director, the agent is a fast but overconfident assistant, and nothing ships that you can't explain. Here's the toolchain, the setup, and the rules. And this site has its own AI TA, Gary 🐌 — the amber button in the corner of every course page — tuned to each week's material for questions between studio sessions, all sixteen weeks of the term.
The toolchain
Claude Code
Anthropic's terminal-based coding agent. Reads your project, wires Blueprints and writes C++, builds Unreal editor tooling, and runs commands. It's the primary agent we lean on this semester.
OpenAI Codex CLI
OpenAI's counterpart agent. We use both deliberately — comparing how two different agents attack the same Unreal problem is itself a course exercise (Week 11).
Unreal MCP (built into 5.8)
Unreal Engine 5.8 ships a first-party MCP server: enable "Unreal MCP" in Edit > Plugins, restart, then start it from the console with ModelContextProtocol.StartServer. It exposes the editor to agents — spawning and editing Actors, running commands — so an agent can act in the editor, not just on files.
Epic's UE skills for Claude Code
Epic's unreal-engine-skills-for-claude-code plugin teaches Claude Code current Unreal workflows and APIs. We pair it with project context (a good CLAUDE.md) and make the agent look up the current API instead of trusting memory.
Setup (Week 9, step by step)
- Install the agents
Claude Code (
npm install -g @anthropic-ai/claude-code) and Codex CLI per current docs. Sign in with the accounts provided/discussed in class. - Create the Unreal project
New Unreal Engine 5.8 project in a folder you control, backed up to your own storage at the end of every session. The habit starts in Week 1, long before the agents arrive.
- Point the agent at the project
Run Claude Code from the project root and add a short
CLAUDE.mddescribing the project, so the agent has context. Ask it to summarize the project structure back to you. - Enable the Unreal MCP + Epic UE skills
In
Edit > Pluginsenable "Unreal MCP", restart, and start the server withModelContextProtocol.StartServer; add Epic'sunreal-engine-skills-for-claude-codeplugin so the agent can act in the editor and knows current UE workflows. - Smoke test
Ask the agent to spawn and describe a few Actors in your level. If it can reach the editor through the MCP and report what it did, you're wired up.
Prompt patterns that work in Unreal
- Look up before you build. Have the agent check the current Unreal class and docs before building — the UE API shifts between versions and models remember old signatures.
- Small, verifiable steps. "Add WASD movement to this Character" beats "make my game." Compile and test in Play In Editor (PIE) after every change.
- Spec first. Write the behavior as three plain-English sentences before prompting. If you can't spec it, the agent can't build it — it will just build something.
- Make it explain. After the agent wires a Blueprint or writes a script, have it walk you through it. Then read it yourself and confirm the explanation matches what's actually there.
- Distrust performance claims. Agents assert; the profilers measure. Use
stat unit,stat gpu, and Unreal Insights to settle arguments about what's slow.
Weeks 1–8 — hands only. No agents in the work: no Claude Code, no Codex, no generative tools producing geometry, textures, rigs or code you submit. Ask Gary, the AI TA, anything you like about how something works; do the work yourself.
Week 7 — nothing at all. No agents, no chat, no AI TA, no internet. The practical exam is unaided by design.
Weeks 9–16 — allowed and expected, and logged. Use Claude Code and Codex on production work, with every session recorded in your AI development log: prompt, what the agent did, what you kept, fixed or rejected.
Required all term: you must be able to explain every asset, material, animation state and line of code in your submitted build, live, at crit. "The AI did it" is a starting point, not an answer.
Never allowed: presenting agent output as hand-authored; using AI to fabricate playtest notes, references or reflection writing; agents on Week 1–8 submitted work or during the Week 7 exam.
Under the University's Undergraduate Academic Integrity Policy, instructors may identify conduct that prevents fair evaluation of your learning as a violation. In this course that includes agent use in Weeks 1–8, any AI use during the Week 7 exam, and undocumented AI use from Week 9 on.
A running document (Markdown in your project folder is ideal) with one entry per working session: date, goal, the prompts that mattered, what the agent produced, what you changed and why, and one thing you learned about directing it. Five honest minutes after each session. It is worth 15% of every project grade. Before Week 9 you keep the same habit as a process log, minus the agent: what you tried, what failed, what you decided.
Headroom
In audio, headroom is the margin between your loudest signal and the ceiling. Run out of it and the sound doesn't get louder — it clips. Your attention works exactly the same way. This is a note on cognitive load: what it is, how this course is built around it, why AI tools raise it rather than lower it, and how to protect your margin while carrying four courses at once.
Working memory is small, and it does not expand. That is the founding observation of cognitive load theory, and everything on this page follows from it. When a project asks you to hold creative judgement, software navigation, technical settings, file management and a deadline in your head at once, the first thing to fail is not your talent — it's your margin.
Professionals are not people who push harder against the ceiling. They are people who engineer their signal chain so they rarely hit it. That's a learnable skill, this course deliberately trains it, and it will matter to your career at least as much as anything you build here.
Three kinds of load
Cognitive load theory splits mental effort into three kinds. Learning to tell them apart in the middle of a work session is the whole trick.
The task itself
The necessary complexity of the work — editing a scene while holding continuity, pacing and intent; a shoulder that has to deform believably. You can't remove it. You can only shrink it with prior knowledge: whatever becomes automatic stops costing working memory. That is what practice is for.
The friction
Effort the work never asked for — hunting for the brief, decoding a vague spec, un-versioned files, redoing a lost export, guessing what the rubric wants. It teaches nothing and clips you anyway. Kill it with systems: naming conventions, one folder template, one home per project.
The learning
The productive effort that builds durable skill — comparing two versions, explaining why the cut works, applying the principle to the next piece. This is the load worth paying for, and it's exactly the load that friction crowds out first.
The goal is never an easy course. The goal is to spend your ceiling on the work that compounds.
This course is built around your headroom
Several things about this course that can read as ritual are load engineering, and you'll get more out of them knowing why they're there.
- Weeks 1–8 are hands-only because chunking is real. A skill you've practiced until it's automatic stops occupying working memory — which is what frees you, later, to think about the work instead of the tool. The Week 7 practical isn't a hazing ritual; it's a headroom reading. It measures what you can do without looking anything up.
- The recurring structures are friction removal. The same session rhythm every week, one submission convention, the same crit format: you learn each format once, and from then on your attention goes to the work. That's extraneous load being deleted on your behalf.
- Demos are segmented and models are narrated — short named steps, worked examples with the decisions explained — because research is unambiguous that learners absorb more, with less effort, when complexity arrives in pieces they can process.
- The process log is external memory. Paper is cheap; working memory isn't. A decision written down is a decision you can stop carrying. By Week 9 the same habit becomes your AI development log, and it's graded because it's the skill.
The AI part: load doesn't drop — it converts
It is tempting to expect the agents to arrive in Week 9 and lower the effort. They won't. They convert it. Before Week 9, the cost of your work is generation — slow, but you understand every asset because you made it. From Week 9 the cost moves to verification and orchestration: reviewing work you didn't do, holding your intent steady across ten fast iterations, deciding what to keep. Generation is bounded by your hands. Supervision is bounded by your judgement — and an agent can outrun it.
That's why this course calls the agent a fast but overconfident assistant. Every output you accept without verifying is borrowed load — it comes back with interest at crit, in the exam room, or in the build that won't package the night before the showcase.
And the career part, plainly: everyone you'll compete with will have the same agents you do. The day everyone can generate, production stops being the scarce skill. What stays scarce is a head that stays clear while directing ten times the output — scoping, verifying, explaining. In a tighter market that difference is the hire. Your AI development log isn't paperwork; it's the portfolio artifact that proves you can supervise the machine accountably.
Four courses, one ceiling
You're carrying this course alongside three others, plus a life. The ceiling doesn't care that the loads come from different syllabi — it's one working memory. Six moves that protect it:
Batch, don't shred
Context-switching is the most expensive thing you do all week. One deep block per course beats four shredded evenings, because every switch pays a re-loading tax and leaves half-finished thoughts resident in memory.
Write it down
A capture list is external memory: ideas, due dates, “fix this later.” If it's written, it can stop occupying you. The open loop you're trying to remember is the one eating your margin during the work.
Close loops
End every session with one line of state: “next — reweight the shoulder.” Future-you boots in seconds instead of twenty minutes. Same rule as the agent log: write the state down before you move on.
One home per course
Every course gets one predictable place for briefs, files and deadlines. Five minutes spent hunting is pure extraneous load; spend the five minutes once, on the folder template.
Scope is load management
Ambition is graded alongside finish here for a reason. Cutting scope early isn't defeat — it's the production judgement studios actually pay for, and it's how a final ships polished instead of ambitious and broken.
Audit weekly
Ten minutes, all four courses plus life, everything on one page. Tag each item: generate, verify, or coordinate. You cannot route a load you've never seen written down — and most people have never once seen theirs.
Four questions, thirty seconds, any course: Does it read without me explaining it? Can I explain every part of it at crit? Is it in the required format, named the required way? Did I write down the one thing I learned? If all four are yes, submit and close the loop.
Where this comes from
Cognitive load theory begins with John Sweller's work in the 1980s and is one of the most replicated bodies of research in instructional design. If you want the sources behind this page:
- Sweller — Cognitive load theory, educational research, and instructional design (Instructional Science)
- van Gog et al. — advances on worked examples, animations, and load measurement (Educational Psychology Review)
- NSW CESE — Cognitive load theory: research that teachers really need to understand (the best short practical guide)
- Spanjers et al. — segmentation of worked examples (why the demos come in named pieces)
- Every Learner Everywhere — cognitive load and equity in higher ed
The application to media production, four-course semesters and AI supervision is mine. Argue with me about it at crit.
Blender in Six Days
Six short sessions to get Blender under your hands before the course needs it — forty-five to sixty minutes a day, self-paced, ungraded, in any week you like. You will build a background you could stand in and animate a character that walks. It exists so that studio time is spent making things rather than hunting for menus. If you have never opened Blender, start with Day 0 — an hour on the interface and the vocabulary, with screenshots. After that there is an optional Grease Pencil track for anyone who wants it.
This sits inside the hands-only stretch of the course, so: no Claude Code, no Codex, no generative tools making your geometry, rigs or animation. Gary, the AI TA, is open the whole time for questions — asking it why is my normal map inverted is help, and it is encouraged. Having it build the mesh is not.
The reason is simple: from Week 9 you will be directing agents, and you cannot tell whether an agent did good work until you can do the work yourself. These six days are what make that judgement possible.
The three strands
Backgrounds
Sculpt a landform and judge it from eye height rather than orbit; then read the course soundstage at three scales, see where a triangle budget really goes, and get the set into Unreal at the right size.
Character animation
Meet a character that is already rigged and weighted — pose it, read its weights, verify what Unreal needs of it — then animate a walk cycle that loops without stuttering, and export it so Unreal accepts it.
Grease Pencil
A separate four-part track once the six days are done. Draw inside 3D space, and use it the way animators actually do — to plan motion before you touch a rig.
Days build on each other: Days 3–6 all work in one supplied file, and Day 6 needs the walk from Day 5.
BlenderSoundstage.zip (16 MB) — one .blend with a character already rigged, bound and weighted on a 65-bone skeleton named the way Unreal names its own, standing on a lit 20-meter stage with a framed camera. Days 3 through 6 open this file. You do not build a rig in this track: fitting a metarig and cleaning weights is a two-day job done properly, and the term needs you animating. Character by Quaternius, CC0; the stage was built for this course.
Day 1 is the one with a deadline — Week 1 has you round-tripping your first object into Unreal on Aug 31, and Week 3 is the export contract itself. Do it before the first class if you can.
Everything after that has room. Days 2–3 back your environment work and Week 2's polygon budget; Days 4 and 5 serve Weeks 8 and 9 (Oct 19 and Oct 26), which are the two weeks students most often come unstuck in; Day 6 feeds Week 10's Animation Blueprints.
Foundations
The interface, and the words for it
- For anyone who has never opened Blender. The window named part by part, moving around, Object mode versus Edit mode, G/R/S and the N panel, the Add menu and the 3D cursor, what a modifier is, and where the Adjust Last Operation panel hides. Every step on the later days assumes these.
- Two Preferences settings for PC laptops and trackpads (Emulate Numpad, Emulate 3 Button Mouse), a glossary of the words the later days use without explaining, and a ten-minute drill to prove you are ready.
- Screenshots throughout — and from here on, every day page has them at the steps that are hardest to follow from text alone.
Getting your bearings, and the export contract
- The handful of keys that matter: Tab for Object vs Edit mode (check this first when something "won't work"), G/R/S then X/Y/Z to constrain, N for exact numbers, Shift+C to reset the 3D cursor, Numpad . when your model vanishes.
- Blender measures in meters; Unreal measures in centimeters. One Blender meter must arrive as 100 Unreal units. That sentence explains most "why is my model enormous" problems you will have this term.
- Make a cube exactly 2 m, Ctrl+A → All Transforms, export, import, and measure it in Unreal — it should read 200. Then break it deliberately: scale it without applying and watch what happens.
Backgrounds
Building ground
- Two kinds of ground, and the distinction governs everything. A heightfield is a grid pushed up and down, like a bedsheet over furniture — it has exactly one height per point, so it physically cannot make a cave mouth or an overhanging cliff. Those shapes have to be meshes.
- Plane → subdivide, then big shapes first with proportional editing (O) — move one vertex and its neighbors follow, giving you a valley in ten seconds.
- Sculpt the rest with Draw, Clay Strips and Smooth, then a Displace modifier for irregularity you did not have to sculpt.
Making it read, and getting it in
- Big, medium, small. Big is the silhouette you recognize from far away; small is surface texture, nearly invisible until you are close. Beginners spend all their time on small — if the silhouette is not working, no amount of surface detail rescues it.
- Scale cues. Nothing in a scene has a size until something familiar sits next to it. The course soundstage carries two on purpose — a 1.82 m person and a stack of apple boxes — and today you open it and read it.
- Where the budget goes. The whole set is 240 triangles; the character is over 14,000. Decimate the character while watching the silhouette, then throw the modifier away; fix a prop whose origin sits in empty space; export the five set pieces and stand them up in Unreal at eight meters, next to a mannequin.
Character animation
A rig that survives the trip
- Today is not about movement. A beautiful animation on a rig you do not understand cannot be rescued when it breaks. The rig is supplied, bound and weighted; you learn to read it rather than build it.
- What a rig is: an armature is a set of bones; skinning tells every vertex which bones move it and by how much — a value from 0 to 1 per bone, adding to 1. When a shoulder crumples like a paper bag, those numbers are wrong in that spot. That is all weight painting means.
- Read the 65-bone tree and what follows what; Pose Mode — rotate an arm, watch the shoulder, reset with Alt+R; Weight Paint — Ctrl-click a bone and see its gradient at the shoulder, then leave without painting; push the rig to its extremes and know what a pinch is.
Making it move
- A walk is four poses that repeat: contact, down, pass, up — then contact again on the opposite foot. Block all four before polishing anything; the most common way students fail to finish is refining pose one for forty minutes.
- Steal the second half: copy a pose and paste it flipped (Ctrl+Shift+V) — the single biggest time-saver in character animation, and it depends on the bone naming Day 4 checked. The supplied rig is forward-kinematics only: you pose a leg from the thigh down, and an in-place cycle is exactly what that suits.
- In the graph editor, the spacing between keys is what you perceive as timing and weight. Then make it loop without the duplicated frame that reads as a stutter.
Into the engine
- Decide before you export. In-place means the feet cycle while the game moves the character; root motion means the animation carries them and the game follows. Pick one per clip — mixing them is exactly what produces a character who moonwalks or runs away from where the game thinks they are.
- Name clips like assets, match your frame rate to the engine's, and export the character as glTF with its animation — not FBX, which carries a scale quirk on rigs that breaks retargeting. FBX stays the right tool for the set.
- Import the character first, then each animation against that same skeleton — accidentally importing a second skeleton is how students end up with two incompatible copies of their character. Then stand it on the set you exported on Day 3.
Optional track · Grease Pencil
Everything above is the part the course leans on. This is the part you take because you want to.
Grease Pencil makes strokes that live in 3D space rather than on a flat canvas — you can orbit the camera around a drawing. It is an unusual thing to find inside a 3D application, and it is more useful to an animator than it first looks. Four short sessions, same pace, entirely optional, nothing graded.
Drawing in three dimensions
- Add → Grease Pencil → Blank, switch to Draw mode, make a mark — then orbit the camera. Feel that before anything else; it is the whole idea.
- Strokes sit on layers and are colored by materials that control line and fill separately. Rough on one layer, cleaner line above it, color underneath. Layers are cheap.
- Draw a simple object from one angle, then move around it and see where your strokes actually sit in space. That surprise is the lesson.
Making it move
- Drawings are held on frames along the timeline, so a drawing changes over time like any other animation.
- Turn on onion skinning — you see the drawings before and after the current one as ghosts. This is how hand-drawn animation has always been made.
- Draw on frame 1, move to frame 12, draw a changed version. Then add one drawing between them and watch how much the timing changes.
Using it to plan — the reason it is here
- Thumbnail your keys before you touch the rig. Four rough drawings of contact, down, pass and up take five minutes and save an hour of posing — and you can draw them right next to the character at the correct scale.
- Storyboard inside the set. Draw shots inside the background you built on Days 2–3 and the perspective is already correct, because you are drawing in the actual space.
- Plan a camera move by sketching what you want in frame rather than describing it to yourself in words.
Line Art, and where this stops
- The Line Art modifier generates Grease Pencil strokes automatically from your 3D geometry. Point it at the background you built and you get a drawn version that updates when you change the model.
- It is the doorway to stylised and toon-shaded looks. Half an hour is enough to know it exists and what it can do.
- Try it on your character too, and see which lines it finds and which it misses.
Each of the day pages carries its own tutor — a separate one from the course AI TA, briefed on Blender specifically, on this path, and on the shelf below. It knows which day you are reading, so you can ask “why did step 4 do that” without explaining the context first.
It explains and diagnoses; it does not do the work. Ask it why your normal map is inverted and it will walk you through it. Ask it to write a script that generates your terrain and it will decline — that is the whole point of these days. You will need the class password the first time you open it.
Where to learn more
A short, deliberately curated shelf — and the same one the Blender TA draws on, so what it recommends is what is listed here. Three layers, and it is worth knowing which kind you are opening before you start.
Reference
What a tool is, and what its options mean. Go here to look something up, not to learn an approach.
| Resource | Level | Best used for |
|---|---|---|
| Blender Reference Manual | all | The canonical documentation and the backbone of this taxonomy. Send students here for what a tool IS and what its options mean — not for how to approach a project. |
| Blender Support hub | all | Blender's own starting point, pointing at the manual, community tutorials and Blender Studio. |
| Blender Tutorials (official index) | beginner | The officially curated tutorial entry point. |
Tutorials
How a workflow actually goes, watched over someone’s shoulder. Tagged by teaching style, because the right one depends on where you are stuck.
| Resource | Level | Best used for |
|---|---|---|
| Blender Guru search by name | beginner | Step-by-step foundational projects; the Donut series is the usual first thing a beginner is pointed at. Best for building confidence with a finished result. |
| Grant Abbitt search by name | beginner | Approachable, patient beginner instruction. The best recommendation for a student who found another tutorial too fast. |
| CG Geek search by name | beginner | Broad practical Blender workflows across a wide range of subjects. |
| Ryan King Art search by name | intermediate | Short, focused single-technique tutorials. Best when a student needs one specific thing rather than a project. |
| Polygon Runway search by name | intermediate | Stylised and illustrative work at an intermediate level. Good for a student who can drive Blender but is asking how to make things look designed. |
Courses
A sequenced path with an order someone thought about. Worth it if a playlist leaves you unsure what to do next.
| Resource | Level | Best used for |
|---|---|---|
| Blender Studio | intermediate · paid | Production-oriented training and real production assets, from the Blender organization itself. The closest thing to seeing how professionals actually work. |
| Class Central Blender roundup | all | A meta-curation layer for comparing courses across providers. Use it to vet, not to learn. |
| Coursera — Blender for Beginners Specialization | beginner · paid | A sequenced beginner curriculum for students who want structure rather than a playlist. |
Several of the tutorial creators are named without a link, on purpose. Channel URLs move, and a dead link that looks authoritative wastes more of your time than no link at all — search the name instead. The Blender TA is instructed never to invent a URL either; if it does not have one, it will tell you what to search for.
The topic buckets here mirror the official manual's own structure rather than our course weeks. That is deliberate: the manual gets reorganized rarely, so this shelf stays usable long after this semester.
Ask Gary, the AI TA — the button in the corner of this page. He is open all term and he is there for exactly this. Describe what you did, what you expected, and what happened instead; learning to ask a debugging question well is itself part of the course.
And bring it to the Workbench hour in class. That block exists so being stuck is something that gets solved in the room rather than at 2am.
Resources
The bookmarks that matter. Everything here is current for Unreal Engine 5.8 as of summer 2026.
Engine & tools
- Unreal Engine 5.8 — install from the Epic Games Launcher; see the 5.8 release notes.
- Epic Developer Community — Learning — official tutorials and courses; the Blueprint and animation tracks back several weeks here.
- Unreal Engine documentation and Blueprints reference — the canonical docs; have the agent cite them.
- Blender — free modeling, UV, texture-paint, and rigging (Rigify); our default DCC tool.
- Substance 3D Painter — PBR texture painting (free with UT Creative Cloud).
- Mixamo — free auto-rigging and a motion library for retargeting practice.
Interactivity
- Animation Blueprints and Blend Spaces — state machines, blending, and IK Retargeter retargeting.
- Enhanced Input and OpenXR / XR in Unreal — optional, if you take VR as a self-directed stretch on P3. Taught properly in FMX 430.
- Networking & multiplayer — optional, if you take multiplayer as a self-directed stretch on P3.
- itch.io publishing — how your packaged standalone build reaches players.
AI agents & MCP
- Claude Code documentation — install, MCP configuration, workflows.
- OpenAI Codex CLI — install and usage for the counterpart agent.
- Unreal MCP (built into 5.8) and Epic's UE skills for Claude Code — the first-party bridge and skills that let agents act inside the editor.
- Model Context Protocol — what MCP is and how servers and clients connect.
State-of-the-art reading list
The sources behind each week's SOTA segment. Claims fact-checked July 2026; market figures are analyst estimates and vendor performance numbers are targets, not independent benchmarks.
- Kerbl et al., “3D Gaussian Splatting for Real-Time Radiance Field Rendering” (SIGGRAPH 2023) — the capture-vs-model landmark paper.
- Unreal Engine 5.8 release notes — the engine baseline for the course.
- Robert Half 2026 tech hiring — the fundamentals-plus-AI hiring reality.
- Lumen global illumination — real-time GI direction.
- Claude Code and OpenAI Codex — the agents in the toolchain.
University
- SpartanLearn (Canvas) — announcements, submissions, the governing syllabus.
- UT Adobe Creative Cloud — creativecloud.adobe.com with your UT email.
- Student Accessibility Services — (813) 257-5757 · accessibility.services@ut.edu.