Scenes
Before diving into the thick of it, we need to do some boring theory first.
I know. Reading sucks. But if you spend 15 minutes reading now you're gonna save months of your time later. Trust me.
What Are Scenes?
Think of a scene as a virtual stage where all your 3D creations live. Just like a theater stage has boundaries, lighting, and props arranged in space, a 3D scene provides the framework for organizing and displaying your digital objects.
The Foundation: 3D Coordinate Systems
Every 3D scene is built on a coordinate system - imagine an invisible grid that helps us describe exactly where everything is positioned in 3D space.
Understanding the Three Axes
A 3D coordinate system uses three axes (X, Y, Z) that intersect at a central point called the origin (0,0,0). Each axis represents a different direction:
Important Note: Different software uses different conventions, so don't be surprised when you see variations! Here's how Blender organizes its axes:
X-axis: Left/Right movement
Positive X = Right
Negative X = Left
Y-axis: Forward/Back movement
Positive Y = Forward
Negative Y = Back
Z-axis: Up/Down movement
Positive Z = Up
Negative Z = Down
Key Concept: There are positive and negative ranges to these dimensions, and there will be the concept of a “front and back” axis (a forward axis), a “left to right” axis (a right axis), and an “up and down” axis (up axis)
Software Differences You'll Encounter
Different 3D programs organize their coordinate systems differently:
Blender: +Y forward, +Z up
Unreal Engine: +X forward, +Z up
Unity: +Z forward, +Y up
Don't worry about memorizing these now - just know that you'll need to adapt when moving between programs.
The Origin Point: Your World's Center
The origin (0,0,0) serves as the anchor point for everything in your scene. All objects are positioned either:
Directly relative to this origin point, or
Relative to another object, which is ultimately relative to the origin
In Blender, you can see any object's position coordinates in the properties panel - this shows its distance from the origin along each axis.
Infinite Space (With Limits)
Coordinate values can be positive or negative, allowing objects to exist in any direction from the origin. While the theoretical space is infinite, the practical limitations of computing place on us this constraint - that extremely large or small numbers cannot be accurately represented in our modeling program.
This will not cause problems until your models are many thousands of meters away from the origin or in size, so don't worry about it for now, but keep it in mind.
Objects and their Transforms:
Scenes are populated with "Objects", and these objects have Positional, Rotational, and Scale data associated with them in the form of a "Transform", (Sometimes referred to as an xFORM in other DCCs).
Translation (Position): Where it is located in 3D space.
Rotation: Its orientation in 3D space.
Scale: Its size along each axis.
These transforms can be in several "spaces", the most common being a "Global space" *(aka world or scene space) and "Local space".
Global space transforms are always relative to the World Origin.
Local space transforms are always relative to some other object
The mesh data of any object for example is described relative to the objects location - in "local space".
If this is confusing right now, that's ok, we're not mathematicians - but it will come up later.
Scale and Units:
Here's where things get tricky: different software uses different unit systems, and there's no universal standard. For example:
Blender: 1 unit = 1 meter
Unity: 1 unit = 1 meter
Unreal Engine: 1 unit = 1 centimeter
Maya: 1 unit = 1 centimeter (I think?)
Real-world Impact: Take a 180cm tall human. That character is "1.8 tall" in Blender. When imported into Unreal, its also going to be "1.8 tall", however:
The Blender character will be 1.8 meters tall
The Unreal character will be 1.8 cm tall, shrunk all the way down, off by a factor of 100.
Caution: This means that you will often find your models either being 100x their normal size, or 0.01x their normal size, when moving assets between varying programs. This will be expressed
This often results in scale factors of 100x or 0.01x when moving assets between programs.
Why This Matters
Games are very particular experiences that hinge on mathematics and team work, and handing content to the engineering team that requires them to counteract your work by either scaling it back up by 100 or scaling it down by 100 isn't fair to them, so we shouldn't make that mistake.
Technically you can do this as the engines functionally support these scale differences, but in the real world, the industry has outlawed it, because it makes everyone else's lives miserable.
I will go over in depth how to prevent this when we get into exporting, but for now just keep it in mind.
Lastly ...
Unit systems also affect things like physics calculations, gravity, collisions, lighting calculations, etc etc. Therefore: we always want to stick to the rough real world scale of anything we created. It doesn't need to be scientific or exact, it just needs to be ballparked, but as a rule of thumb we stick to real world scales - every time.
The TRS Gizmo: Your Manipulation Tool
When interacting with objects in CG programs, blender, max, maya, unreal, unity, etc, you will commonly see something called a TRS gizmo:
TRS of course stands for Translation, Rotation, and Scale. This is the fundamental manipulator cursor you will use to manipulate things in 3d space.
Translation (Movement) - represented by arrows
Rotation - represented by curved lines/circles
Scale - represented by small squares or cubes
Note - Blender is actually awesome in that it provides simple intuitive hotkeys such that once you're underway, you won't even use the TRS gizmo directly, because you wont need to!
All 3d programs use some form of TRS manipulator gizmo.
Understanding Spaces: Local vs Global
When manipulating objects in a scene, you will be performing these manipulations in some sort of "space", which will ultimately define how the translation resolves when for that object.
Global Space
When working in Global Space, all transformations are performed relative to the world's coordinate system (the scene's X, Y, Z axes). Moving an object +5 units on the X-axis will always move it in the same world direction, regardless of how the object is rotated or scaled.
Local Space
When working in Local Space, transformations are performed relative to some other space. Meshes for example exist entirely within the "Local Space" of the object that contains them.
A weapon that a character holds for example, may exist in within the "Local Space" of the players hand that is holding it.
Imagine opening a car door. You would open it by rotating it out and away from the vehicle. But it doesn't matter if the car is facing north, or south, or even turned upside down. The door will always be opened in the same way, swinging out and away from the car - this is a local space transformation.
What else Lives in a Scene?
Anything with a transform can be said to be an Object that lives in a scene, for example:
Lights, Particles, Characters, Explosions, Cameras, etc.
Key Takeaways for New Students
Coordinate systems are fundamental - everything else builds on this foundation
Software differences are normal - expect errors when switching programs, and don't complain. We will learn how to overcome these later.
Units matter - always check your scale when importing/exporting.
All things that exist in a scene are an "Object" of some kind, but those objects can contain many different types of data internally.
When things Transform through space, these transformations can be in Local, Global, or any other such space.
Last updated