Less friction: human ergonomics for Blueprints
Blueprints are easy to start and hard to grow. The graphs inside an Unreal class are procedural, while the classes around them are object oriented, so the structure a programmer leans on disappears: the hierarchy hides, wires tangle, casts stand in for interfaces, and the only way to understand a graph is to pan across it. The Blueprint view attacks that friction four ways: it raises a Blueprint back to the objects it really is and draws them in 3D, it lets you say what you want, it shows the whole thing as code, and it lets you watch it run. This page goes through each, with what is measured and what is not done.
1Objects you can see: OO, raised and drawn in 3D
Read back as classes. The pasted text never names a class's parent, so the view reads it from the evidence: the engine members a Blueprint uses on itself, and the engine header that declares each one. Lock-On's FrankBP is a Character because it uses Crouch (Character.h:871), UnCrouch (Character.h:880), CharacterMovement (Character.h:259), K2_GetActorLocation (Actor.h:1571), GetActorForwardVector (Actor.h:1596), GetController (Pawn.h:249) on itself. Fields are typed from the pins that read and write them, components come from the events bound to them, and the interface LockOnInterface is drawn with the 6 places that message it. Where the text does not say, the view says so rather than guess. Every class of every sample, as read:
| Sample | Class | Parent, and the evidence | Fields / methods |
|---|---|---|---|
| Pong | BP_Ball | Actor, read from K2_AddActorWorldOffset (Actor.h:1758), K2_SetActorLocation (Actor.h:1588) | 2 / 3 |
| Pong | BP_Paddle | Actor, read from K2_AddActorWorldOffset (Actor.h:1758) | 2 / 2 |
| Asteroid Shooter | BP_Asteorid | Actor, read from K2_DestroyActor (Actor.h:1937), K2_SetActorLocation (Actor.h:1588), K2_GetActorLocation (Actor.h:1571), SetActorScale3D (Actor.h:1709) | 2 / 2 |
| Asteroid Shooter | BP_Character | PaperCharacter, read from Sprite (PaperCharacter.h:25), K2_SetActorRotation (Actor.h:1653) | 3 / 2 |
| Asteroid Shooter | BP_Controller | Controller, read from K2_GetActorRotation (Actor.h:1592), SetControlRotation (Controller.h:163) | 3 / 3 |
| Asteroid Shooter | BP_EnemyLogic | not stated: no native member it uses on itself names a class | 0 / 3 |
| Asteroid Shooter | BP_EnemyProjectile | Actor, read from K2_GetActorLocation (Actor.h:1571), K2_SetActorLocation (Actor.h:1588), K2_DestroyActor (Actor.h:1937) | 2 / 3 |
| Asteroid Shooter | BP_EnemyShip | Actor, read from K2_DestroyActor (Actor.h:1937), K2_GetActorLocation (Actor.h:1571), K2_SetActorLocationAndRotation (Actor.h:1686), SetActorScale3D (Actor.h:1709) | 5 / 3 |
| Asteroid Shooter | BP_Meteor | Actor, read from K2_GetActorLocation (Actor.h:1571), K2_SetActorLocation (Actor.h:1588) | 2 / 2 |
| Asteroid Shooter | BP_Projectile | PaperSpriteActor, read from RenderComponent (PaperSpriteActor.h:25), K2_GetActorLocation (Actor.h:1571), K2_DestroyActor (Actor.h:1937) | 0 / 1 |
| Asteroid Shooter | TitleScreen | not stated: no native member it uses on itself names a class | 0 / 1 |
| Lock-On System | MasterEnemy | Actor, read from K2_GetActorLocation (Actor.h:1571) | 2 / 1 |
| Lock-On System | FrankBP | Character, read from Crouch (Character.h:871), UnCrouch (Character.h:880), CharacterMovement (Character.h:259), K2_GetActorLocation (Actor.h:1571), GetActorForwardVector (Actor.h:1596), GetController (Pawn.h:249) | 11 / 11 |
| Lock-On System | Master_Enemy | not stated: no native member it uses on itself names a class | 2 / 0 |
| Antagonist Enemy AI | Enemy_AI_BP | Character, read from K2_GetActorLocation (Actor.h:1571), CapsuleComponent (Character.h:263), Mesh (Character.h:255), CustomTimeDilation (Actor.h:761), CharacterMovement (Character.h:259), K2_DestroyActor (Actor.h:1937), K2_GetActorRotation (Actor.h:1592), K2_SetActorRotation (Actor.h:1653) | 67 / 36 |
| Antagonist Enemy AI | BP_LearningKit_PlayerCharacter | not stated: no native member it uses on itself names a class | 11 / 0 |
Drawn as a city. Each class is a district standing over its parent's floor, so the hierarchy a Blueprint hides is the ground you fly over. An interface is a ring its messages pass through. A call between graphs is an arc, and a call made by a name in a string, which no editor search can find, marches in orange: Lock-On makes 5 of its 13 calls between graphs that way. Execution pipes run above the nodes and data pipes below them, so the two can never cross: as drawn, 17 of Lock-On's wire crossings and 108 of the enemy AI's are execution over data; in 3D, none.
Less boilerplate. Variable reads and pure math are written into the statement that reads them, the way the engine compiles a pure node, so a getter is a word in a line and not a node to wire: 43 of Lock-On's nodes and 451 of the enemy AI's fold away like that.
The OO shape it proposes. For each procedural pattern the brainstorm finds, the view names the object-oriented form that removes it. A proposal is a design, not a change: nothing here rewrites a Blueprint. On Lock-On:
- the casting trap: 4 Cast To nodes test an actor's class before using it: an interface the cast class implements, holding the members the code reads through the cast; the code asks the interface instead of casting
- 3 events fired like function calls (LockON, LockOnDone, SetLockOnTarget): private methods of the class: called in order, can return a result, cannot be fired from outside
- 2 functions run by a NAME in a string (DistanceToFrank, ToggleLockOn): a delegate bound to the method itself: a rename is a compile error, and the reference shows in a search
- ClosestTargetDistance written by 2 graphs: one owner: a private field behind a single method that changes it (and tells whoever must know)
- LockedOn written by 4 graphs: one owner: a private field behind a single method that changes it (and tells whoever must know)
- LockedOnTarget written by 3 graphs: one owner: a private field behind a single method that changes it (and tells whoever must know)
- FrankBP carries 11 fields, 2 components and 11 methods that are all one behaviour: one component any Character can add (composition), named after the system: FrankBP keeps being a Character, the behaviour moves out of its graph
- state polled by looping timers (DistanceToFrank, ToggleLockOn): ask when needed instead of polling: compute the value where it is used, and update on the owner's own tick
Hierarchy: ANSWEREDCasting trap: PROPOSED
2Say it: dictation
The city's command bar takes what you type or say. Press Mic and say a command; the city says back what it heard and what it did.
fly toany graph, class, interface or statement by name or by its words:fly to lock on,fly to Frank BP,fly to random roamplay 3,pause,next,go back: replay a path step by stepshow the code,blueprint,pseudo, andwhole codefor this page's view of all of itquestionsfor the questions only the Blueprint's author can answer, andaskanything:ask what happens when the locked target dieshands back only the slice of the trace that answers, 905 tokens a question where the converted code is 24,615 and the raw paste 164,230
Measured: 19 of 22 spoken commands were heard and run, end to end, on this site's live city, in Chrome 156.0.8078.49, with a synthesized voice played to the browser as its microphone (tools/dictation_check.py). Names are matched by what is said, not how they are spelled, and a name heard slightly wrong goes to the nearest one, saying so. Chrome, Edge and Safari offer speech recognition; Firefox does not, and the Mic button says so, while typing does the same. Voice: PARTLY: commands yes; speaking a CHANGE, not yet Speaking a change is not built: under closed loop requirements a change belongs on a requirement, and the loop then names the code that must change.
3All of it, as code
Every node in the city opens its Blueprint nodes, its line of C#, its pseudo-code and its whole graph's code, with its line lit; click a line of code and the city selects its node. 99 of 99 Lock-On statements map to 99 distinct C# lines. And the whole-code page shows every sample entire: every class, field and method, each method's body its converted graph, with the same graphs in the node graph language the views print from.
4Watch it run: observation
Understanding comes faster from watching than from reading. Pong and the asteroid shooter play on their converted Blueprints, and every node lights as it runs, in the city and in the Unreal-style 2D view. Every path through a graph replays step by step, back and forth, each step naming the use case step and the requirement it serves: 54 paths through Lock-On, 270 through the enemy AI. A graph a timer runs a hundred times a second burns red, so a hidden cost is the first thing you see. Flowing data: ANSWERED
5Debugging: the part not done
Debugging is where ergonomics matters most, and it is not finished. What exists: replaying paths on every sample, and on the battles of a game in production, replaying with real values, scrubbing back to the step where a planted fault diverged, and changing a value at a probe to re-run every battle with no rebuild. What does not: values for a Blueprint pasted from the web, because a paste holds no run (its enemy class and the engine are not in it), and a debugger a person has used in anger. Replay: ANSWERED for paths; VALUES on the replays of a game in productionCoding by watching: ANSWERED on the replays of a game in production; ABSENT on the sample
6Why more than one way in
People understand in different ways. Some read their way in, some talk it through, some need to see it, and some only get it with their hands in the thing. You can sort them into a few types, but really it is a broad spectrum, and a tool built for one kind of mind leaves the others out. So the Blueprint view offers several doors into the same logic: read it as code, say it, see it as a city, watch it run, step it back and forth. Observation carries the most weight for the people who learn by doing. I am one of them: describing a system to me engages very little; getting into it engages everything.
The craft is changing, and the artistry is not leaving. A hand-made table and a skyscraper are both building, at different scales, and both will always exist. I watched music go through this in my father's recording studio, from the seventies into the nineties: playing every part gave way to remixing, and later a DJ could make a record without playing an instrument, the way vibe coding makes software without reading it. The game changed; the art stayed. Games are at that point now, and AI remixes will be everywhere.
So the work that is ours moves. Not the typing: understanding people, which is what human ergonomics is, the art itself, and the requirements, to the letter. When code was slow to write we planned so we would never write it twice. Now it takes a second to write, and the danger is writing it wrong: at that speed nobody reads every line, and there is no cheap repair. The only safe way is right the first time, which is what closed loop requirements are for.
A prototype: measured by tools, not yet tested by people. The samples are public pastes on blueprintue.com; their authors keep the rights. Every figure on this page is read from the experiment's result files when the page is built. Source: github.com/rj45Thompson/blueprint-view-source.