@carbonenginejs/runtime-utils 0.1.0

package/src/geometry/helpers/misc.js

@@ -0,0 +1,103 @@
+import { num } from "../../num.js";
+import { triangulate } from "./earcut.js";
+
+
+// Ported from ThreeJS
+
+/**
+ * Calculates the area of a points polygon
+ * @param {Array<Float32Array|Array>} points
+ * @returns {number}
+ */
+export function getShapeArea(points)
+{
+    const n = points.length;
+    let a = 0.0;
+    for (let p = n - 1, q = 0; q < n; p = q++)
+    {
+        a += points[p][0] * points[q][1] - points[q][0] * points[p][1];
+    }
+    return a * 0.5;
+}
+
+/**
+ * Checks if clockwise oriented points
+ * @param {Array<Float32Array|Array>} pts
+ * @returns {boolean}
+ */
+export function isShapeClockWise(points)
+{
+    return getShapeArea(points) < 0;
+}
+
+/**
+ * Removes duplicate start and end points
+ * @param {Array<Float32Array|Array>} points
+ */
+function removeDupEndPts(points)
+{
+    const len = points.length;
+    if (len <= 2) return;
+
+    const
+        start = points[0],
+        end = points[len - 1];
+
+    for (let x = 0; x < start.length; x++)
+    {
+        if (!num.equals(start[x], end[x])) return;
+    }
+
+    points.pop();
+}
+
+/**
+ * Adds a points to positions array
+ * @param {Array} positions
+ * @param {Array<Float32Array>} points
+ */
+function addContour(positions, points)
+{
+    for (let i = 0; i < points.length; i++)
+    {
+        for (let x = 0; x < points[i].length; x++)
+        {
+            positions.push(points[i][x]);
+        }
+    }
+}
+
+/**
+ *
+ * @param points
+ * @param holes
+ * @returns {*[]}
+ */
+export function triangulateShape(points, holes = [])
+{
+    const
+        positions = [], // flat array of positions like [ x0,y0, x1,y1, x2,y2, ... ]
+        holeIndices = [], // array of hole indices
+        faces = []; // final array of vertex indices like [ [ a,b,d ], [ b,c,d ] ]
+
+    removeDupEndPts(points);
+    addContour(positions, points);
+
+    let holeIndex = points.length;
+    holes.forEach(removeDupEndPts);
+    for (let i = 0; i < holes.length; i++)
+    {
+        holeIndices.push(holeIndex);
+        holeIndex += holes[i].length;
+        addContour(positions, holes[i]);
+    }
+
+    const triangles = triangulate(positions, holeIndices);
+    for (let i = 0; i < triangles.length; i += 3)
+    {
+        faces.push(triangles.slice(i, i + 3));
+    }
+    return faces;
+}
+
+

package/src/geometry/index.js

@@ -0,0 +1,8 @@
+export * from "./box.js";
+export * from "./cylinder.js";
+export * from "./plane.js";
+export * from "./shape.js";
+export * from "./sphere.js";
+export * from "./torus.js";
+export * from "./json.js";
+export * from "./lathe.js";

package/src/geometry/json.js

