# Collision Detection Primitives MCP for AI Agents MCP > Collision Detection Primitives is a specialized computational engine for 3D spatial mathematics. It calculates intersections, penetrations, and impact timings between common geometric shapes like spheres, axis-aligned bounding boxes (AABBs), rays, and planes. This MCP lets your AI agent determine exactly if objects overlap in virtual space or what point they hit along a path, giving developers precise physical data needed for realistic simulations. ## Overview - **Category:** mathematics - **Price:** Free - **Endpoint:** https://edge.vinkius.com/vk_preview_kK2yROtuWhslKjCtmw2YLCD0P6tkFHsyCR0wgegM/mcp - **Tags:** 3d, collision, intersection, aabb, ray-casting, spatial-math ## Description Building accurate 3D worlds requires knowing when things touch. Instead of writing complex math functions in C++ to check for overlaps, you let your AI client handle the heavy lifting. This MCP provides a computational layer that specializes in high-precision geometric intersection testing. You can ask if two spheres are overlapping and get the exact penetration depth. Need to see if a laser beam hits a virtual wall? The engine calculates the precise time of impact for rays against bounding boxes. For spatial containment, it verifies if an object is fully enclosed by specific boundaries. Connecting this MCP via Vinkius gives your agent access to industry-standard physics checks, letting you focus on design instead of differential geometry equations. ## Tools ### boundary_inclusion Verifies whether a sphere is fully contained inside specific geometric boundaries defined by minimum and maximum coordinates. ### box_collision Calculates if a sphere overlaps or collides with an axis-aligned bounding box, providing key collision details. ### ray_intersection Checks for intersections between a projected ray and an AABB, returning the time of impact along the path. ### spherical_collision Determines if two spheres are colliding and returns critical data like penetration depth and contact point. ## Prompt Examples **Prompt:** ``` I have two virtual objects. One is a sphere at (0, 0, 0) with radius 5, and the other is centered at (8, 0, 0) with radius 4. Are they overlapping? ``` **Response:** ``` **Collision Check Result:** * **Overlap Status:** Yes, collision detected. * **Penetration Depth:** 1.0 unit. * **Contact Point:** (5, 0, 0). The objects intersect exactly at these coordinates. You can use this data to trigger an impact event. ``` **Prompt:** ``` A projectile is fired from (-20, 10, 5) heading toward the box defined by min(-1, 0, -1) and max(1, 2, 1). When does it hit? ``` **Response:** ``` **Ray Intersection Analysis:** * **Target AABB:** Defined. * **Hit Detected:** Yes. * **Time of Impact (t):** 4.0 units. * **Impact Coordinates:** (-1, 1, 0). The projectile hits the boundary at time t=4.0. ``` **Prompt:** ``` Check if my main character's sphere is entirely within the map boundaries (min: -5, -5, -5; max: 5, 5, 5). ``` **Response:** ``` **Boundary Inclusion Report:** * **Sphere Center:** (2.1, 0, 3). * **Radius:** 1.5. * **Is Contained?** **YES**. The sphere is fully within the specified boundaries. The object placement is safe. ``` ## Capabilities ### Determine Sphere Overlap and Contact Details Checks if two spherical objects intersect and returns data like the depth of overlap and the precise contact point. ### Test Collision Between Spheres and AABBs Calculates whether a sphere is colliding with an axis-aligned bounding box, crucial for character interaction checks. ### Calculate Ray Impact Time Against Bounding Boxes Determines the exact time of impact and hit location when a simulated ray passes through or hits an AABB. ### Verify Object Containment within Bounds Checks if a sphere is completely contained inside defined, specific spatial boundaries. ## Use Cases ### Preventing Character Clipping Through Walls A game developer asks their agent: 'If my character (sphere) tries to move into this room's box, will they collide?' The agent runs the check using `box_collision` and reports a collision at specific coordinates, allowing the development team to adjust movement parameters instantly. ### Simulating Laser Beam Hits A simulation engineer asks their agent: 'What is the precise time and location where this laser beam (ray) hits the target box?' The agent uses `ray_intersection` to provide exact coordinates, which are needed for scoring or damage calculation. ### Checking Object Placement Boundaries A CAD modeler asks their agent: 'Is this newly attached engine (sphere) fully contained within the car chassis's bounding box?' The agent uses `boundary_inclusion` and confirms whether the object violates any defined physical limits. ### Determining Explosive Overlaps A physics programmer asks their agent: 'Do these two explosion spheres overlap given their centers and radii?' The agent uses `spherical_collision` to confirm the intersection, providing a penetration depth metric needed for accurate damage modeling. ## Benefits - Accurate Overlap Data: Use the `spherical_collision` tool to instantly know if two objects overlap and exactly how deep they penetrate, eliminating guesswork in physics design. - Fast Ray Tracing Checks: The `ray_intersection` tool calculates precise hit points and times when a beam or projectile passes through an AABB, critical for accurate aiming mechanics. - Spatial Containment Validation: Use the `boundary_inclusion` tool to programmatically ensure that no part of an object accidentally exceeds its designed operational area. - Robust Collision Checks: The `box_collision` tool handles the common scenario of checking a sphere against a simple bounding box, speeding up general physics loop calculations dramatically. ## How It Works The bottom line is your AI client executes complex 3D physics calculations without you needing to write any geometry code. 1. You give your AI client the parameters for two shapes (e.g., Sphere A and Sphere B) or a shape and its target boundary. 2. The MCP sends these geometric coordinates to the specialized computational engine, which runs multiple intersection algorithms in parallel. 3. Your agent receives a clean output: a simple 'yes' or 'no', along with critical metrics like penetration depth, contact points, or time of impact. ## Frequently Asked Questions **How do I use Collision Detection Primitives MCP to check if two items are hitting in a game?** You tell your agent the coordinates and radii of both spheres. The MCP runs the specialized collision check, giving you an instant answer on whether they overlap, along with precise data like penetration depth so you can model realistic damage. **Can I use this MCP to check if a beam hits a defined box in my simulation?** Yes. You provide the ray's start point and direction, plus the AABB boundaries. The tool calculates the exact time of impact (t) and provides the coordinates where the hit occurs, which is vital for accurate targeting systems. **What if I need to make sure a newly spawned object stays inside the map's limits?** Use the boundary inclusion tool. You specify the sphere and the boundaries (min/max coordinates). It confirms with certainty that the object is entirely contained, preventing physics errors when spawning assets. **Is this MCP better than writing custom collision math code?** Absolutely. Writing custom geometry math is prone to edge-case bugs and takes huge amounts of time. This MCP handles the complex, standardized calculations for you through simple prompts, making your agent do the hard work. **Can Collision Detection Primitives MCP handle different types of shapes?** It specializes in core primitives: spheres, AABBs, rays, and planes. It's built for high-precision checks involving these foundational 3D geometry types.