From meta-vr
Places Unity GameObjects relative to others using Renderer/Collider bounds to prevent overlaps. Activates on spatial placement requests like "put X on Y" or "position X 2 meters left of Y."
How this skill is triggered — by the user, by Claude, or both
Slash command
/meta-vr:hz-unity-placementThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
This skill ensures that when placing, moving, or positioning Unity GameObjects relative to other objects, proper bounding box calculations are used to prevent overlaps and ensure accurate placement.
This skill ensures that when placing, moving, or positioning Unity GameObjects relative to other objects, proper bounding box calculations are used to prevent overlaps and ensure accurate placement.
Use this skill automatically whenever:
IMPORTANT: Proactively invoke this skill immediately when you detect ANY of these patterns:
refMax.x + 1.0 + targetExtents.xExample 1: "Place all objects on the tables"
Example 2: "Put the mug on the table"
Example 3: "Place the lamp next to the clock"
refMax.x + targetExtents.xExample 4: "Position the book 0.5 meters to the left of the pen"
penMin.x - 0.5 - bookExtents.xExample 1: "Move object to [5, 10, 3]"
Example 2: "Set the cube's position to (0, 0, 0)"
ALWAYS get bounding box information before calculating positions.
Never assume object sizes - always retrieve actual bounds from Renderer or Collider components using whatever Unity MCP tools are available.
When the user requests object placement:
For BOTH objects, retrieve bounds using available Unity MCP tools:
MeshRenderer or Collider components and their bounds propertyUnderstanding bounds types in Unity:
| Property | Space | Accounts for rotation? | Use when |
|---|---|---|---|
Renderer.bounds | World | Yes (AABB enclosing rotated mesh) | Placing objects in the scene — preferred for placement |
Renderer.localBounds | Local | No (ignores rotation) | Comparing intrinsic object sizes without rotation effects |
Collider.bounds | World | Yes (AABB enclosing rotated collider) | Placing objects when no Renderer exists |
Always prefer world-space bounds (Renderer.bounds or Collider.bounds) for placement. These already account for the object's position, rotation, and scale — no manual conversion needed.
If using world-space bounds (preferred — from Renderer.bounds or Collider.bounds):
The values are ready to use directly:
worldCenter = bounds.center // already in world space
worldMin = bounds.min // already in world space
worldMax = bounds.max // already in world space
size = bounds.size // world-space AABB dimensions
extents = bounds.extents // half of size
If using local bounds (from Renderer.localBounds or manual component data):
Convert to world space by adding the object's position:
worldCenter = position + localBounds.center
worldMin = worldCenter - (localBounds.size / 2)
worldMax = worldCenter + (localBounds.size / 2)
Note on rotation: Local bounds ignore rotation. If converting from local bounds on a rotated object, the calculated AABB will not reflect the actual world-space footprint. Prefer world-space bounds whenever possible.
Store these values for each object:
worldCenter: [x, y, z]size: [width, height, depth]extents: [width/2, height/2, depth/2]Based on the spatial relationship, calculate the target position:
On top of (object A on top of object B):
targetY = B.worldMax.y + A.extents.y
targetX = B.worldCenter.x
targetZ = B.worldCenter.z
newPosition = [targetX, targetY, targetZ]
Beside (object A beside object B, +X direction):
targetX = B.worldMax.x + A.extents.x
targetY = B.worldCenter.y
targetZ = B.worldCenter.z
newPosition = [targetX, targetY, targetZ]
In front of (object A in front of object B, +Z direction):
targetX = B.worldCenter.x
targetY = B.worldCenter.y
targetZ = B.worldMax.z + A.extents.z
newPosition = [targetX, targetY, targetZ]
Above (floating above, with gap):
gap = 0.5 // or specified distance
targetY = B.worldMax.y + gap + A.extents.y
targetX = B.worldCenter.x
targetZ = B.worldCenter.z
newPosition = [targetX, targetY, targetZ]
Next to / Beside with distance (object A next to object B, with specified gap):
gap = user_specified_distance // e.g., 0.5 meters
// Right side (+X):
targetX = B.worldMax.x + gap + A.extents.x
// Left side (-X):
targetX = B.worldMin.x - gap - A.extents.x
targetY = B.worldCenter.y // or B.worldMin.y + A.extents.y for ground level
targetZ = B.worldCenter.z
newPosition = [targetX, targetY, targetZ]
X meters/units to the left/right/front/back:
// "2 meters to the right of B"
targetX = B.worldMax.x + 2.0 + A.extents.x
// "1.5 units to the left of B"
targetX = B.worldMin.x - 1.5 - A.extents.x
// "0.5 meters in front of B"
targetZ = B.worldMax.z + 0.5 + A.extents.z
// "1 unit behind B"
targetZ = B.worldMin.z - 1.0 - A.extents.z
Use available Unity MCP tools to set the target object's position to the calculated coordinates.
After placement, inform the user:
Renderer.bounds) are axis-aligned bounding boxes (AABB) that expand to enclose the rotated mesh. A 1x0.1x1 plane rotated 45 degrees on Z will have a taller AABB than when flat. This is correct behavior — the AABB reflects the actual space the object occupies. Always use world-space bounds for placement so rotation is automatically handledRenderer.bounds) are axis-aligned bounding boxes (AABB) that expand to enclose the rotated geometrylocalBounds to compute a surface point, rather than relying on the AABBUser: "Place the Cube on top of the Sphere"
Get Sphere's components and extract bounds:
Get Cube's components and extract bounds:
Calculate new position:
Apply position to Cube
Report: "Placed Cube on top of Sphere at position [0, 2.5, 0]. The Cube (size 1x1x1) sits on the Sphere's top surface (Y=2)."
World-space (Renderer.bounds, Collider.bounds) — use for placement:
bounds.center: World-space center of the AABBbounds.size: Full AABB dimensions (accounts for rotation and scale)bounds.extents: Half dimensions (size / 2)bounds.min: World-space minimum cornerbounds.max: World-space maximum cornerLocal-space (Renderer.localBounds) — use for intrinsic size comparison:
localBounds.center: Local offset from object pivotlocalBounds.size: Intrinsic dimensions (ignores rotation)localBounds.extents: Half dimensions (size / 2)refMax.y + targetExtents.yrefMin.y - targetExtents.yrefMax.x + targetExtents.xrefMin.x - targetExtents.xrefMax.z + targetExtents.zrefMin.z - targetExtents.zrefMax.x + distance + targetExtents.xrefMin.x - distance - targetExtents.xrefMax.z + distance + targetExtents.zrefMin.z - distance - targetExtents.zrefMax.y + distance + targetExtents.yrefMin.y - distance - targetExtents.yrefMax.x + gap + targetExtents.x (or use refMin.x for left side)The goal is to make object placement intuitive and accurate. Always:
npx claudepluginhub meta-quest/agentic-tools --plugin meta-vrProvides high-level tools for scene-aware mixed reality development in Unity using Meta XR MRUK, including scene loading, world locking, prefab spawning, and environment raycasting.
Builds Unity scenes via CLI: object placement, component configuration, prefab creation, and scene save/load through unity-cli Relay Server.
Unity 3D math correctness patterns. Catches common mistakes with coordinate spaces, Quaternion, Vector3, Plane, Bounds, Transform hierarchies, raycasting projection, and floating-point precision. PATTERN format: WHEN/WRONG/RIGHT/GOTCHA. Based on Unity 6.3 LTS documentation.