@@ -0,0 +1,165 @@
+import { toArray } from "../utils.js";
+import { calculateNormals, calculateTangents } from "../vertex.js";
+
+
+function isAreaLike(value)
+{
+    if (!value) return false;
+    if (Array.isArray(value)) return !!value.length && typeof value[0] === "object" && value[0] !== null && "start" in value[0];
+    return typeof value === "object" && "start" in value;
+}
+
+
+/**
+ * Converts index and vertex buffer data to geometry json
+ * @param {Array|TypedArray} indices
+ * @param {Array|TypedArray} positions
+ * @param {Array|TypedArray} uvs
+ * @param {Array|TypedArray|Array|Object} [normals]
+ * @param {Array|Object} [areas]
+ * @param {Array|TypedArray} [tangents]
+ * @throw If required data is not provided
+ * @returns {Object}
+ */
+export function toJSON(indices, positions, uvs, normals, areas, tangents)
+{
+    if (!indices || !positions || !uvs || !indices.length || !positions.length || !uvs.length)
+    {
+        throw new Error("Invalid inputs");
+    }
+
+    if (isAreaLike(normals))
+    {
+        const temp = areas;
+        areas = normals;
+        normals = temp;
+    }
+
+    const vertexCount = positions.length / 3;
+    if (!Number.isInteger(vertexCount) ||
+        indices.length % 3 !== 0 ||
+        uvs.length !== vertexCount * 2)
+    {
+        throw new Error("Invalid geometry channel lengths");
+    }
+
+    for (let i = 0; i < indices.length; i++)
+    {
+        if (!Number.isInteger(indices[i]) || indices[i] < 0 || indices[i] >= vertexCount)
+        {
+            throw new Error(`Invalid vertex index at ${i}`);
+        }
+    }
+
+    if (normals && normals.length && normals.length !== positions.length)
+    {
+        throw new Error("Invalid normal channel length");
+    }
+
+    if (tangents && tangents.length &&
+        tangents.length !== vertexCount * 3 &&
+        tangents.length !== vertexCount * 4)
+    {
+        throw new Error("Invalid tangent channel length");
+    }
+
+    areas = toArray(areas && areas.length !== 0 ? areas : { start: 0, count: indices.length });
+    for (const area of areas)
+    {
+        if (!area ||
+            !Number.isInteger(area.start) ||
+            !Number.isInteger(area.count) ||
+            area.start < 0 ||
+            area.count < 0 ||
+            area.start % 3 !== 0 ||
+            area.count % 3 !== 0 ||
+            area.start + area.count > indices.length)
+        {
+            throw new Error("Invalid geometry area");
+        }
+    }
+
+    if (!normals || !normals.length)
+    {
+        normals = calculateNormals(indices, positions);
+    }
+
+    if (!tangents || !tangents.length)
+    {
+        tangents = calculateTangents(indices, positions, uvs, areas, normals);
+    }
+
+    return {
+        meshes: [ {
+            name: "",
+            vertex: {
+                position: positions,
+                texcoord0: uvs,
+                tangent: tangents,
+                normal: normals,
+                texcoord1: null,
+                binormal: null,
+                blendIndice: null,
+                blendWeight: null
+            },
+            indices: areas.map(area =>
+            {
+                const faces = indices.slice(area.start, area.start + area.count);
+                const requires32Bit = faces.some(index => index > 0xffff);
+                const bytesPerIndex = area.bytesPerIndex ?? (requires32Bit ? 4 : 2);
+                if ((bytesPerIndex !== 2 && bytesPerIndex !== 4) ||
+                    (bytesPerIndex === 2 && requires32Bit))
+                {
+                    throw new Error("Invalid bytes per index");
+                }
+                return {
+                    bytesPerIndex,
+                    start: area.start,
+                    count: area.count,
+                    faces
+                };
+            })
+        } ]
+    };
+}
+
+
+/**
+ * Creates a mesh container from geometry json
+ * @param {Object} tw2
+ * @param {Object} json
+ * @param {String} [name=""]
+ * @param {Object} [autoCreateMeshAreas={}]
+ * @returns {Object}
+ */
+export function toContainer(tw2, json, name = "", autoCreateMeshAreas = {})
+{
+    const
+        container = new tw2.EveChildMesh(),
+        mesh = container.mesh = new tw2.Tw2Mesh(),
+        res = mesh.geometryResource = new tw2.Tw2GeometryRes();
+
+    container.name = name;
+    res.UpdateFromJSON(json);
+    res.OnPrepared();
+
+    Object
+        .keys(autoCreateMeshAreas)
+        .forEach(areaName =>
+        {
+            const effect = autoCreateMeshAreas[areaName] || {};
+            for (let m = 0; m < res.meshes.length; m++)
+            {
+                for (let a = 0; a < res.meshes[m].areas.length; a++)
+                {
+                    const meshArea = new tw2.Tw2MeshArea();
+                    meshArea.meshIndex = m;
+                    meshArea.index = a;
+                    meshArea.effect = tw2.Tw2Effect.from(effect);
+                    mesh[areaName].push(meshArea);
+                }
+            }
+        });
+
+    return container;
+}

package/src/geometry/lathe.js

