Add support for negative vertex indices in OBJ loader

avinxshKD · avinxshKD · commit a948fd7c32c8 · 2026-02-08T23:32:13.000+05:30
diff --git a/src/webgl/loading.js b/src/webgl/loading.js
@@ -620,12 +620,10 @@ function parseObj(model, lines, materials= {}) {
             const vertString = tokens[vertexTokens[tokenInd]];
             let vertParts=vertString.split('/');
 
-            // TODO: Faces can technically use negative numbers to refer to the
-            // previous nth vertex. I haven't seen this used in practice, but
-            // it might be good to implement this in the future.
-
             for (let i = 0; i < vertParts.length; i++) {
-              vertParts[i] = parseInt(vertParts[i]) - 1;
+              let index=parseInt(vertParts[i]);
+              if (index > 0) index -= 1; // OBJ uses 1-based indexing
+              vertParts[i]=index;
             }
 
             if (!usedVerts[vertString]) {
@@ -634,19 +632,19 @@ function parseObj(model, lines, materials= {}) {
 
             if (usedVerts[vertString][currentMaterial] === undefined) {
               const vertIndex = model.vertices.length;
-              model.vertices.push(loadedVerts.v[vertParts[0]].copy());
-              model.uvs.push(loadedVerts.vt[vertParts[1]] ?
-                loadedVerts.vt[vertParts[1]].slice() : [0, 0]);
-              model.vertexNormals.push(loadedVerts.vn[vertParts[2]] ?
-                loadedVerts.vn[vertParts[2]].copy() : new p5.Vector());
+              model.vertices.push(loadedVerts.v.at(vertParts[0]).copy());
+              model.uvs.push(loadedVerts.vt.at(vertParts[1]) ?
+                loadedVerts.vt.at(vertParts[1]).slice() : [0, 0]);
+              model.vertexNormals.push(loadedVerts.vn.at(vertParts[2]) ?
+                loadedVerts.vn.at(vertParts[2]).copy() : new p5.Vector());
 
               usedVerts[vertString][currentMaterial] = vertIndex;
               face.push(vertIndex);
               if (currentMaterial
                 && materials[currentMaterial]
                 && materials[currentMaterial].diffuseColor) {
                 // Mark this vertex as colored
-                coloredVerts.add(loadedVerts.v[vertParts[0]]); //since a set would only push unique values
+                coloredVerts.add(loadedVerts.v.at(vertParts[0])); //since a set would only push unique values
               }
             } else {
               face.push(usedVerts[vertString][currentMaterial]);
diff --git a/test/unit/assets/cube-negative-indices.obj b/test/unit/assets/cube-negative-indices.obj
@@ -0,0 +1,20 @@
+# Cube using negative vertex indices
+# Negative indices count backwards: -1 = last vertex, -2 = second-to-last, etc.
+
+# Vertices
+v  0.0  0.0  0.0
+v  1.0  0.0  0.0
+v  1.0  1.0  0.0
+v  0.0  1.0  0.0
+v  0.0  0.0  1.0
+v  1.0  0.0  1.0
+v  1.0  1.0  1.0
+v  0.0  1.0  1.0
+
+# Faces using negative indices
+f  -8 -7 -6 -5
+f  -4 -3 -2 -1
+f  -8 -4 -1 -5
+f  -7 -3 -2 -6
+f  -5 -6 -2 -1
+f  -8 -7 -3 -4
diff --git a/test/unit/io/loadModel.js b/test/unit/io/loadModel.js
@@ -212,4 +212,34 @@ suite('loadModel', function() {
     });
     assert.instanceOf(model, p5.Geometry);
   });
+
+  test('OBJ with negative vertex indices loads correctly', async function() {
+    const model = await promisedSketch(function(sketch, resolve, reject) {
+      sketch.preload = function() {
+        sketch.loadModel('unit/assets/cube-negative-indices.obj', resolve, reject);
+      };
+    });
+    assert.instanceOf(model, p5.Geometry);
+    assert.isAbove(model.vertices.length, 0, 'Model should have vertices');
+    assert.isAbove(model.faces.length, 0, 'Model should have faces');
+  });
+
+  test('OBJ with negative indices produces same geometry as positive indices', async function() {
+    const [positiveModel, negativeModel] = await promisedSketch(function(sketch, resolve, reject) {
+      let positive, negative;
+      let loaded = 0;
+      function checkDone() {
+        loaded++;
+        if (loaded === 2) resolve([positive, negative]);
+      }
+      sketch.preload = function() {
+        sketch.loadModel('unit/assets/cube.obj', function(m) { positive = m; checkDone(); }, reject);
+        sketch.loadModel('unit/assets/cube-negative-indices.obj', function(m) { negative = m; checkDone(); }, reject);
+      };
+    });
+    assert.equal(positiveModel.vertices.length, negativeModel.vertices.length,
+      'Vertex count should match between positive and negative index OBJs');
+    assert.equal(positiveModel.faces.length, negativeModel.faces.length,
+      'Face count should match between positive and negative index OBJs');
+  });
 });
