Polygon mesh

For Microsoft's collaboration platform, see Microsoft Mesh.

A polygon mesh is a collection of vertices, edges and faces that together describe the surface of a 3D object in computer graphics. The faces are flat polygons, most often triangles, that share edges and vertices with their neighbours. In Hugues Hoppe's definition, a triangle mesh is "a piecewise linear surface consisting of triangular faces pasted together along their edges", described by its connectivity (which vertices, edges and faces are adjacent) and by the 3D positions of its vertices. Meshes often also carry appearance data such as colours, normals and texture coordinates, and Hoppe notes that models in computer graphics are often represented using triangle meshes.

In virtual reality (VR) and augmented reality (AR), meshes carry most rendered 3D content, so triangle counts are part of headset performance budgets. Meshes also describe the physical world to AR and mixed reality systems: Microsoft HoloLens, Apple's ARKit and Meta's scene APIs all give applications a triangle mesh of the user's surroundings, which applications use for occlusion, physics and placing virtual objects.

Reviewed 19 October 2026. Checked every cited paper (full text or abstract, plus Crossref DOI metadata) and every Microsoft, Apple, Meta, Unity, Epic, Khronos, OpenUSD, CGAL and Library of Congress documentation claim against the cited pages. About review dates.

Structure

A mesh has three kinds of element. Vertices are points in 3D space; edges are line segments joining two vertices; faces are polygons bounded by a closed loop of edges. File formats such as Wavefront OBJ and OpenUSD allow faces with more than three vertices, but many processing algorithms assume triangles. In their 1997 paper on mesh simplification, Michael Garland and Paul Heckbert note that assuming triangles "implies no loss of generality, since every polygon in the original model can be triangulated as part of a preprocessing phase". They also recommend that faces meeting at a point share a single vertex rather than two separate vertices that happen to be coincident in space.

Beyond geometry, a mesh can hold appearance attributes. Hoppe divides them into discrete attributes, usually attached to faces, such as a material identifier, and scalar attributes such as colour, normal and texture coordinates. Scalar attributes are often stored per corner (a vertex and face pair) rather than per vertex, so that a vertex on a sharp crease can have a different normal on each side.

Face orientation matters for rendering. The order in which a triangle's vertices are listed (its winding order) determines which side is the front, and renderers use it for back-face culling. Microsoft documents that HoloLens spatial mapping meshes use a front-clockwise winding order, with the front side matching the visible side of the real surface. The glTF 2.0 specification defines winding order as "the relative order in which vertices are defined within a triangle" and uses it to classify each triangle as front-facing or back-facing.

Data structures

Indexed face lists

The most common storage scheme keeps an array of vertex positions and, for each face, a list of indices into that array. Microsoft notes that the index and vertex data of a spatial mapping mesh use "the same familiar layout" as the vertex and index buffers "used for rendering triangle meshes in all modern rendering APIs", with each triangle given by three vertex indices. Pixar's OpenUSD stores a mesh as a points array, a flat faceVertexIndices list and a companion faceVertexCounts array giving the number of vertices in each face; its documentation states that "no additional connectivity information is required or constructed, so no adjacency or neighborhood queries are available".

Index size limits mesh size in some engines. Unity's Mesh.indexFormat documentation states that a 16-bit index buffer supports up to 65,535 vertices in a mesh and a 32-bit buffer up to 4 billion, that 16 bit is the default because it uses less memory and bandwidth, and that GPU support for 32-bit indices is not guaranteed on every platform (Android devices with a Mali-400 GPU do not support them).

Edge-based structures

An indexed list on its own does not record which faces and edges are adjacent; OpenUSD, for example, offers no adjacency queries on its meshes. Edge-based structures store this connectivity explicitly. Bruce G. Baumgart described the winged-edge polyhedron representation in Stanford Artificial Intelligence Laboratory memo AIM-179 (October 1972), together with a set of primitives that preserve Euler's F-E+V=2 relation. In his paper "A Polyhedron Representation for Computer Vision" for the 1975 National Computer Conference, each edge record points to its two faces and two vertices and to its four neighbouring edges clockwise and counterclockwise, which Baumgart called "the wings of the edge".

D. E. Muller and F. P. Preparata introduced the doubly connected edge list (DCEL) in a 1978 paper on intersecting convex polyhedra. Each edge node holds the edge's origin and terminus vertices, the faces to its left and right, and two pointers to the next edge counterclockwise around each endpoint, so that both the edges around a vertex and the edges around a face can be traversed. The halfedge data structure used by geometry libraries splits each edge into "two halfedges with opposite orientations"; each halfedge references the next halfedge and its opposite, and optionally its incident vertex and face. The CGAL manual by Lutz Kettner notes that the structure is also known as the FE-structure or DCEL (although the original DCEL reference describes a different structure) and that its variant is restricted to orientable 2-manifolds.

Creating meshes

