User Rating 0.0 ★★★★★

Total Usage 0 times

Category File Converters

Drop .obj file here or click to browse Supports vertices, normals, texcoords & faces

Output Mode

Float Precision

Pretty Print

JSON Output

Is this tool helpful?

Your feedback helps us improve.

★ ★ ★ ★ ★

About

Wavefront OBJ is a plain-text geometry format dating to the 1980s. Its simplicity makes it ubiquitous but its lack of native browser support creates friction in WebGL pipelines. Manually parsing vertex positions (v), texture coordinates (vt), and face index triplets (f) is error-prone. Mismatched index bases (OBJ uses 1-based indexing; WebGL expects 0-based) cause silent rendering failures: missing triangles, inverted normals, black textures. This converter parses OBJ files client-side with correct index rebasing, fan triangulation of n-gon faces, and outputs a structured JSON object ready for gl.bufferData(). No server upload required. The tool approximates the OBJ specification for polygonal geometry; it does not handle free-form curves, material libraries (.mtl), or group hierarchies.

Formulas

OBJ face indices are 1-based. WebGL and most JSON consumers expect 0-based indexing. The rebasing operation for each index i is:

i_json = i_obj − 1

For negative indices (relative references from end of current list of length n):

i_json = n + i_obj

N-gon faces with k vertices (where k > 3) are triangulated via fan decomposition, producing k − 2 triangles. For vertices [v₀, v₁, …, v_k−1], triangle j is:

T_j = (v₀, v_j+1, v_j+2) for j = 0, …, k − 3

Where v₀ is the pivot vertex, k is the face vertex count, and T_j represents the j-th output triangle.

Reference Data

OBJ Prefix	Data Type	Components	JSON Key	Example Line
`v`	Vertex Position	x, y, z	`vertices`	`v 1.0 2.0 3.0`
`vt`	Texture Coordinate	u, v	`texcoords`	`vt 0.5 0.8`
`vn`	Vertex Normal	x, y, z	`normals`	`vn 0.0 1.0 0.0`
`f`	Face (tri/quad/n-gon)	v/vt/vn indices	`faces`	`f 1/1/1 2/2/1 3/3/1`
`f`	Face (pos only)	v indices	`faces`	`f 1 2 3`
`f`	Face (pos+normal)	v//vn indices	`faces`	`f 1//1 2//1 3//1`
`f`	Face (pos+tex)	v/vt indices	`faces`	`f 1/1 2/2 3/3`
`#`	Comment	-	Ignored	`# cube mesh`
`o`	Object Name	string	`name`	`o MyCube`
`g`	Group Name	string	Ignored	`g front`
`s`	Smooth Shading	on/off/int	Ignored	`s 1`
`mtllib`	Material Library	filename	Ignored	`mtllib cube.mtl`
`usemtl`	Material Usage	name	Ignored	`usemtl wood`

Frequently Asked Questions

Faces with more than 3 vertices are decomposed into triangles using fan triangulation. A quad (4 vertices) produces 2 triangles; a pentagon produces 3. The first vertex of the face serves as the pivot. This method is correct for convex faces but may produce incorrect geometry for concave polygons. Most modeling software exports convex faces by default.

OBJ supports negative indices as relative references. An index of -1 refers to the last defined vertex, -2 to the second-to-last, and so on. The converter resolves these by adding the negative index to the current count of the respective element type (vertices, normals, or texture coordinates), then converts to 0-based indexing.

The converter offers two output modes. "Indexed" mode preserves separate arrays for vertices, normals, texcoords, and face indices - useful for gl.drawElements(). "Flat" mode de-indexes the data into interleaved per-vertex arrays where each triangle vertex has its own position, normal, and texcoord - ready for gl.drawArrays() without an index buffer. Choose based on your rendering pipeline.

Material libraries require loading external .mtl files and resolving texture image paths, which exceeds the scope of geometry conversion. Group and object names are informational metadata. The converter captures the first object name ('o' directive) in the JSON output but does not split geometry by group. For multi-object files, all geometry merges into a single mesh.

Parsing runs in a Web Worker to avoid blocking the UI. Files up to approximately 100 MB can be processed depending on available browser memory. The parser uses line-by-line streaming rather than loading the entire file into a single string, which reduces peak memory usage. A progress indicator shows parsing advancement for files exceeding 1 MB.

Each line is validated against expected component counts: "v" must have 3 floats, "vt" must have at least 2, "vn" must have 3, and "f" must have at least 3 vertex references. Lines that fail validation are counted and reported in the conversion summary. Face indices referencing out-of-range vertices are flagged as errors. The converter continues processing valid lines rather than aborting on the first error.