@woosh/meep-engine 2.33.23 → 2.33.27

package/core/geom/3d/shape/UnitCubeShape3D.js

@@ -0,0 +1,101 @@
+import { AbstractShape3D } from "./AbstractShape3D.js";
+import { randomPointInBox } from "../../random/randomPointInBox.js";
+import { v3_length } from "../../v3_length.js";
+import { max2 } from "../../../math/max2.js";
+import { max3 } from "../../../math/max3.js";
+import { min2 } from "../../../math/min2.js";
+import { clamp } from "../../../math/clamp.js";
+import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
+
+export class UnitCubeShape3D extends AbstractShape3D {
+
+    get volume() {
+        return 1;
+    }
+
+    nearest_point_on_surface(result, reference) {
+        const r_x = reference[0];
+        const r_y = reference[1];
+        const r_z = reference[2];
+
+        // figure out closest face to the reference point
+        const ar_x = Math.abs(r_x);
+        const ar_y = Math.abs(r_y);
+        const ar_z = Math.abs(r_z);
+
+        if (ar_x > ar_y && ar_x > ar_z) {
+            // X is smallest, project onto X axis
+            if (r_x <= 0) {
+                result[0] = -0.5;
+            } else {
+                result[0] = 0.5;
+            }
+
+            result[1] = clamp(r_y, -0.5, 0.5);
+            result[2] = clamp(r_z, -0.5, 0.5);
+        } else if (ar_y > ar_x && ar_y > ar_z) {
+            // Y is smallest, project onto X axis
+            if (r_y <= 0) {
+                result[1] = -0.5;
+            } else {
+                result[1] = 0.5;
+            }
+
+            result[0] = clamp(r_x, -0.5, 0.5);
+            result[2] = clamp(r_z, -0.5, 0.5);
+        } else {
+            // project onto Z axis
+
+            if (r_z <= 0) {
+                result[2] = -0.5;
+            } else {
+                result[2] = 0.5;
+            }
+
+            result[0] = clamp(r_x, -0.5, 0.5);
+            result[1] = clamp(r_y, -0.5, 0.5);
+        }
+    }
+
+    signed_distance_gradient_at_point(result, point) {
+        return compute_signed_distance_gradient_by_sampling(result,this, point);
+    }
+
+    signed_distance_at_point(point) {
+        /*
+        based on https://www.iquilezles.org/www/articles/distfunctions/distfunctions.htm
+        original shader code:
+            ------------
+            float sdBox( vec3 p, vec3 b )
+            {
+              vec3 q = abs(p) - b;
+              return length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0);
+            }
+            ------------
+         */
+        const q_x = Math.abs(point[0]) - 0.5;
+        const q_y = Math.abs(point[1]) - 0.5;
+        const q_z = Math.abs(point[2]) - 0.5;
+
+        return v3_length(
+            max2(q_x, 0),
+            max2(q_y, 0),
+            max2(q_z, 0)
+        ) + min2(max3(q_x, q_y, q_z), 0);
+    }
+
+    contains_point(point) {
+        const x = point[0];
+        const y = point[1];
+        const z = point[2];
+
+        return x > -0.5 && x < 0.5
+            && y > -0.5 && y < 0.5
+            && z > -0.5 && z < 0.5
+            ;
+    }
+
+    sample_random_point_in_volume(result, result_offset, random) {
+        randomPointInBox(random, result, result_offset);
+    }
+}

package/core/geom/3d/shape/UnitCubeShape3D.spec.js