Artists build meshes directly in 3D modeling software, or convert other surface types into them. Hoppe notes that models built from extrusion, constructive solid geometry and freeform deformation "must usually be tessellated into polygonal approximations" for efficient display, and that detailed meshes are also obtained by scanning physical objects with range scanners. E. Catmull and J. Clark's 1978 subdivision method works in the other direction: it generates smooth surfaces from a control mesh "of arbitrary topology", reproducing a standard B-spline surface for rectangular control meshes and differing from one only at a small number of extraordinary points. OpenUSD meshes are treated as Catmull-Clark subdivision surfaces by default, so a plain polygonal mesh has to be declared explicitly.

From volumes

William E. Lorensen and Harvey E. Cline of General Electric presented marching cubes at SIGGRAPH 1987, an algorithm that "creates triangle models of constant density surfaces from 3D medical data" such as CT, MR and SPECT scans. It examines one cube of eight neighbouring samples at a time; because each corner is either inside or outside the surface there are 2⁸ = 256 cases, which the authors reduced by symmetry to 14 patterns stored in a lookup table of triangle topologies.

From scans and point samples

3D scanning and photogrammetry produce depth maps or point clouds that must be turned into a surface. Hoppe and colleagues at the University of Washington described a 1992 algorithm that takes an unorganized set of points on or near an unknown surface and outputs a simplicial surface approximating it, inferring topology, boundaries and geometry from the data. Brian Curless and Marc Levoy's 1996 volumetric method merges aligned range images into a cumulative weighted signed distance function on a voxel grid and extracts the final surface as an isosurface; they reported models of up to 2.6 million triangles built from as many as 70 range images. Michael Kazhdan, Matthew Bolitho and Hoppe's Poisson surface reconstruction (2006) treats reconstruction from oriented points as a spatial Poisson problem: it computes an indicator function that is 1 inside the model and 0 outside, then extracts an isosurface.

The same volumetric idea moved into real time with KinectFusion, presented at the IEEE International Symposium on Mixed and Augmented Reality (ISMAR) in 2011. It fuses depth data from a moving Kinect into a volumetric truncated signed distance function using commodity GPU hardware. The authors list two ways to view such a model: extracting the surface with a marching cubes type algorithm and rasterising it, or raycasting the distance function directly; their system raycasts the function to predict the surface for tracking.

Simplification and level of detail

Scanned and modelled meshes often contain far more triangles than a renderer can afford. Mesh simplification replaces them with approximations that look nearly the same. Garland and Heckbert's quadric error metric algorithm (SIGGRAPH 1997) repeatedly contracts vertex pairs and tracks the accumulated geometric error at each vertex with a quadric matrix that needs 10 floating-point numbers per vertex. Because it can contract pairs that are not joined by an edge, it can merge unconnected parts of a model. The authors reported producing a 100-face approximation of a 70,000-face model in 15 seconds.

Hoppe's progressive mesh representation (SIGGRAPH 1996) stores a coarse base mesh followed by a sequence of vertex split records. Each vertex split is the inverse of an edge collapse, so applying them in order restores the original mesh exactly. The representation was designed for smooth geomorphs between level of detail approximations (avoiding visible "popping"), progressive transmission, compression and selective refinement. Mesh repair, smoothing, parameterization, remeshing and simplification are covered at textbook length in Polygon Mesh Processing by Mario Botsch, Leif Kobbelt, Mark Pauly, Pierre Alliez and Bruno Lévy (A K Peters/CRC Press, 2010).

Some engines now automate level of detail inside the renderer. Epic Games describes Nanite in Unreal Engine 5 as a virtualized geometry system with its own internal mesh format; on import, meshes are split into hierarchical clusters of triangle groups that are swapped at different levels of detail depending on the camera view. The Unreal Engine 5.8 documentation lists "Stereo rendering for Virtual Reality" among Nanite's unsupported rendering features.

File formats

Format	Mesh storage	Notes
Wavefront OBJ	Plain text: vertex positions (v), optional normals (vn) and texture coordinates (vt), and faces (f) built from them	First used by Wavefront Technologies around 1990; materials live in a separate MTL file; the specification also allows freeform curves and surfaces
glTF 2.0	Meshes are arrays of primitives; each primitive references accessors for vertex attributes (POSITION, NORMAL, TANGENT, TEXCOORD_n, COLOR_n, JOINTS_n, WEIGHTS_n) and optionally indices	Primitives "correspond to the data required for GPU draw calls"; topology modes include points, lines, triangles, triangle strips and triangle fans (triangles by default); supports morph targets and skinned meshes
OpenUSD (including USDZ)	Points array plus faceVertexIndices and faceVertexCounts	Encodes both subdivision surfaces and plain polygonal meshes; Catmull-Clark is the default subdivision scheme

Applications in VR and AR

Rendering budgets

