@loaders.gl/terrain 4.0.0-alpha.1 → 4.0.0-alpha.11

package/dist/terrain-worker.js

@@ -35,16 +35,33 @@
   }
 
   // ../worker-utils/src/lib/worker-farm/worker-body.ts
+  function getParentPort() {
+    let parentPort;
+    try {
+      eval("globalThis.parentPort = require('worker_threads').parentPort");
+      parentPort = globalThis.parentPort;
+    } catch {
+    }
+    return parentPort;
+  }
   var onMessageWrapperMap = new Map();
   var WorkerBody = class {
+    static inWorkerThread() {
+      return typeof self !== "undefined" || Boolean(getParentPort());
+    }
     static set onmessage(onMessage) {
-      self.onmessage = (message) => {
-        if (!isKnownMessage(message)) {
-          return;
-        }
-        const { type, payload } = message.data;
+      function handleMessage(message) {
+        const parentPort3 = getParentPort();
+        const { type, payload } = parentPort3 ? message : message.data;
         onMessage(type, payload);
-      };
+      }
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.on("message", handleMessage);
+        parentPort2.on("exit", () => console.debug("Node worker closing"));
+      } else {
+        globalThis.onmessage = handleMessage;
+      }
     }
     static addEventListener(onMessage) {
       let onMessageWrapper = onMessageWrapperMap.get(onMessage);
@@ -53,22 +70,36 @@
           if (!isKnownMessage(message)) {
             return;
           }
-          const { type, payload } = message.data;
+          const parentPort3 = getParentPort();
+          const { type, payload } = parentPort3 ? message : message.data;
           onMessage(type, payload);
         };
       }
-      self.addEventListener("message", onMessageWrapper);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.addEventListener("message", onMessageWrapper);
+      }
     }
     static removeEventListener(onMessage) {
       const onMessageWrapper = onMessageWrapperMap.get(onMessage);
       onMessageWrapperMap.delete(onMessage);
-      self.removeEventListener("message", onMessageWrapper);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        console.error("not implemented");
+      } else {
+        globalThis.removeEventListener("message", onMessageWrapper);
+      }
     }
     static postMessage(type, payload) {
-      if (self) {
-        const data = { source: "loaders.gl", type, payload };
-        const transferList = getTransferList(payload);
-        self.postMessage(data, transferList);
+      const data = { source: "loaders.gl", type, payload };
+      const transferList = getTransferList(payload);
+      const parentPort2 = getParentPort();
+      if (parentPort2) {
+        parentPort2.postMessage(data, transferList);
+      } else {
+        globalThis.postMessage(data, transferList);
       }
     }
   };
