Concave Trigger & Collider Generator

About Concave Trigger & Collider Generator – Unity Editor Tool & Plugin

Concave Trigger & Collider Generator Unity Asset Overview

If you have worked with Unity's physics system for any length of time, you have likely hit the classic PhysX brick wall: MeshCollider instances marked as isTrigger = true must be set to convex. Unity simply will not allow non-convex concave mesh triggers out of the box. In my experience building complex level geometry—such as winding arched tunnels, hollowed-out tree trunks, torus-shaped portals, or multi-level cave networks—this limitation forces developers into a painful choice: spend hours manually positioning dozens of primitive BoxCollider or CapsuleCollider sub-objects, or sacrifice trigger detection accuracy.

The Concave Trigger & Collider Generator addresses this bottleneck directly. High-level, this tool acts as an automated convex decomposition pipeline integrated directly inside the Unity Editor. It takes any arbitrary 3D mesh, analyzes its topology, and decomposes the concave volume into a compound collection of optimized convex sub-colliders. It then binds these sub-colliders under a unified parent manager component that forwards PhysX events. Here is the key takeaway: it gives you pixel-precise trigger volumes for complex shapes without manual placement work or custom native C++ physics plugins.

Core Technical Features & Highlights

Architecturally, this tool focuses on editor-time baking, ensuring that your runtime performance remains lean and efficient. Below are the key technical features built into the tool:

• Volumetric Decomposition Algorithm: Uses a tailored implementation of volumetric hierarchical approximate convex decomposition (V-HACD style processing) to calculate accurate sub-hulls without deep manual geometry tweaking.
• Compound Event Forwarding Engine: Automatically attaches child proxy components to each generated convex hull and aggregates OnTriggerEnter, OnTriggerStay, and OnTriggerExit callbacks back to a root ConcaveTriggerReceiver component.
• Zero-Allocation Runtime Footprint: All mesh splitting and hull creation happen inside the Unity Editor. The generated asset produces raw Mesh resources and standard Unity primitive components, adding zero engine overhead at runtime.
• Editor UI & Visualizers: Features custom editor handles that allow real-time wireframe visual feedback, parameter tuning for hull counts, and resolution previewing right inside the Scene view.
• Multi-Pipeline Compatibility: Fully pipeline-agnostic. Because it deals strictly with PhysX collision representation rather than rendering shaders, it works natively across the Built-in Render Pipeline, URP, and HDRP without modification.

Ideal Use Cases & Game Genres

Honestly, while simple games can get away with basic box colliders, certain game types rely heavily on accurate trigger collision for core gameplay loops:

Mobile Racing & Flight Simulators

Setting up curved checkpoints, hollow boost hoops, or floating ring gates usually requires meticulous collider work. With this tool, you can convert a complex 3D ring mesh into a tight, hollow trigger area in seconds, guaranteeing that players only trigger a pass when flying *through* the ring rather than clipping its outer bounding box.

Indie RPGs & Open-World Explorers

For complex environmental features like winding cavern tunnels, arched stone bridges, or hollowed-out ruins, this tool creates exact environmental trigger boundaries. You can use these compound triggers to activate localized ambient audio zones, occlusion culling portals, or dynamic weather volumes seamlessly.

Physics Sandboxes & VR Interactions

Virtual reality interaction demands high spatial accuracy. If a player sticks their virtual hand into a hollow mechanical gear or a bowl-shaped object, standard convex triggers register a hit long before the hand enters the interior volume. Generating concave triggers ensures hand and tool interactions feel intuitive and physically consistent.

Quick-Start Unity Setup & Integration Guide

Integrating the tool into your workflow takes less than five minutes. Here is the standard setup process I follow when configuring static environmental triggers:

1. Target Mesh Setup

Select your target GameObject in the hierarchy containing the complex mesh filter (e.g., a curved stone archway). Ensure the mesh asset has Read/Write Enabled checked in its Model Import Settings if you plan on generating hulls from non-exported runtime geometry.

2. Generating the Sub-Colliders

Attach the ConcaveColliderGenerator script to your object via the Inspector. Adjust the Hull Resolution slider (a value between 10 and 20 works well for standard level props) and click Generate Compound Trigger. The script will instantiate child objects containing individual convex MeshCollider components set to trigger mode.

3. Listening to Combined Trigger Events

To capture trigger events from the aggregate sub-colliders, create a C# script and attach it to the parent GameObject alongside the generator script. Use the following implementation pattern:

using UnityEngine;

[RequireComponent(typeof(ConcaveTriggerReceiver))]
public class EnvironmentalZoneDetector : MonoBehaviour
{
    private ConcaveTriggerReceiver triggerReceiver;

    private void Awake()
    {
        // Cache reference to the event aggregator component
        triggerReceiver = GetComponent<ConcaveTriggerReceiver>();
    }

    private void OnEnable()
    {
        // Subscribe to trigger callbacks
        if (triggerReceiver != null)
        {
            triggerReceiver.OnEntityEntered += HandleEntityEntered;
            triggerReceiver.OnEntityExited += HandleEntityExited;
        }
    }

    private void OnDisable()
    {
        // Unsubscribe to prevent memory leaks
        if (triggerReceiver != null)
        {
            triggerReceiver.OnEntityEntered -= HandleEntityEntered;
            triggerReceiver.OnEntityExited -= HandleEntityExited;
        }
    }

    private void HandleEntityEntered(Collider targetCollider)
    {
        if (targetCollider.CompareTag("Player"))
        {
            Debug.Log($"[Physics Alert]: Player entered concave zone: {gameObject.name}");
        }
    }

    private void HandleEntityExited(Collider targetCollider)
    {
        if (targetCollider.CompareTag("Player"))
        {
            Debug.Log($"[Physics Alert]: Player exited concave zone: {gameObject.name}");
        }
    }
}

Pros & Cons Assessment

Here is my honest developer evaluation of where this tool excels and where you need to exercise caution:

• Pros:
  • Massive Time Saver: Replaces hours of manual primitive box stitching with a single inspector click.
  • Accurate Physics Bounds: Generates tight concave fits that prevent false-positive trigger fires.
  • Editor-Baked Efficiency: Zero dynamic runtime generation costs, making it very performant for static geometry.
  • Clean Architecture: Automatically manages child event bubbling, saving you from writing custom child trigger listener boilerplate.
• Cons:
  • PhysX Broadphase Overhead: Over-decomposing a mesh into dozens of tiny convex hulls can increase PhysX broadphase collision pair checks. Always keep hull count as low as reasonably possible.
  • Requires Read/Write Mesh Access: Source meshes must have Read/Write enabled during editor baking, which can temporarily increase memory during import step.

Developers Who Downloaded This Also Downloaded

Related Unity Tools Assets