Meta's device optimization guidance recommends fewer than 1.5 million triangles per frame and fewer than 200 draw calls on Meta Quest 3 (72 Hz target, 90 Hz recommended), and fewer than 750,000 triangles and 100 draw calls on Meta Quest 2 (72 Hz). Meta's Unity performance guide adds that triangle budgets "fluctuate based on frame-to-frame factors", and that on the headsets' tile-based GPUs a triangle's vertex shader runs three times per tile it covers, so triangles spanning several tiles cost more.

Meshes of the real world

Mixed reality devices reconstruct the user's room as a mesh through spatial mapping. On HoloLens, an application asks a spatial surface observer for data inside bounding volumes and receives spatial surfaces, each a triangle mesh attached to a world-locked coordinate system that appears, changes or disappears as the device learns more about the room. The Spatial Mapping API lets the application choose its level of detail through a "Triangles Per Cubic Meter" parameter, and Microsoft advises requesting the lowest triangle density that will do, since fewer triangles reduce memory use and vertex processing. The documentation describes placement, occlusion, physics, navigation and visualization as common usage scenarios. For occlusion, the room mesh is drawn in a depth-only pass so that holograms behind real surfaces are hidden; meshes used for physics often have few triangles, are watertight and are converted into convex hulls. Microsoft notes that these meshes are not as "clean" as artist-made topology and may need hole filling, removal of floating "hallucinations" left by reflections, bright lights and moving objects, or smoothing. The camera used for spatial mapping sees only 3.1 m in front of the user. On Microsoft HoloLens 2, a static version of the same mesh can also be queried through the Scene Understanding SDK.

Apple added scene reconstruction to ARKit in iOS and iPadOS 13.4. ARKit divides the reconstructed scene into ARMeshAnchor objects, "an anchor for a physical object that ARKit detects and recreates virtually using a polygonal mesh", and keeps refining them, although Apple notes that changes are not meant to appear in real time. Scene reconstruction requires a device with a LiDAR Scanner, such as the fourth-generation iPad Pro. In the ARMeshGeometry format, every three vertices form a triangular face with an outward normal and a classification. Apple's sample code shows the mesh classifying floors, tables, seats, windows and ceilings, flattening the mesh where plane detection finds a plane, letting raycasts hit nonplanar or featureless surfaces such as white walls, and occluding virtual content in RealityKit. On visionOS, the SceneReconstructionProvider supplies MeshAnchor objects, each "a volume of space that contains a mesh of a person's surroundings".

Meta's scene mesh is "a low-fidelity, high-coverage artifact which describes the boundary between free and occupied space" in a room, generated automatically during the headset's space setup. Meta's documentation lists it for Meta Quest 3, Meta Quest 3S and the announced Meta VR Glasses, and directs new projects to the Mixed Reality Utility Kit (MRUK) because the older scene actor is deprecated. Its Unity migration guide calls the scene mesh a triangle mesh whose use "comes at a high cost", to be used preferably "only for fast-paced short-lived physics contacts".

Captured objects and people

Photogrammetry tools output textured meshes sized for different uses. Apple's RealityKit Object Capture, which builds a 3D model from a set of photographs and writes a USDZ file, publishes the following triangle budgets for its detail levels; on iOS only the reduced level is supported.

Detail level	Triangles	Estimated file size
Preview	fewer than 25,000	about 5 MB
Reduced	fewer than 50,000	about 10 MB
Medium	fewer than 100,000	about 30 MB
Full	fewer than 250,000	about 100 MB
Raw	fewer than 30 million	Varies

Apple states that raw models are not suitable for use in an AR scene and are meant for export to 3D software.

Face tracking also uses meshes. ARKit's ARFaceGeometry is "a 3D mesh describing face topology" that conforms to the detected face's dimensions, shape and current expression; Apple suggests it for effects such as virtual makeup and as occlusion geometry that hides virtual content behind the user's face. In research on photoreal avatars, Stephen Lombardi, Jason Saragih, Tomas Simon and Yaser Sheikh's deep appearance model (SIGGRAPH 2018) learns a face's vertex positions together with view-specific textures with a variational autoencoder, and the authors describe the system as suited to real-time interactive settings such as VR.

Other representations

Meshes are not the only way to describe 3D content. Point clouds and voxels are common in capture and mapping, and Neural Radiance Fields and Gaussian splatting represent captured scenes without explicit surfaces. Bernhard Kerbl and colleagues' 3D Gaussian splatting (ACM Transactions on Graphics, 2023) represents a scene captured in multiple photos or videos with 3D Gaussians and renders them directly with a visibility-aware splatting algorithm, reaching real-time rates (30 frames per second or more) at 1080p.

See also

• 3D Modeling
• Level of detail
• Spatial mapping
• Scene understanding
• Photogrammetry
• 3D scanning
• Point cloud
• Voxel
• Graphics pipeline
• Draw call
• Back-face culling
• Rendering
• FBX