@@ -0,0 +1,172 @@
+import { num } from "../num.js";
+import { vec2 } from "../vec2.js";
+import { vec3 } from "../vec3.js";
+import { toJSON } from "./json.js";
+
+/**
+ * Creates a lathe
+ * @author Three.js converted
+ **/
+export function createLathe(options = {})
+{
+    let {
+        points = [
+            vec2.fromValues(0, -0.5),
+            vec2.fromValues(0.5, 0),
+            vec2.fromValues(0, 0.5)
+        ],
+        segments = 12,
+        phiStart = 0,
+        phiLength = Math.PI * 2
+    } = options;
+
+    segments = Math.max(3, Math.floor(Number.isFinite(segments) ? segments : 12));
+    if (!Array.isArray(points) || points.length < 2)
+    {
+        throw new Error("Lathe requires at least two profile points");
+    }
+    if (!Number.isFinite(phiStart) || !Number.isFinite(phiLength) || phiLength <= 0)
+    {
+        throw new Error("Invalid lathe sweep");
+    }
+    let hasRadius = false;
+    for (let i = 0; i < points.length; i++)
+    {
+        const point = points[i];
+        if (!point || point.length < 2 || !Number.isFinite(point[0]) || !Number.isFinite(point[1]))
+        {
+            throw new Error("Invalid lathe profile point");
+        }
+        hasRadius ||= point[0] !== 0;
+        if (i > 0 && point[0] === points[i - 1][0] && point[1] === points[i - 1][1])
+        {
+            throw new Error("Lathe profile contains a zero-length segment");
+        }
+    }
+    if (!hasRadius) throw new Error("Lathe profile must leave the rotation axis");
+
+    // clamp phiLength so it's in range of [ 0, 2PI ]
+    phiLength = num.clamp(phiLength, 0, Math.PI * 2);
+
+    // buffers
+    const
+        indices = [],
+        positions = [],
+        uvs = [],
+        initNormals = [],
+        normals = [];
+
+    // helper variables
+    const
+        inverseSegments = 1.0 / segments,
+        normal = vec3.alloc(),
+        curNormal = vec3.alloc(),
+        prevNormal = vec3.alloc();
+
+    let dx = 0,
+        dy = 0;
+
+    // pre-compute normals for initial "meridian"
+    for (let j = 0; j <= (points.length - 1); j++)
+    {
+        switch (j)
+        {
+            case 0:				// special handling for 1st vertex on path
+                dx = points[j + 1][0] - points[j][0];
+                dy = points[j + 1][1] - points[j][1];
+
+                normal[0] = dy * 1.0;
+                normal[1] = -dx;
+                normal[2] = dy * 0.0;
+
+                vec3.copy(prevNormal, normal);
+                vec3.normalize(normal, normal);
+                initNormals.push(normal[0], normal[1], normal[2]);
+                break;
+
+            case (points.length - 1):	// special handling for last Vertex on path
+                vec3.normalize(prevNormal, prevNormal);
+                initNormals.push(prevNormal[0], prevNormal[1], prevNormal[2]);
+                break;
+
+            default:			// default handling for all positions in between
+                dx = points[j + 1][0] - points[j][0];
+                dy = points[j + 1][1] - points[j][1];
+
+                normal[0] = dy * 1.0;
+                normal[1] = -dx;
+                normal[2] = dy * 0.0;
+                vec3.copy(curNormal, normal);
+
+                normal[0] += prevNormal[0];
+                normal[1] += prevNormal[1];
+                normal[2] += prevNormal[2];
+                vec3.normalize(normal, normal);
+
+                initNormals.push(normal[0], normal[1], normal[2]);
+                vec3.copy(prevNormal, curNormal);
+        }
+    }
+
+    // generate positions, uvs and normals
+    for (let i = 0; i <= segments; i++)
+    {
+        const
+            phi = phiStart + i * inverseSegments * phiLength,
+            sin = Math.sin(phi),
+            cos = Math.cos(phi);
+
+        for (let j = 0; j <= (points.length - 1); j++)
+        {
+            // vertex
+            positions.push(
+                points[j][0] * sin,
+                points[j][1],
+                points[j][0] * cos
+            );
+            // uv
+            uvs.push(
+                i / segments,
+                j / (points.length - 1)
+            );
+            // normal
+            normals.push(
+                initNormals[3 * j + 0] * sin,
+                initNormals[3 * j + 1],
+                initNormals[3 * j + 0] * cos
+            );
+        }
+    }
+
+    vec3.unalloc(normal);
+    vec3.unalloc(curNormal);
+    vec3.unalloc(prevNormal);
+
+    // indices
+    for (let i = 0; i < segments; i++)
+    {
+        for (let j = 0; j < (points.length - 1); j++)
+        {
+            const
+                base = j + i * points.length,
+                a = base,
+                b = base + points.length,
+                c = base + points.length + 1,
+                d = base + 1;
+
+            // faces
+            if (points[j][0] !== 0) indices.push(a, b, d);
+            if (points[j + 1][0] !== 0) indices.push(c, d, b);
+        }
+    }
+
+    const result = toJSON(indices, positions, uvs, normals);
+    result.factory = createLathe;
+    result.options = {
+        points,
+        segments,
+        phiStart,
+        phiLength,
+    };
+    return result;
+}

package/src/geometry/plane.js

