From meta-vr
Ensures accurate GameObject placement in Unity for Meta Quest and Horizon OS using Renderer/Collider bounds to prevent overlaps when positioning relative to other objects like on, beside, or above.
npx claudepluginhub meta-quest/agentic-tools --plugin meta-vrThis skill uses the workspace's default tool permissions.
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.
Creates, loads, saves Unity scenes; manages GameObjects with primitives, parenting, positions; adds components; retrieves hierarchies and analyzes scenes.
Configures Unity world-space canvases and UI for Meta Quest VR with TextMesh Pro setup, optimal sizing, viewing distances, and interaction readiness. For VR canvas setup, TMP text, interactive UI, and fixing sizing/interaction issues.
Creates and bootstraps Unity scenes using unity-cli. Use for new scene creation, loading/saving scenes, adding starter GameObjects, and attaching components during level or test setup.
Share bugs, ideas, or general feedback.
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: