Skip to content
TheChatArchiveThe Chat Archive
o3-2025-04-16· OpenAIHugging Face LMArena Human Preference 140K

If i wanted to render a mesh showing the possible movement zone what would be the best…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Mistralmistral-small-3.1-24b-instruct-2503’s answer.
  1. User

    If i wanted to render a mesh showing the possible movement zone what would be the best way?

  2. Assistant

    Below is a “menu” of practical ways Unity developers usually render a “where-can-I-move?” zone, starting with the quickest prototype and ending with a fully-accurate, polygon-perfect solution.
    Pick the one that best matches your time-budget and accuracy needs.


    🚀 1. Fastest prototype – “Projector / Decal”
    • Drop a circular Projector (or URP/HDRP Decal) on the ground that simply draws a translucent disc with radius = maxMoveDistance.
    • Pros: 5-minute setup, zero CPU.
    • Cons: Ignores walls, gaps, other units – it only shows a raw radius.

    Great for a first playable, not for final rules accuracy.


    🟡 2. Good enough for many games – “Sample-and-Triangulate”
    Idea: scatter points inside a circle, keep the ones that can actually be reached (NavMesh path ≤ distance), then triangulate them into a mesh.

    Step-by-step:

    Mesh BuildMoveZoneMesh(Vector3 origin, float maxDist, float sampleStep = 0.4f)
    {
        List<Vector3> pts = new List<Vector3>();
    
        // 1. Polar (or grid) sampling
        for (float x = -maxDist; x <= maxDist; x += sampleStep)
        for (float z = -maxDist; z <= maxDist; z += sampleStep)
        {
            Vector3 candidate = origin + new Vector3(x, 0, z);
            if ((candidate - origin).sqrMagnitude > maxDist * maxDist) continue;
    
            NavMeshPath p = new NavMeshPath();
            if (NavMesh.CalculatePath(origin, candidate, NavMesh.AllAreas, p) &&
                p.status == NavMeshPathStatus.PathComplete &&
                PathLength(p) <= maxDist)
            {
                pts.Add(candidate);
            }
        }
    
        // 2. 2D Delaunay / ear-clipping triangulation (any open-source Triangulator)
        int[] indices = Triangulate2D(pts);
    
        // 3. Push slightly down so it doesn’t Z-fight
        for (int i = 0; i < pts.Count; i++) pts[i].y -= 0.02f;
    
        Mesh m = new Mesh();
        m.SetVertices(pts);
        m.SetTriangles(indices, 0, true);
        m.RecalculateNormals();
        return m;
    }
    

    Render it with a transparent material (renderQueue 3000, additive or alpha-blend).

    Pros • Works with every agent size, obstacles, & NavMesh carving.
    • Implementation time ≈ 1–2 evenings.

    Cons • Quality = resolution you sample at (0.2 m grid ≈ 50×50 = 2500 path calls). Use a Job or throttle to 1-frame build.
    • Edges look “pixelled” unless you post-smooth outlines.


    🟢 3. Production grade – “BFS through NavMesh polygons”
    If you need a razor-sharp outline and minimal CPU, walk the NavMesh polygons directly instead of brute-force sampling.

    Concept

    1. Grab the baked NavMesh once:
      NavMeshTriangulation tri = NavMesh.CalculateTriangulation();
      This gives you all triangles (tri.vertices, tri.indices).

    2. Build an adjacency list (edge → neighboring triangle). One-time cost.

    3. When a unit is selected
      a. Find the triangle that contains the unit (PointInTriangle test).
      b. Run Dijkstra/BFS across triangles:
      • cost to enter neighbour = distance between the two triangles’ shared edge mid-points.
      • stop when cumulative cost > maxMoveDistance.
      c. Collect all triangles visited.

    4. Extract “border edges” (edges that belong to exactly one visited triangle).

    5. Chain the border edges into ordered loops, then feed the loop(s) into a simple mesh builder (fan triangulate or Ear-clip).

    6. Drop a transparent material on the mesh (plus XZ billboard outline FX if you like).

    Advantages • 100 × fewer path calculations → fast even on large maps.
    • Pixel-perfect outline – matches NavMesh obstacles and gaps exactly.
    • Only recalculated when something (unit position, carved obstacles) changes.

    Useful helpers • open-source “https://github.com/h8man/NavMeshBuilder” shows how to walk polygons.
    • Unity’s new “com.unity.ai.navigation” package exposes NavMeshQuery which already contains MoveAlongSurface and polygon iterators – perfect for step (3).


    🛠️ 4. Third-party pathfinding libraries
    Aron Granberg’s A* Pro or Recast/Detour (C implementation) already expose Constant-Cost or Flood queries that return “all nodes reachable within X cost.” You get boundary polygons almost for free.


    ✨ 5. Extra polish once you have a mesh
    • Fade-in/out with a shader or MaterialPropertyBlock alpha.
    • Use a gradient (closer = brighter) by encoding distance into vertex color.
    • Add a thin outline via post-process or by extruding border vertices upward and giving them a solid emissive color.


    Summary cheat-sheet

    MethodDev timeLooksCPU costObstacle aware?
    Projector⭐★★★🔋 Low❌
    Sample+Triang⭐⭐★★★★🔋 Mid✅
    NavMesh BFS⭐⭐⭐★★★★★🔋 Low✅
    3rd-party⭐⭐–⭐⭐⭐★★★★★🔋 Low✅

    If you’re shipping soon, go with #2 (sampling) – it’s robust and easy.
    If you can invest a bit more and want perfect tabletop fidelity, implement #3 or use a library that already does it. Good luck and have fun measuring those inches! 🧙‍♂️🎲

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.