@@ -0,0 +1,81 @@
+import { toJSON } from "./json.js";
+
+/**
+ * Creates a plane
+ * @author Three.js converted
+ * @param {Object} [options={}]
+ * @param {Number} [options.width=1]
+ * @param {Number} [options.height=1]
+ * @param {Number} [widthSegments=1]
+ * @param {Number} [heightSegments=1]
+ * @returns {Object}
+ */
+export function createPlane(options = {})
+{
+    const {
+        width = 1,
+        height = 1,
+        widthSegments = 1,
+        heightSegments = 1
+    } = options;
+
+    if (!Number.isFinite(width) || !Number.isFinite(height) || width === 0 || height === 0)
+    {
+        throw new Error("Plane dimensions must be finite and non-zero");
+    }
+
+    const
+        indices = [],
+        positions = [],
+        normals = [],
+        uvs = [];
+
+    const
+        widthHalf = width / 2,
+        heightHalf = height / 2,
+        gridX = Math.max(1, Math.floor(Number.isFinite(widthSegments) ? widthSegments : 1)),
+        gridY = Math.max(1, Math.floor(Number.isFinite(heightSegments) ? heightSegments : 1)),
+        gridX1 = gridX + 1,
+        gridY1 = gridY + 1,
+        segmentWidth = width / gridX,
+        segmentHeight = height / gridY;
+
+    for (let iy = 0; iy < gridY1; iy++)
+    {
+        const y = iy * segmentHeight - heightHalf;
+        for (let ix = 0; ix < gridX1; ix++)
+        {
+            const x = ix * segmentWidth - widthHalf;
+            positions.push(x, -y, 0);
+            normals.push(0, 0, 1);
+            uvs.push(ix / gridX);
+            uvs.push(1 - (iy / gridY));
+        }
+    }
+
+    for (let iy = 0; iy < gridY; iy++)
+    {
+        for (let ix = 0; ix < gridX; ix++)
+        {
+            const
+                a = ix + gridX1 * iy,
+                b = ix + gridX1 * (iy + 1),
+                c = (ix + 1) + gridX1 * (iy + 1),
+                d = (ix + 1) + gridX1 * iy;
+
+            indices.push(a, b, d);
+            indices.push(b, c, d);
+        }
+    }
+
+    // Normalize
+    const result = toJSON(indices, positions, uvs, normals);
+    result.factory = createPlane;
+    result.options = {
+        width,
+        height,
+        widthSegments: gridX,
+        heightSegments: gridY
+    };
+    return result;
+}

package/src/geometry/shape.js

@@ -0,0 +1,95 @@
+import { toArray } from "../utils.js";
+import { isShapeClockWise, triangulateShape } from "./helpers/misc.js";
+import { toJSON } from "./json.js";
+
+/**
+ * Creates a shape
+ * @author Three.js converted
+ **/
+export function createShape(shapes)
+{
+    shapes = toArray(shapes);
+
+    const
+        indices = [],
+        positions = [],
+        normals = [],
+        uvs = [];
+
+    let areaStart = 0,
+        areaCount = 0,
+        areas = [];
+
+    for (let i = 0; i < shapes.length; i++)
+    {
+        addShape(shapes[i]);
+        addArea(areaStart, areaCount, i);
+        areaStart += areaCount;
+        areaCount = 0;
+    }
+
+    function addArea(start, count, index)
+    {
+        areas.push({ start, count, index });
+    }
+
+    function addShape(shape)
+    {
+        let shapeVertices = shape.positions.map(point => Array.from(point)),
+            shapeHoles = (shape.holes || []).map(hole => hole.map(point => Array.from(point)));
+
+        const indexOffset = positions.length / 3;
+
+        // check direction of positions
+        if (isShapeClockWise(shapeVertices) === false)
+        {
+            shapeVertices = shapeVertices.reverse();
+        }
+
+        for (let i = 0, l = shapeHoles.length; i < l; i++)
+        {
+            const shapeHole = shapeHoles[i];
+            if (isShapeClockWise(shapeHole) === true)
+            {
+                shapeHoles[i] = shapeHole.reverse();
+            }
+        }
+
+        const faces = triangulateShape(shapeVertices, shapeHoles);
+
+        // join positions of inner and outer paths to a single array
+        for (let i = 0, l = shapeHoles.length; i < l; i++)
+        {
+            const shapeHole = shapeHoles[i];
+            shapeVertices = shapeVertices.concat(shapeHole);
+        }
+
+        // positions, normals, uvs
+        for (let i = 0, l = shapeVertices.length; i < l; i++)
+        {
+            const vertex = shapeVertices[i];
+            positions.push(vertex[0], vertex[1], 0);
+            normals.push(0, 0, 1);
+            uvs.push(vertex[0], vertex[1]); // world uvs
+        }
+
+        // indices
+        for (let i = 0, l = faces.length; i < l; i++)
+        {
+            const
+                face = faces[i],
+                a = face[0] + indexOffset,
+                b = face[1] + indexOffset,
+                c = face[2] + indexOffset;
+
+            indices.push(a, b, c);
+            areaCount += 3;
+        }
+    }
+
+    // Normalize
+    const result = toJSON(indices, positions, uvs, areas, normals);
+    result.factory = createShape;
+    result.options = shapes;
+    return result;
+}