@@ -0,0 +1,42 @@
+import { UnitCubeShape3D } from "./UnitCubeShape3D.js";
+
+test('signed distance', () => {
+    const s = new UnitCubeShape3D();
+
+    expect(s.signed_distance_at_point([0, 0, 0])).toBeCloseTo(-0.5);
+
+    expect(s.signed_distance_at_point([0.5, 0, 0])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0, 0.5, 0])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0, 0, 0.5])).toBeCloseTo(0);
+
+    expect(s.signed_distance_at_point([-0.5, 0, 0])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0, -0.5, 0])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0, 0, -0.5])).toBeCloseTo(0);
+
+    expect(s.signed_distance_at_point([0.5, 0.5, 0])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0, 0.5, 0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0.5, 0, 0.5])).toBeCloseTo(0);
+
+    expect(s.signed_distance_at_point([-0.5, 0.5, 0])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0.5, -0.5, 0])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([-0.5, -0.5, 0])).toBeCloseTo(0);
+
+    expect(s.signed_distance_at_point([0, -0.5, 0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0, 0.5, -0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0, -0.5, -0.5])).toBeCloseTo(0);
+
+    expect(s.signed_distance_at_point([-0.5, 0, 0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0.5, 0, -0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([-0.5, 0, -0.5])).toBeCloseTo(0);
+
+    expect(s.signed_distance_at_point([0.5, 0.5, 0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([-0.5, 0.5, 0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0.5, -0.5, 0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0.5, 0.5, -0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([-0.5, -0.5, 0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([0.5, -0.5, -0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([-0.5, 0.5, -0.5])).toBeCloseTo(0);
+    expect(s.signed_distance_at_point([-0.5, -0.5, -0.5])).toBeCloseTo(0);
+
+    expect(s.signed_distance_at_point([1, 0, 0])).toBeCloseTo(0.5);
+});

package/core/geom/3d/shape/UnitSphereShape3D.js

@@ -0,0 +1,55 @@
+import { AbstractShape3D } from "./AbstractShape3D.js";
+import { randomPointInSphere } from "../../random/randomPointInSphere.js";
+import { v3_length } from "../../v3_length.js";
+import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
+
+/**
+ * Sphere with diameter of 1 (radius = 0.5)
+ */
+export class UnitSphereShape3D extends AbstractShape3D {
+    get volume() {
+        return 0.523598776;
+    }
+
+    get surface_area() {
+        return 3.14159265;
+    }
+
+    nearest_point_on_surface(result, reference) {
+
+        const r_x = reference[0];
+        const r_y = reference[1];
+        const r_z = reference[2];
+
+        // normalize vector to 0.5 radius
+        const d = 0.5 / Math.hypot(r_x, r_y, r_z);
+
+        result[0] = r_x * d;
+        result[1] = r_y * d;
+        result[2] = r_z * d;
+    }
+
+    signed_distance_gradient_at_point(result, point) {
+        return compute_signed_distance_gradient_by_sampling(result,this, point);
+    }
+
+    signed_distance_at_point(point) {
+        return v3_length(
+            point[0],
+            point[1],
+            point[2]
+        ) - 0.5;
+    }
+
+    contains_point(point) {
+        const x = point[0];
+        const y = point[1];
+        const z = point[2];
+
+        return (x * x + y * y + z * z) < 0.25;
+    }
+
+    sample_random_point_in_volume(result, result_offset, random) {
+        randomPointInSphere(random, result, result_offset);
+    }
+}

package/core/geom/3d/shape/util/compute_signed_distance_gradient_by_sampling.js

@@ -0,0 +1,48 @@
+const scratch_v = [];
+
+/**
+ *
+ * @param {number[]} result
+ * @param {AbstractShape3D} shape
+ * @param {number[]} point
+ * @returns {number}
+ */
+export function compute_signed_distance_gradient_by_sampling(result, shape, point) {
+    const v0 = shape.signed_distance_at_point(point);
+
+    scratch_v[0] = point[0] + 1e-5;
+    scratch_v[1] = point[1];
+    scratch_v[2] = point[2];
+
+    const vx = shape.signed_distance_at_point(scratch_v);
+
+    scratch_v[0] = point[0];
+    scratch_v[1] = point[1] + 1e-5;
+    scratch_v[2] = point[2];
+
+    const vy = shape.signed_distance_at_point(point);
+
+    scratch_v[0] = point[0];
+    scratch_v[1] = point[1];
+    scratch_v[2] = point[2] + 1e-5;
+
+    const vz = shape.signed_distance_at_point(point);
+
+    // convert absolute sample values to relative
+    const rx = vx - v0;
+    const ry = vy - v0;
+    const rz = vz - v0;
+
+    // normalize by sampling distance
+    const d = 1e-5 / 1.73205080757;
+
+    const nx = rx * d;
+    const ny = ry * d;
+    const nz = rz * d;
+
+    result[0] = nx;
+    result[1] = ny;
+    result[2] = nz;
+
+    return v0;
+}

package/core/geom/3d/shape/util/shape_to_visual_entity.js

@@ -0,0 +1,159 @@
+import { UnionShape3D } from "../UnionShape3D.js";
+import { UnitCubeShape3D } from "../UnitCubeShape3D.js";
+import { UnitSphereShape3D } from "../UnitSphereShape3D.js";
+import { TransformedShape3D } from "../TransformedShape3D.js";
+import EntityBuilder from "../../../../../engine/ecs/EntityBuilder.js";
+import { Transform } from "../../../../../engine/ecs/transform/Transform.js";
+import { AttachmentSockets } from "../../../../../engine/ecs/sockets/AttachmentSockets.js";
+import { Attachment } from "../../../../../engine/ecs/attachment/Attachment.js";
+import { ShadedGeometry } from "../../../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
+import { LineBasicMaterial } from "three";
+import { makeHelperSphereGeometry } from "../../../../../editor/process/symbolic/makeHelperSphereGeometry.js";
+import { DrawMode } from "../../../../../engine/graphics/ecs/mesh-v2/DrawMode.js";
+import { makeHelperBoxGeometry } from "../../../../../editor/process/symbolic/makeHelperBoxGeometry.js";
+import Tag from "../../../../../engine/ecs/components/Tag.js";
+
+const g_unit_sphere = makeHelperSphereGeometry(0.5, 32);
+const g_unit_cube = makeHelperBoxGeometry(1, 1, 1);
+
+const lineMaterial = new LineBasicMaterial({
+    depthTest: true,
+    depthWrite: false,
+    transparent: true,
+    linewidth: 1,
+    fog: false,
+    color: '#FFFFFF',
+    opacity: 1
+});
+
+export const SHAPE_VISUAL_ENTITY_TAG = 'util/vis/Shape3D';
+
+/**
+ *
+ * @param {UnionShape3D} shape
+ * @param {EntityComponentDataset} ecd
+ * @returns {EntityBuilder}
+ */
+function composite_shape_to_entity(shape, ecd) {
+
+    const parent = new EntityBuilder();
+    parent
+        .add(new Transform())
+        .add(AttachmentSockets.fromJSON({
+            elements: [
+                {
+                    type: 0,
+                    id: 0
+                }
+            ]
+        }))
+        .build(ecd);
+
+    shape.children.forEach(c => {
+
+        const child_entity = shape_to_visual_entity(c, ecd);
+
+        child_entity.add(Attachment.fromJSON({
+            socket: 0,
+            parent: parent.entity,
+            immediate: true
+        }));
+
+    })
+
+    return parent;
+}
+
+
+/**
+ *
+ * @param {UnitCubeShape3D} shape
+ * @param {EntityComponentDataset} ecd
+ * @returns {EntityBuilder}
+ */
+function cube_shape_to_entity(shape, ecd) {
+    const eb = new EntityBuilder();
+
+    eb.add(new Transform());
+    eb.add(Tag.fromOne(SHAPE_VISUAL_ENTITY_TAG));
+    eb.add(ShadedGeometry.from(g_unit_cube, lineMaterial, DrawMode.LineSegments));
+
+    eb.build(ecd);
+
+    return eb;
+}
+
+
+/**
+ *
+ * @param {UnitSphereShape3D} shape
+ * @param {EntityComponentDataset} ecd
+ * @returns {EntityBuilder}
+ */
+function sphere_shape_to_entity(shape, ecd) {
+    const eb = new EntityBuilder();
+
+    eb.add(new Transform());
+    eb.add(Tag.fromOne(SHAPE_VISUAL_ENTITY_TAG));
+    eb.add(ShadedGeometry.from(g_unit_sphere, lineMaterial, DrawMode.Lines));
+
+    eb.build(ecd);
+
+    return eb;
+
+}
+
+/**
+ *
+ * @param {TransformedShape3D} shape
+ * @param {EntityComponentDataset} ecd
+ * @returns {EntityBuilder}
+ */
+function transformed_shape_to_entity(shape, ecd) {
+    const subject = shape_to_visual_entity(shape.subject, ecd);
+
+    const parent = new EntityBuilder();
+    parent
+        .add(new Transform())
+        .add(AttachmentSockets.fromJSON({
+            elements: [
+                {
+                    type: 0,
+                    id: 0
+                }
+            ]
+        }))
+        .build(ecd);
+
+    const attachment = Attachment.fromJSON({
+        socket: 0,
+        parent: parent.entity,
+        immediate: true
+    });
+
+    attachment.transform.fromMatrix4(shape.transform);
+
+    subject.add(attachment);
+
+    return parent;
+}
+
+/**
+ *
+ * @param {AbstractShape3D} shape
+ * @param {EntityComponentDataset} ecd
+ * @returns {EntityBuilder}
+ */
+export function shape_to_visual_entity(shape, ecd) {
+    if (shape instanceof UnionShape3D) {
+        return composite_shape_to_entity(shape, ecd);
+    } else if (shape instanceof UnitCubeShape3D) {
+        return cube_shape_to_entity(shape, ecd);
+    } else if (shape instanceof UnitSphereShape3D) {
+        return sphere_shape_to_entity(shape, ecd);
+    } else if (shape instanceof TransformedShape3D) {
+        return transformed_shape_to_entity(shape, ecd);
+    } else {
+        throw new Error('Unsupported shape type');
+    }
+}

package/core/geom/AABB2.js

@@ -6,11 +6,11 @@
 
 import { assert } from "../assert.js";
 import { clamp } from "../math/clamp.js";
-import { overlap1D } from "../math/MathUtils.js";
 import { max2 } from "../math/max2.js";
 import { min2 } from "../math/min2.js";
 import LineSegment2 from "./LineSegment2.js";
 import Vector2 from "./Vector2.js";
+import { overlap1D } from "../math/overlap1D.js";
 
 /**
  *

package/core/geom/ConicRay.js

@@ -1,6 +1,8 @@
 import { assert } from "../assert.js";
-import { computeHashFloat, computeHashIntegerArray, EPSILON, epsilonEquals } from "../math/MathUtils.js";
+import { EPSILON, epsilonEquals } from "../math/MathUtils.js";
 import Vector3 from "./Vector3.js";
+import { computeHashIntegerArray } from "../collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../math/hash/computeHashFloat.js";
 
 
 /**

package/core/geom/LineSegment.js

@@ -3,8 +3,6 @@
  */
 import { clamp } from "../math/clamp.js";
 import Vector3 from "./Vector3.js";
-import { v3_dot } from "./v3_dot.js";
-import { v3_distance_sqr } from "./v3_distance_sqr.js";
 
 
 const SMALL_NUM = 1e-9;
@@ -19,82 +17,6 @@ const LineSegment = function (first, second) {
 
 };
 
-/**
- *
- * @param {Vector3} result
- * @param {number} origin_x
- * @param {number} origin_y
- * @param {number} origin_z
- * @param {number} direction_x
- * @param {number} direction_y
- * @param {number} direction_z
- * @param {number} px
- * @param {number} py
- * @param {number} pz
- * @returns {number} distance from origin, negative means that the point lies behind the origin in the direction opposite to the ray's own
- */
-export function ray_computeNearestPointToPoint(result, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, px, py, pz) {
-    // find closest point
-    const sp0_x = px - origin_x;
-    const sp0_y = py - origin_y;
-    const sp0_z = pz - origin_z;
-
-    //
-    const d2 = v3_dot(direction_x, direction_y, direction_z, direction_x, direction_y, direction_z);
-    const d3 = v3_dot(direction_x, direction_y, direction_z, sp0_x, sp0_y, sp0_z);
-
-    const t = d3 / d2;
-
-    // compute point on the ray
-    const lp_x = direction_x * t + origin_x;
-    const lp_y = direction_y * t + origin_y;
-    const lp_z = direction_z * t + origin_z;
-
-    result.set(lp_x, lp_y, lp_z);
-
-    return t;
-}
-
-/**
- * Computes shortest distance between a line segment(defined by 2 points) and a point
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {number} px
- * @param {number} py
- * @param {number} pz
- */
-export function line3_computeSegmentPointDistance_sqr(x0, y0, z0, x1, y1, z1, px, py, pz) {
-    // find closest point
-    const sp0_x = px - x0;
-    const sp0_y = py - y0;
-    const sp0_z = pz - z0;
-
-    // get line delta
-    const line_delta_x = x1 - x0;
-    const line_delta_y = y1 - y0;
-    const line_delta_z = z1 - z0;
-
-    //
-    const d2 = line_delta_x * line_delta_x + line_delta_y * line_delta_y + line_delta_z * line_delta_z;
-
-
-    const d3 = line_delta_x * sp0_x + line_delta_y * sp0_y + line_delta_z * sp0_z;
-
-    const t = clamp(d3 / d2, 0, 1);
-
-    // compute point on the line
-    const lp_x = line_delta_x * t + x0;
-    const lp_y = line_delta_y * t + y0;
-    const lp_z = line_delta_z * t + z0;
-
-    // compute distance from the point in question to the point on the line
-    return v3_distance_sqr(px, py, pz, lp_x, lp_y, lp_z);
-}
-
 LineSegment.prototype.closestPointToPointParameter = function (point, clampToLine) {
 
 

package/core/geom/Matrix4.js

@@ -1,5 +1,4 @@
 import Vector3 from "./Vector3.js";
-import { v3_length } from "./v3_length.js";
 
 const _z = new Vector3();
 const _x = new Vector3();
@@ -193,12 +192,12 @@ export class Matrix4 {
     decompose(position, rotation, scale) {
 
 
-        var sx = v3_length(this.a0, this.a1, this.a2);
-        var sy = v3_length(this.b0, this.b1, this.b2);
-        var sz = v3_length(this.c0, this.c1, this.c2);
+        let sx = Math.hypot(this.a0, this.a1, this.a2);
+        const sy = Math.hypot(this.b0, this.b1, this.b2);
+        const sz = Math.hypot(this.c0, this.c1, this.c2);
 
         // if determine is negative, we need to invert one scale
-        var det = this.determinant();
+        const  det = this.determinant();
         if (det < 0) sx = -sx;
 
         position.set(
@@ -208,9 +207,9 @@ export class Matrix4 {
         );
 
         // scale the rotation part
-        var invSX = 1 / sx;
-        var invSY = 1 / sy;
-        var invSZ = 1 / sz;
+        const invSX = 1 / sx;
+        const invSY = 1 / sy;
+        const invSZ = 1 / sz;
 
         const i_a0 = this.a0 * invSX;
         const i_a1 = this.a1 * invSX;

package/core/geom/Rectangle.js

@@ -1,10 +1,11 @@
 /**
  * Created by Alex on 14/03/2016.
  */
-import { intersects1D, overlap1D } from "../math/MathUtils.js";
 import { max2 } from "../math/max2.js";
 import { min2 } from "../math/min2.js";
 import Vector2 from "./Vector2.js";
+import { intersects1D } from "../math/intersects1D.js";
+import { overlap1D } from "../math/overlap1D.js";
 
 
 /**

package/core/geom/Vector1.js

@@ -6,7 +6,7 @@
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
 import { clamp } from "../math/clamp.js";
-import { computeHashFloat } from "../math/MathUtils.js";
+import { computeHashFloat } from "../math/hash/computeHashFloat.js";
 
 
 class Vector1 extends Number {

package/core/geom/Vector3.js

@@ -6,7 +6,7 @@
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
 import { lerp } from "../math/lerp.js";
-import { computeHashFloat, EPSILON, epsilonEquals } from "../math/MathUtils.js";
+import { EPSILON, epsilonEquals } from "../math/MathUtils.js";
 import { sign } from "../math/sign.js";
 import { v3_dot } from "./v3_dot.js";
 import { v3_length_sqr } from "./v3_length_sqr.js";
@@ -14,6 +14,7 @@ import { v3_length } from "./v3_length.js";
 import { v3_angle_between } from "./v3_angle_between.js";
 import { v3_lerp } from "./v3_lerp.js";
 import { v3_slerp } from "./v3_slerp.js";
+import { computeHashFloat } from "../math/hash/computeHashFloat.js";
 
 class Vector3 {
     /**

package/core/geom/Vector4.js

@@ -5,7 +5,8 @@
 import { assert } from "../assert.js";
 import { Signal } from "../events/signal/Signal.js";
 import { lerp } from "../math/lerp.js";
-import { computeHashFloat, computeHashIntegerArray } from "../math/MathUtils.js";
+import { computeHashIntegerArray } from "../collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../math/hash/computeHashFloat.js";
 
 /**
  *

package/core/geom/random/randomPointInBox.js

@@ -1,12 +1,16 @@
 /**
  *
  * @param {function} random
- * @param {Vector3} result
+ * @param {number[]} result
+ * @param {number} result_offset
  */
-export function randomPointInBox(random, result) {
+export function randomPointInBox(random, result, result_offset) {
     const x = random() - 0.5;
     const y = random() - 0.5;
     const z = random() - 0.5;
 
-    result.set(x, y, z);
+    //write the result
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
 }

package/core/geom/random/randomPointInPoint.js

@@ -1,8 +1,11 @@
 /**
  * Volumetric sampling method, since sample volume is a point, it simply sets result to origin
  * @param {function} random
- * @param {Vector3} result
+ * @param {number[]} result
+ * @param {number} destination_offset
  */
-export function randomPointInPoint(random, result) {
-    result.set(0, 0, 0);
+export function randomPointInPoint(random, result, destination_offset) {
+    result[destination_offset] = 0;
+    result[destination_offset + 1] = 0;
+    result[destination_offset + 2] = 0;
 }

package/core/geom/random/randomPointInSphere.js

@@ -4,18 +4,20 @@ import { PI2 } from "../../math/MathUtils.js";
  *
  * @see based on python code suggested here: https://stackoverflow.com/questions/5408276/sampling-uniformly-distributed-random-points-inside-a-spherical-volume
  * @param {function} random
- * @param {Vector3} result
+ * @param {number[]} result
+ * @param {number} result_offset
  */
-export function randomPointInSphere(random, result) {
+export function randomPointInSphere(random, result, result_offset) {
     const phi = PI2 * random();
 
     const cosTheta = random() * 2 - 1;
 
-    const u = random() * 0.5;
+    const u = random();
 
     const theta = Math.acos(cosTheta);
 
-    const r = Math.cbrt(u);
+    // compute radius
+    const r = Math.cbrt(u) * 0.5;
 
     const sinTheta = Math.sin(theta);
 
@@ -27,5 +29,7 @@ export function randomPointInSphere(random, result) {
     const z = r * cosTheta;
 
     //write the result
-    result.set(x, y, z);
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
 }