@@ -80,19 +111,20 @@
   // ../loader-utils/src/lib/worker-loader-utils/create-loader-worker.ts
   var requestId = 0;
   function createLoaderWorker(loader) {
-    if (typeof self === "undefined") {
+    if (!WorkerBody.inWorkerThread()) {
       return;
     }
     WorkerBody.onmessage = async (type, payload) => {
       switch (type) {
         case "process":
           try {
-            const { input, options = {} } = payload;
+            const { input, options = {}, context = {} } = payload;
             const result = await parseData({
               loader,
               arrayBuffer: input,
               options,
               context: {
+                ...context,
                 parse: parseOnMainThread
               }
             });
@@ -168,7 +200,7 @@
     return result;
   }
 
-  // ../schema/src/category/mesh/mesh-utils.ts
+  // ../schema/src/lib/mesh/mesh-utils.ts
   function getMeshBoundingBox(attributes) {
     let minX = Infinity;
     let minY = Infinity;
@@ -434,12 +466,12 @@
     }
     edges.sort((a, b) => Math.min(...a) - Math.min(...b) || Math.max(...a) - Math.max(...b));
     const outsideEdges = [];
-    let index = 1;
+    let index = 0;
     while (index < edges.length) {
-      if (edges[index][0] === edges[index - 1][1] && edges[index][1] === edges[index - 1][0]) {
+      if (edges[index][0] === edges[index + 1]?.[1] && edges[index][1] === edges[index + 1]?.[0]) {
         index += 2;
       } else {
-        outsideEdges.push(edges[index - 1]);
+        outsideEdges.push(edges[index]);
         index++;
       }
     }
@@ -479,42 +511,15 @@
     newTexcoord0.set(attributes.TEXCOORD_0.value.subarray(edge[1] * 2, edge[1] * 2 + 2), vertex2Offset * 2);
     const triangle1Offset = edgeIndex * 2 * 3;
     newTriangles[triangle1Offset] = edge[0];
-    newTriangles[triangle1Offset + 1] = edge[1];
-    newTriangles[triangle1Offset + 2] = positionsLength / 3 + vertex2Offset;
+    newTriangles[triangle1Offset + 1] = positionsLength / 3 + vertex2Offset;
+    newTriangles[triangle1Offset + 2] = edge[1];
     newTriangles[triangle1Offset + 3] = positionsLength / 3 + vertex2Offset;
-    newTriangles[triangle1Offset + 4] = positionsLength / 3 + vertex1Offset;
-    newTriangles[triangle1Offset + 5] = edge[0];
+    newTriangles[triangle1Offset + 4] = edge[0];
+    newTriangles[triangle1Offset + 5] = positionsLength / 3 + vertex1Offset;
   }
 
   // src/lib/parse-quantized-mesh.ts
-  function getMeshAttributes(vertexData, header, bounds) {
-    const { minHeight, maxHeight } = header;
-    const [minX, minY, maxX, maxY] = bounds || [0, 0, 1, 1];
-    const xScale = maxX - minX;
-    const yScale = maxY - minY;
-    const zScale = maxHeight - minHeight;
-    const nCoords = vertexData.length / 3;
-    const positions = new Float32Array(nCoords * 3);
-    const texCoords = new Float32Array(nCoords * 2);
-    for (let i = 0; i < nCoords; i++) {
-      const x = vertexData[i] / 32767;
-      const y = vertexData[i + nCoords] / 32767;
-      const z = vertexData[i + nCoords * 2] / 32767;
-      positions[3 * i + 0] = x * xScale + minX;
-      positions[3 * i + 1] = y * yScale + minY;
-      positions[3 * i + 2] = z * zScale + minHeight;
-      texCoords[2 * i + 0] = x;
-      texCoords[2 * i + 1] = y;
-    }
-    return {
-      POSITION: { value: positions, size: 3 },
-      TEXCOORD_0: { value: texCoords, size: 2 }
-    };
-  }
-  function getTileMesh(arrayBuffer, options) {
-    if (!arrayBuffer) {
-      return null;
-    }
+  function parseQuantizedMesh(arrayBuffer, options = {}) {
     const { bounds } = options;
     const {
       header,
@@ -528,7 +533,7 @@
     let triangleIndices = originalTriangleIndices;
     let attributes = getMeshAttributes(vertexData, header, bounds);
     const boundingBox = getMeshBoundingBox(attributes);
-    if (options.skirtHeight) {
+    if (options?.skirtHeight) {
       const { attributes: newAttributes, triangles: newTriangles } = addSkirt(attributes, triangleIndices, options.skirtHeight, {
         westIndices,
         northIndices,
@@ -546,13 +551,36 @@
         vertexCount: triangleIndices.length,
         boundingBox
       },
+      schema: void 0,
+      topology: "triangle-list",
       mode: 4,
       indices: { value: triangleIndices, size: 1 },
       attributes
     };
   }
-  function loadQuantizedMesh(arrayBuffer, options) {
-    return getTileMesh(arrayBuffer, options["quantized-mesh"]);
+  function getMeshAttributes(vertexData, header, bounds) {
+    const { minHeight, maxHeight } = header;
+    const [minX, minY, maxX, maxY] = bounds || [0, 0, 1, 1];
+    const xScale = maxX - minX;
+    const yScale = maxY - minY;
+    const zScale = maxHeight - minHeight;
+    const nCoords = vertexData.length / 3;
+    const positions = new Float32Array(nCoords * 3);
+    const texCoords = new Float32Array(nCoords * 2);
+    for (let i = 0; i < nCoords; i++) {
+      const x = vertexData[i] / 32767;
+      const y = vertexData[i + nCoords] / 32767;
+      const z = vertexData[i + nCoords * 2] / 32767;
+      positions[3 * i + 0] = x * xScale + minX;
+      positions[3 * i + 1] = y * yScale + minY;
+      positions[3 * i + 2] = z * zScale + minHeight;
+      texCoords[2 * i + 0] = x;
+      texCoords[2 * i + 1] = y;
+    }
+    return {
+      POSITION: { value: positions, size: 3 },
+      TEXCOORD_0: { value: texCoords, size: 2 }
+    };
   }
 
   // ../../node_modules/@mapbox/martini/index.js
@@ -688,7 +716,7 @@
     }
   };
 
-  // src/lib/delatin/index.js
+  // src/lib/delatin/index.ts
   var Delatin = class {
     constructor(data, width, height = width) {
       this.data = data;
@@ -1042,55 +1070,7 @@
   }
 
   // src/lib/parse-terrain.ts
-  function getTerrain(imageData, width, height, elevationDecoder, tesselator) {
-    const { rScaler, bScaler, gScaler, offset } = elevationDecoder;
-    const terrain = new Float32Array((width + 1) * (height + 1));
-    for (let i = 0, y = 0; y < height; y++) {
-      for (let x = 0; x < width; x++, i++) {
-        const k = i * 4;
-        const r = imageData[k + 0];
-        const g = imageData[k + 1];
-        const b = imageData[k + 2];
-        terrain[i + y] = r * rScaler + g * gScaler + b * bScaler + offset;
-      }
-    }
-    if (tesselator === "martini") {
-      for (let i = (width + 1) * width, x = 0; x < width; x++, i++) {
-        terrain[i] = terrain[i - width - 1];
-      }
-      for (let i = height, y = 0; y < height + 1; y++, i += height + 1) {
-        terrain[i] = terrain[i - 1];
-      }
-    }
-    return terrain;
-  }
-  function getMeshAttributes2(vertices, terrain, width, height, bounds) {
-    const gridSize = width + 1;
-    const numOfVerticies = vertices.length / 2;
-    const positions = new Float32Array(numOfVerticies * 3);
-    const texCoords = new Float32Array(numOfVerticies * 2);
-    const [minX, minY, maxX, maxY] = bounds || [0, 0, width, height];
-    const xScale = (maxX - minX) / width;
-    const yScale = (maxY - minY) / height;
-    for (let i = 0; i < numOfVerticies; i++) {
-      const x = vertices[i * 2];
-      const y = vertices[i * 2 + 1];
-      const pixelIdx = y * gridSize + x;
-      positions[3 * i + 0] = x * xScale + minX;
-      positions[3 * i + 1] = -y * yScale + maxY;
-      positions[3 * i + 2] = terrain[pixelIdx];
-      texCoords[2 * i + 0] = x / width;
-      texCoords[2 * i + 1] = y / height;
-    }
-    return {
-      POSITION: { value: positions, size: 3 },
-      TEXCOORD_0: { value: texCoords, size: 2 }
-    };
-  }
-  function getMesh(terrainImage, terrainOptions) {
-    if (terrainImage === null) {
-      return null;
-    }
+  function makeTerrainMeshFromImage(terrainImage, terrainOptions) {
     const { meshMaxError, bounds, elevationDecoder } = terrainOptions;
     const { data, width, height } = terrainImage;
     let terrain;
@@ -1150,15 +1130,54 @@
     const vertices = coords;
     return { vertices, triangles };
   }
-  async function loadTerrain(arrayBuffer, options, context) {
-    options.image = options.image || {};
-    options.image.type = "data";
-    const image = await context.parse(arrayBuffer, options, options.baseUri);
-    return getMesh(image, options.terrain);
+  function getTerrain(imageData, width, height, elevationDecoder, tesselator) {
+    const { rScaler, bScaler, gScaler, offset } = elevationDecoder;
+    const terrain = new Float32Array((width + 1) * (height + 1));
+    for (let i = 0, y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++, i++) {
+        const k = i * 4;
+        const r = imageData[k + 0];
+        const g = imageData[k + 1];
+        const b = imageData[k + 2];
+        terrain[i + y] = r * rScaler + g * gScaler + b * bScaler + offset;
+      }
+    }
+    if (tesselator === "martini") {
+      for (let i = (width + 1) * width, x = 0; x < width; x++, i++) {
+        terrain[i] = terrain[i - width - 1];
+      }
+      for (let i = height, y = 0; y < height + 1; y++, i += height + 1) {
+        terrain[i] = terrain[i - 1];
+      }
+    }
+    return terrain;
+  }
+  function getMeshAttributes2(vertices, terrain, width, height, bounds) {
+    const gridSize = width + 1;
+    const numOfVerticies = vertices.length / 2;
+    const positions = new Float32Array(numOfVerticies * 3);
+    const texCoords = new Float32Array(numOfVerticies * 2);
+    const [minX, minY, maxX, maxY] = bounds || [0, 0, width, height];
+    const xScale = (maxX - minX) / width;
+    const yScale = (maxY - minY) / height;
+    for (let i = 0; i < numOfVerticies; i++) {
+      const x = vertices[i * 2];
+      const y = vertices[i * 2 + 1];
+      const pixelIdx = y * gridSize + x;
+      positions[3 * i + 0] = x * xScale + minX;
+      positions[3 * i + 1] = -y * yScale + maxY;
+      positions[3 * i + 2] = terrain[pixelIdx];
+      texCoords[2 * i + 0] = x / width;
+      texCoords[2 * i + 1] = y / height;
+    }
+    return {
+      POSITION: { value: positions, size: 3 },
+      TEXCOORD_0: { value: texCoords, size: 2 }
+    };
   }
 
-  // src/lib/utils/version.js
-  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  // src/lib/utils/version.ts
+  var VERSION = true ? "4.0.0-alpha.11" : "latest";
 
   // src/terrain-loader.ts
   var TerrainLoader = {
@@ -1167,12 +1186,12 @@
     module: "terrain",
     version: VERSION,
     worker: true,
-    extensions: ["png", "pngraw"],
-    mimeTypes: ["image/png"],
+    extensions: ["png", "pngraw", "jpg", "jpeg", "gif", "webp", "bmp"],
+    mimeTypes: ["image/png", "image/jpeg", "image/gif", "image/webp", "image/bmp"],
     options: {
       terrain: {
         tesselator: "auto",
-        bounds: null,
+        bounds: void 0,
         meshMaxError: 10,
         elevationDecoder: {
           rScaler: 1,
@@ -1180,7 +1199,7 @@
           bScaler: 0,
           offset: 0
         },
-        skirtHeight: null
+        skirtHeight: void 0
       }
     }
   };
@@ -1205,14 +1224,24 @@
   // src/index.ts
   var TerrainLoader2 = {
     ...TerrainLoader,
-    parse: loadTerrain
+    parse: parseTerrain
   };
+  async function parseTerrain(arrayBuffer, options, context) {
+    const loadImageOptions = {
+      ...options,
+      mimeType: "application/x.image",
+      image: { ...options?.image, type: "data" }
+    };
+    const image = await context?.parse(arrayBuffer, loadImageOptions);
+    const terrainOptions = { ...TerrainLoader2.options.terrain, ...options?.terrain };
+    return makeTerrainMeshFromImage(image, terrainOptions);
+  }
   var QuantizedMeshLoader2 = {
     ...QuantizedMeshLoader,
-    parseSync: loadQuantizedMesh,
-    parse: async (arrayBuffer, options) => loadQuantizedMesh(arrayBuffer, options)
+    parseSync: (arrayBuffer, options) => parseQuantizedMesh(arrayBuffer, options?.["quantized-mesh"]),
+    parse: async (arrayBuffer, options) => parseQuantizedMesh(arrayBuffer, options?.["quantized-mesh"])
   };
 
-  // src/workers/terrain-worker.js
+  // src/workers/terrain-worker.ts
   createLoaderWorker(TerrainLoader2);
 })();

package/dist/workers/quantized-mesh-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=quantized-mesh-worker.d.ts.map

package/dist/workers/quantized-mesh-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantized-mesh-worker.d.ts","sourceRoot":"","sources":["../../src/workers/quantized-mesh-worker.ts"],"names":[],"mappings":""}

package/dist/workers/quantized-mesh-worker.js

@@ -1,4 +1,5 @@
-import { createLoaderWorker } from '@loaders.gl/loader-utils';
-import { QuantizedMeshLoader } from '../index';
-createLoaderWorker(QuantizedMeshLoader);
-//# sourceMappingURL=quantized-mesh-worker.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const index_1 = require("../index");
+(0, loader_utils_1.createLoaderWorker)(index_1.QuantizedMeshLoader);

package/dist/workers/terrain-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=terrain-worker.d.ts.map

package/dist/workers/terrain-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain-worker.d.ts","sourceRoot":"","sources":["../../src/workers/terrain-worker.ts"],"names":[],"mappings":""}

package/dist/workers/terrain-worker.js

@@ -1,4 +1,5 @@
-import { createLoaderWorker } from '@loaders.gl/loader-utils';
-import { TerrainLoader } from '../index';
-createLoaderWorker(TerrainLoader);
-//# sourceMappingURL=terrain-worker.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const index_1 = require("../index");
+(0, loader_utils_1.createLoaderWorker)(index_1.TerrainLoader);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/terrain",
-  "version": "4.0.0-alpha.1",
+  "version": "4.0.0-alpha.11",
   "description": "Framework-independent loader for terrain raster formats",
   "license": "MIT",
   "publishConfig": {
@@ -18,9 +18,9 @@
     "point cloud",
     "OBJ"
   ],
-  "types": "src/index.ts",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "main": "dist/es5/index.js",
+  "module": "dist/esm/index.js",
   "sideEffects": false,
   "files": [
     "src",
@@ -29,15 +29,16 @@
   ],
   "scripts": {
     "pre-build": "npm run build-worker && npm run build-worker2 && npm run build-bundle",
-    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/bundle.js",
-    "build-worker": "esbuild src/workers/terrain-worker.js --bundle --outfile=dist/terrain-worker.js",
-    "build-worker2": "esbuild src/workers/quantized-mesh-worker.js --bundle --outfile=dist/quantized-mesh-worker.js"
+    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js",
+    "build-worker": "esbuild src/workers/terrain-worker.ts --bundle --outfile=dist/terrain-worker.js --define:__VERSION__=\\\"$npm_package_version\\\"",
+    "build-worker2": "esbuild src/workers/quantized-mesh-worker.ts --bundle --outfile=dist/quantized-mesh-worker.js --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
     "@babel/runtime": "^7.3.1",
-    "@loaders.gl/loader-utils": "4.0.0-alpha.1",
-    "@loaders.gl/schema": "4.0.0-alpha.1",
+    "@loaders.gl/images": "4.0.0-alpha.11",
+    "@loaders.gl/loader-utils": "4.0.0-alpha.11",
+    "@loaders.gl/schema": "4.0.0-alpha.11",
     "@mapbox/martini": "^0.2.0"
   },
-  "gitHead": "e48f5534fe7188c810f23f965a440c144b3cf6d0"
+  "gitHead": "bc680098cfea790c67b7fb95bab96e8d9288d34f"
 }

package/src/index.ts

@@ -1,20 +1,37 @@
-import type {LoaderWithParser} from '@loaders.gl/loader-utils';
-import parseQuantizedMesh from './lib/parse-quantized-mesh';
-import loadTerrain from './lib/parse-terrain';
+import type {LoaderContext, LoaderWithParser} from '@loaders.gl/loader-utils';
+import {parseQuantizedMesh} from './lib/parse-quantized-mesh';
+import {TerrainOptions, makeTerrainMeshFromImage} from './lib/parse-terrain';
 
-import {TerrainLoader as TerrainWorkerLoader} from './terrain-loader';
-import {QuantizedMeshLoader as QuantizedMeshWorkerLoader} from './quantized-mesh-loader';
+import {TerrainLoader as TerrainWorkerLoader, TerrainLoaderOptions} from './terrain-loader';
+import {
+  QuantizedMeshLoader as QuantizedMeshWorkerLoader,
+  QuantizedMeshLoaderOptions
+} from './quantized-mesh-loader';
 
 // TerrainLoader
 
 export {TerrainWorkerLoader};
 
-export const TerrainLoader = {
+export const TerrainLoader: LoaderWithParser<any, never, TerrainLoaderOptions> = {
   ...TerrainWorkerLoader,
-  parse: loadTerrain
+  parse: parseTerrain
 };
 
-export const _typecheckTerrainLoader: LoaderWithParser = TerrainLoader; // eslint-disable-line
+export async function parseTerrain(
+  arrayBuffer: ArrayBuffer,
+  options?: TerrainLoaderOptions,
+  context?: LoaderContext
+) {
+  const loadImageOptions = {
+    ...options,
+    mimeType: 'application/x.image',
+    image: {...options?.image, type: 'data'}
+  };
+  const image = await context?.parse(arrayBuffer, loadImageOptions);
+  // Extend function to support additional mesh generation options (square grid or delatin)
+  const terrainOptions = {...TerrainLoader.options.terrain, ...options?.terrain} as TerrainOptions;
+  return makeTerrainMeshFromImage(image, terrainOptions);
+}
 
 // QuantizedMeshLoader
 
@@ -23,10 +40,9 @@ export {QuantizedMeshWorkerLoader};
 /**
  * Loader for quantized meshes
  */
-export const QuantizedMeshLoader = {
+export const QuantizedMeshLoader: LoaderWithParser<any, never, QuantizedMeshLoaderOptions> = {
   ...QuantizedMeshWorkerLoader,
-  parseSync: parseQuantizedMesh,
-  parse: async (arrayBuffer, options) => parseQuantizedMesh(arrayBuffer, options)
+  parseSync: (arrayBuffer, options) => parseQuantizedMesh(arrayBuffer, options?.['quantized-mesh']),
+  parse: async (arrayBuffer, options) =>
+    parseQuantizedMesh(arrayBuffer, options?.['quantized-mesh'])
 };
-
-export const _typecheckQuantizedMeshLoader: LoaderWithParser = QuantizedMeshLoader;

package/src/lib/helpers/skirt.ts

@@ -70,12 +70,12 @@ function getOutsideEdgesFromTriangles(triangles) {
   edges.sort((a, b) => Math.min(...a) - Math.min(...b) || Math.max(...a) - Math.max(...b));
 
   const outsideEdges: number[][] = [];
-  let index = 1;
+  let index = 0;
   while (index < edges.length) {
-    if (edges[index][0] === edges[index - 1][1] && edges[index][1] === edges[index - 1][0]) {
+    if (edges[index][0] === edges[index + 1]?.[1] && edges[index][1] === edges[index + 1]?.[0]) {
       index += 2;
     } else {
-      outsideEdges.push(edges[index - 1]);
+      outsideEdges.push(edges[index]);
       index++;
     }
   }
@@ -159,10 +159,10 @@ function updateAttributesForNewEdge({
   // Define new triangles
   const triangle1Offset = edgeIndex * 2 * 3;
   newTriangles[triangle1Offset] = edge[0];
-  newTriangles[triangle1Offset + 1] = edge[1];
-  newTriangles[triangle1Offset + 2] = positionsLength / 3 + vertex2Offset;
+  newTriangles[triangle1Offset + 1] = positionsLength / 3 + vertex2Offset;
+  newTriangles[triangle1Offset + 2] = edge[1];
 
   newTriangles[triangle1Offset + 3] = positionsLength / 3 + vertex2Offset;
-  newTriangles[triangle1Offset + 4] = positionsLength / 3 + vertex1Offset;
-  newTriangles[triangle1Offset + 5] = edge[0];
+  newTriangles[triangle1Offset + 4] = edge[0];
+  newTriangles[triangle1Offset + 5] = positionsLength / 3 + vertex1Offset;
 }