From 288eb6f4cb561134ecde3d6e37362aa0a033290c Mon Sep 17 00:00:00 2001 From: Andy Wong Date: Sat, 16 Mar 2024 15:27:58 -0700 Subject: [PATCH] fix mat and add tests --- dist/index.js | 2 +- dist/wasm/mat.js | 4 +- js/wasm/__tests__/mat.spec.ts | 189 ++++++++++++++++++++++++++++++++++ js/wasm/mat.ts | 19 ++-- 4 files changed, 204 insertions(+), 10 deletions(-) diff --git a/dist/index.js b/dist/index.js index 4a5be0b..e968602 100644 --- a/dist/index.js +++ b/dist/index.js @@ -1,2 +1,2 @@ export*from"./wasm/index.js";export*from"./scalar.js";export*from"./types.js"; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vanMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi93YXNtL2luZGV4LnRzJztcbmV4cG9ydCAqIGZyb20gJy4vc2NhbGFyLnRzJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMudHMnO1xuIl0sIm1hcHBpbmdzIjoiIiwiaWdub3JlTGlzdCI6W119 \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vanMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBNaW5pbWFsaXN0aWMgbnVtZXJpY2FsIGxpYnJhcnkgZm9yIGhpZ2gtcGVyZm9ybWFuY2UgM0QgbWF0aCwgcG93ZXJlZCBieSBSdXN0IFdlYkFzc2VtYmx5IGJpbmRpbmdzLlxuICogQHBhY2thZ2VEb2N1bWVudGF0aW9uXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi93YXNtL2luZGV4LnRzJztcbmV4cG9ydCAqIGZyb20gJy4vc2NhbGFyLnRzJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMudHMnO1xuIl0sIm1hcHBpbmdzIjoiIiwiaWdub3JlTGlzdCI6W119 \ No newline at end of file diff --git a/dist/wasm/mat.js b/dist/wasm/mat.js index 1598295..3c69746 100644 --- a/dist/wasm/mat.js +++ b/dist/wasm/mat.js @@ -1,2 +1,2 @@ -import{mat2identity,mat2add,mat2det,mat2frommat3,mat2invert,mat2mul,mat2scale,mat2sub,mat2transpose,mat3identity,mat3add,mat3det,mat3frommat2,mat3frommat4,mat3invert,mat3mul,mat3scale,mat3sub,mat3transpose,mat4identity,mat4add,mat4det,mat4frommat3,mat4invert,mat4mul,mat4scale,mat4sub,mat4transpose}from"../../wasm/index.js";import{ManagedFloat64Array}from"./memory.js";export class Mat2 extends ManagedFloat64Array{static identity(){return new Mat2(mat2identity())}static fromMat3(m){return new Mat2(mat2frommat3(m.byteOffset))}constructor(ptr){super(4,ptr)}add(rhs){mat2add(this.byteOffset,this.byteOffset,rhs.byteOffset);return this}sub(rhs){mat2sub(this.byteOffset,this.byteOffset,rhs.byteOffset);return this}mul(m){mat2mul(this.byteOffset,m.byteOffset,this.byteOffset);return this}scale(factor){mat2scale(this.byteOffset,this.byteOffset,factor);return this}transpose(){mat2transpose(this.byteOffset,this.byteOffset)}invert(){return!!mat2invert(this.byteOffset,this.byteOffset)}det(){return mat2det(this.byteOffset)}}export class Mat3 extends ManagedFloat64Array{static identity(){return new Mat3(mat3identity())}static fromMat2(m){return new Mat3(mat3frommat2(m.byteOffset))}static fromMat4(m){return new Mat3(mat3frommat4(m.byteOffset))}constructor(ptr){super(9,ptr)}add(rhs){mat3add(this.byteOffset,this.byteOffset,rhs.byteOffset);return this}sub(rhs){mat3sub(this.byteOffset,this.byteOffset,rhs.byteOffset);return this}mul(m){mat3mul(this.byteOffset,m.byteOffset,this.byteOffset);return this}scale(factor){mat3scale(this.byteOffset,this.byteOffset,factor);return this}transpose(){mat3transpose(this.byteOffset,this.byteOffset)}invert(){return!!mat3invert(this.byteOffset,this.byteOffset)}det(){return mat3det(this.byteOffset)}}export class Mat4 extends ManagedFloat64Array{static identity(){return new Mat4(mat4identity())}static fromMat3(m){return new Mat4(mat4frommat3(m.byteOffset))}constructor(ptr){super(16,ptr)}add(rhs){mat4add(this.byteOffset,this.byteOffset,rhs.byteOffset);return this}sub(rhs){mat4sub(this.byteOffset,this.byteOffset,rhs.byteOffset);return this}mul(m){mat4mul(this.byteOffset,m.byteOffset,this.byteOffset);return this}scale(factor){mat4scale(this.byteOffset,this.byteOffset,factor);return this}transpose(){mat4transpose(this.byteOffset,this.byteOffset)}invert(){return!!mat4invert(this.byteOffset,this.byteOffset)}det(){return mat4det(this.byteOffset)}} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["mat2identity","mat2add","mat2det","mat2frommat3","mat2invert","mat2mul","mat2scale","mat2sub","mat2transpose","mat3identity","mat3add","mat3det","mat3frommat2","mat3frommat4","mat3invert","mat3mul","mat3scale","mat3sub","mat3transpose","mat4identity","mat4add","mat4det","mat4frommat3","mat4invert","mat4mul","mat4scale","mat4sub","mat4transpose","ManagedFloat64Array","Mat2","identity","fromMat3","m","byteOffset","constructor","ptr","add","rhs","sub","mul","scale","factor","transpose","invert","det","Mat3","fromMat2","fromMat4","Mat4"],"sources":["../../js/wasm/mat.ts"],"sourcesContent":["import {\n  mat2identity, mat2add, mat2det, mat2frommat3, mat2invert, mat2mul, mat2scale, mat2sub, mat2transpose,\n  mat3identity, mat3add, mat3det, mat3frommat2, mat3frommat4, mat3invert, mat3mul, mat3scale, mat3sub, mat3transpose,\n  mat4identity, mat4add, mat4det, mat4frommat3, mat4invert, mat4mul, mat4scale, mat4sub, mat4transpose,\n} from '../../wasm/index.js';\nimport { Indexable, Mat } from '../types.ts';\nimport { ManagedFloat64Array } from './memory.ts';\n\n/** A 2x2 matrix. */\nexport class Mat2 extends ManagedFloat64Array<4> implements Mat<2>, Indexable<4> {\n  public 0: number;\n  public 1: number;\n  public 2: number;\n  public 3: number;\n\n  /** Return an identity Mat2. */\n  public static identity(): Mat2 {\n    return new Mat2(mat2identity());\n  }\n\n  /** Return a Mat2 from Mat3. */\n  public static fromMat3(m: Mat3): Mat2 {\n    return new Mat2(mat2frommat3(m.byteOffset));\n  }\n\n  private constructor(ptr: number) {\n    super(4, ptr);\n  }\n\n  public add(rhs: Mat2): this {\n    mat2add(this.byteOffset, this.byteOffset, rhs.byteOffset);\n    return this;\n  }\n\n  public sub(rhs: Mat2): this {\n    mat2sub(this.byteOffset, this.byteOffset, rhs.byteOffset);\n    return this;\n  }\n\n  public mul(m: Mat2): this {\n    mat2mul(this.byteOffset, m.byteOffset, this.byteOffset);\n    return this;\n  }\n\n  public scale(factor: number): this {\n    mat2scale(this.byteOffset, this.byteOffset, factor);\n    return this;\n  }\n\n  public transpose(): void {\n    mat2transpose(this.byteOffset, this.byteOffset);\n  }\n\n  public invert(): boolean {\n    return !!mat2invert(this.byteOffset, this.byteOffset);\n  }\n\n  public det(): number {\n    return mat2det(this.byteOffset);\n  }\n}\n\n/** A 3x3 matrix. */\nexport class Mat3 extends ManagedFloat64Array<9> implements Mat<3>, Indexable<9> {\n  public 0: number;\n  public 1: number;\n  public 2: number;\n  public 3: number;\n  public 4: number;\n  public 5: number;\n  public 6: number;\n  public 7: number;\n  public 8: number;\n\n  /** Return an identity Mat3. */\n  public static identity(): Mat3 {\n    return new Mat3(mat3identity());\n  }\n\n  /** Return a Mat3 from Mat2. */\n  public static fromMat2(m: Mat2): Mat3 {\n    return new Mat3(mat3frommat2(m.byteOffset));\n  }\n\n  /** Return a Mat3 from Mat4. */\n  public static fromMat4(m: Mat4): Mat3 {\n    return new Mat3(mat3frommat4(m.byteOffset));\n  }\n\n  private constructor(ptr: number) {\n    super(9, ptr);\n  }\n\n  public add(rhs: Mat3): this {\n    mat3add(this.byteOffset, this.byteOffset, rhs.byteOffset);\n    return this;\n  }\n\n  public sub(rhs: Mat3): this {\n    mat3sub(this.byteOffset, this.byteOffset, rhs.byteOffset);\n    return this;\n  }\n\n  public mul(m: Mat3): this {\n    mat3mul(this.byteOffset, m.byteOffset, this.byteOffset);\n    return this;\n  }\n\n  public scale(factor: number): this {\n    mat3scale(this.byteOffset, this.byteOffset, factor);\n    return this;\n  }\n\n  public transpose(): void {\n    mat3transpose(this.byteOffset, this.byteOffset);\n  }\n\n  public invert(): boolean {\n    return !!mat3invert(this.byteOffset, this.byteOffset);\n  }\n\n  public det(): number {\n    return mat3det(this.byteOffset);\n  }\n}\n\n/** A 4x4 matrix. */\nexport class Mat4 extends ManagedFloat64Array<16> implements Mat<4>, Indexable<16> {\n  public 0: number;\n  public 1: number;\n  public 2: number;\n  public 3: number;\n  public 4: number;\n  public 5: number;\n  public 6: number;\n  public 7: number;\n  public 8: number;\n  public 9: number;\n  public 10: number;\n  public 11: number;\n  public 12: number;\n  public 13: number;\n  public 14: number;\n  public 15: number;\n\n  /** Return an identity Mat4. */\n  public static identity(): Mat4 {\n    return new Mat4(mat4identity());\n  }\n\n  /** Return a Mat4 from Mat3. */\n  public static fromMat3(m: Mat3): Mat4 {\n    return new Mat4(mat4frommat3(m.byteOffset));\n  }\n\n  private constructor(ptr: number) {\n    super(16, ptr);\n  }\n\n  public add(rhs: Mat4): this {\n    mat4add(this.byteOffset, this.byteOffset, rhs.byteOffset);\n    return this;\n  }\n\n  public sub(rhs: Mat4): this {\n    mat4sub(this.byteOffset, this.byteOffset, rhs.byteOffset);\n    return this;\n  }\n\n  public mul(m: Mat4): this {\n    mat4mul(this.byteOffset, m.byteOffset, this.byteOffset);\n    return this;\n  }\n\n  public scale(factor: number): this {\n    mat4scale(this.byteOffset, this.byteOffset, factor);\n    return this;\n  }\n\n  public transpose(): void {\n    mat4transpose(this.byteOffset, this.byteOffset);\n  }\n\n  public invert(): boolean {\n    return !!mat4invert(this.byteOffset, this.byteOffset);\n  }\n\n  public det(): number {\n    return mat4det(this.byteOffset);\n  }\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file +import{mat2identity,mat2add,mat2det,mat2frommat3,mat2invert,mat2mul,mat2scale,mat2sub,mat2transpose,mat3identity,mat3add,mat3det,mat3frommat2,mat3frommat4,mat3invert,mat3mul,mat3scale,mat3sub,mat3transpose,mat4identity,mat4add,mat4det,mat4frommat3,mat4invert,mat4mul,mat4scale,mat4sub,mat4transpose,normalmat3}from"../../wasm/index.js";import{ManagedFloat64Array}from"./memory.js";export class Mat2 extends ManagedFloat64Array{static identity(){return new Mat2(mat2identity())}static fromMat3(m){return new Mat2(mat2frommat3(m.byteOffset))}constructor(ptr){super(4,ptr)}add(rhs){mat2add(this.byteOffset,this.byteOffset,rhs.byteOffset);return this}sub(rhs){mat2sub(this.byteOffset,this.byteOffset,rhs.byteOffset);return this}mul(rhs){mat2mul(this.byteOffset,this.byteOffset,rhs.byteOffset);return this}scale(factor){mat2scale(this.byteOffset,this.byteOffset,factor);return this}transpose(){mat2transpose(this.byteOffset,this.byteOffset)}invert(){return!!mat2invert(this.byteOffset,this.byteOffset)}det(){return mat2det(this.byteOffset)}}export class Mat3 extends ManagedFloat64Array{static identity(){return new Mat3(mat3identity())}static fromMat2(m){return new Mat3(mat3frommat2(m.byteOffset))}static fromMat4(m){return new Mat3(mat3frommat4(m.byteOffset))}constructor(ptr){super(9,ptr)}add(rhs){mat3add(this.byteOffset,this.byteOffset,rhs.byteOffset);return this}sub(rhs){mat3sub(this.byteOffset,this.byteOffset,rhs.byteOffset);return this}mul(rhs){mat3mul(this.byteOffset,this.byteOffset,rhs.byteOffset);return this}scale(factor){mat3scale(this.byteOffset,this.byteOffset,factor);return this}transpose(){mat3transpose(this.byteOffset,this.byteOffset)}invert(){return!!mat3invert(this.byteOffset,this.byteOffset)}det(){return mat3det(this.byteOffset)}normalMat(){return!!normalmat3(this.byteOffset,this.byteOffset)}}export class Mat4 extends ManagedFloat64Array{static identity(){return new Mat4(mat4identity())}static fromMat3(m){return new Mat4(mat4frommat3(m.byteOffset))}constructor(ptr){super(16,ptr)}add(rhs){mat4add(this.byteOffset,this.byteOffset,rhs.byteOffset);return this}sub(rhs){mat4sub(this.byteOffset,this.byteOffset,rhs.byteOffset);return this}mul(rhs){mat4mul(this.byteOffset,this.byteOffset,rhs.byteOffset);return this}scale(factor){mat4scale(this.byteOffset,this.byteOffset,factor);return this}transpose(){mat4transpose(this.byteOffset,this.byteOffset)}invert(){return!!mat4invert(this.byteOffset,this.byteOffset)}det(){return mat4det(this.byteOffset)}} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["mat2identity","mat2add","mat2det","mat2frommat3","mat2invert","mat2mul","mat2scale","mat2sub","mat2transpose","mat3identity","mat3add","mat3det","mat3frommat2","mat3frommat4","mat3invert","mat3mul","mat3scale","mat3sub","mat3transpose","mat4identity","mat4add","mat4det","mat4frommat3","mat4invert","mat4mul","mat4scale","mat4sub","mat4transpose","normalmat3","ManagedFloat64Array","Mat2","identity","fromMat3","m","byteOffset","constructor","ptr","add","rhs","sub","mul","scale","factor","transpose","invert","det","Mat3","fromMat2","fromMat4","normalMat","Mat4"],"sources":["../../js/wasm/mat.ts"],"sourcesContent":["import {\n  mat2identity, mat2add, mat2det, mat2frommat3, mat2invert, mat2mul, mat2scale, mat2sub, mat2transpose,\n  mat3identity, mat3add, mat3det, mat3frommat2, mat3frommat4, mat3invert, mat3mul, mat3scale, mat3sub, mat3transpose,\n  mat4identity, mat4add, mat4det, mat4frommat3, mat4invert, mat4mul, mat4scale, mat4sub, mat4transpose, normalmat3,\n} from '../../wasm/index.js';\nimport { Indexable, Mat } from '../types.ts';\nimport { ManagedFloat64Array } from './memory.ts';\n\n/** A 2x2 matrix. */\nexport class Mat2 extends ManagedFloat64Array<4> implements Mat<2>, Indexable<4> {\n  public 0: number;\n  public 1: number;\n  public 2: number;\n  public 3: number;\n\n  /** Return an identity Mat2. */\n  public static identity(): Mat2 {\n    return new Mat2(mat2identity());\n  }\n\n  /** Return a Mat2 from Mat3. */\n  public static fromMat3(m: Mat3): Mat2 {\n    return new Mat2(mat2frommat3(m.byteOffset));\n  }\n\n  private constructor(ptr: number) {\n    super(4, ptr);\n  }\n\n  public add(rhs: Mat2): this {\n    mat2add(this.byteOffset, this.byteOffset, rhs.byteOffset);\n    return this;\n  }\n\n  public sub(rhs: Mat2): this {\n    mat2sub(this.byteOffset, this.byteOffset, rhs.byteOffset);\n    return this;\n  }\n\n  public mul(rhs: Mat2): this {\n    mat2mul(this.byteOffset, this.byteOffset, rhs.byteOffset);\n    return this;\n  }\n\n  public scale(factor: number): this {\n    mat2scale(this.byteOffset, this.byteOffset, factor);\n    return this;\n  }\n\n  public transpose(): void {\n    mat2transpose(this.byteOffset, this.byteOffset);\n  }\n\n  public invert(): boolean {\n    return !!mat2invert(this.byteOffset, this.byteOffset);\n  }\n\n  public det(): number {\n    return mat2det(this.byteOffset);\n  }\n}\n\n/** A 3x3 matrix. */\nexport class Mat3 extends ManagedFloat64Array<9> implements Mat<3>, Indexable<9> {\n  public 0: number;\n  public 1: number;\n  public 2: number;\n  public 3: number;\n  public 4: number;\n  public 5: number;\n  public 6: number;\n  public 7: number;\n  public 8: number;\n\n  /** Return an identity Mat3. */\n  public static identity(): Mat3 {\n    return new Mat3(mat3identity());\n  }\n\n  /** Return a Mat3 from Mat2. */\n  public static fromMat2(m: Mat2): Mat3 {\n    return new Mat3(mat3frommat2(m.byteOffset));\n  }\n\n  /** Return a Mat3 from Mat4. */\n  public static fromMat4(m: Mat4): Mat3 {\n    return new Mat3(mat3frommat4(m.byteOffset));\n  }\n\n  private constructor(ptr: number) {\n    super(9, ptr);\n  }\n\n  public add(rhs: Mat3): this {\n    mat3add(this.byteOffset, this.byteOffset, rhs.byteOffset);\n    return this;\n  }\n\n  public sub(rhs: Mat3): this {\n    mat3sub(this.byteOffset, this.byteOffset, rhs.byteOffset);\n    return this;\n  }\n\n  public mul(rhs: Mat3): this {\n    mat3mul(this.byteOffset, this.byteOffset, rhs.byteOffset);\n    return this;\n  }\n\n  public scale(factor: number): this {\n    mat3scale(this.byteOffset, this.byteOffset, factor);\n    return this;\n  }\n\n  public transpose(): void {\n    mat3transpose(this.byteOffset, this.byteOffset);\n  }\n\n  public invert(): boolean {\n    return !!mat3invert(this.byteOffset, this.byteOffset);\n  }\n\n  public det(): number {\n    return mat3det(this.byteOffset);\n  }\n\n  /** Coverts this to a normal matrix, which is the inverse transpose matrix. */\n  public normalMat(): boolean {\n    return !!normalmat3(this.byteOffset, this.byteOffset);\n  }\n}\n\n/** A 4x4 matrix. */\nexport class Mat4 extends ManagedFloat64Array<16> implements Mat<4>, Indexable<16> {\n  public 0: number;\n  public 1: number;\n  public 2: number;\n  public 3: number;\n  public 4: number;\n  public 5: number;\n  public 6: number;\n  public 7: number;\n  public 8: number;\n  public 9: number;\n  public 10: number;\n  public 11: number;\n  public 12: number;\n  public 13: number;\n  public 14: number;\n  public 15: number;\n\n  /** Return an identity Mat4. */\n  public static identity(): Mat4 {\n    return new Mat4(mat4identity());\n  }\n\n  /** Return a Mat4 from Mat3. */\n  public static fromMat3(m: Mat3): Mat4 {\n    return new Mat4(mat4frommat3(m.byteOffset));\n  }\n\n  private constructor(ptr: number) {\n    super(16, ptr);\n  }\n\n  public add(rhs: Mat4): this {\n    mat4add(this.byteOffset, this.byteOffset, rhs.byteOffset);\n    return this;\n  }\n\n  public sub(rhs: Mat4): this {\n    mat4sub(this.byteOffset, this.byteOffset, rhs.byteOffset);\n    return this;\n  }\n\n  public mul(rhs: Mat4): this {\n    mat4mul(this.byteOffset, this.byteOffset, rhs.byteOffset);\n    return this;\n  }\n\n  public scale(factor: number): this {\n    mat4scale(this.byteOffset, this.byteOffset, factor);\n    return this;\n  }\n\n  public transpose(): void {\n    mat4transpose(this.byteOffset, this.byteOffset);\n  }\n\n  public invert(): boolean {\n    return !!mat4invert(this.byteOffset, this.byteOffset);\n  }\n\n  public det(): number {\n    return mat4det(this.byteOffset);\n  }\n}\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/js/wasm/__tests__/mat.spec.ts b/js/wasm/__tests__/mat.spec.ts index f93eaeb..8cbd982 100644 --- a/js/wasm/__tests__/mat.spec.ts +++ b/js/wasm/__tests__/mat.spec.ts @@ -17,6 +17,64 @@ describe('Mat2', () => { m.set([1, 2, 3, 4]); expectArrayEqual(m, [1, 2, 3, 4]); }); + + test('add', () => { + const m = Mat2.identity(); + const m2 = Mat2.identity(); + m.set([29, 31, 37, 41]); + m2.set([43, 47, 53, 59]); + expectArrayEqual(m.add(m2), [72, 78, 90, 100]); + }); + + test('sub', () => { + const m = Mat2.identity(); + const m2 = Mat2.identity(); + m.set([29, 31, 37, 41]); + m2.set([43, 47, 53, 59]); + expectArrayEqual(m.sub(m2), [-14, -16, -16, -18]); + }); + + test('mul', () => { + const m = Mat2.identity(); + const m2 = Mat2.identity(); + m.set([1, 2, 3, 4]); + m2.set([5, 6, 7, 8]); + expectArrayEqual(m.mul(m2), [23, 34, 31, 46]); + }); + + test('scale', () => { + const m = Mat2.identity(); + m.set([1, 2, 3, 4]); + expectArrayEqual(m.scale(2), [2, 4, 6, 8]); + }); + + test('transpose', () => { + const m = Mat2.identity(); + m.set([1, 2, 3, 4]); + m.transpose(); + expectArrayEqual(m, [1, 3, 2, 4]); + }); + + test('det', () => { + const m = Mat2.identity(); + m.set([1, 2, 3, 4]); + expect(m.det()).toBe(-2); + }); + + test('invert', () => { + const m = Mat2.identity(); + m.set([1, 2, 3, 4]); + expect(m.invert()).toBe(true); + expectArrayEqual(m, [-2, 1, 1.5, -0.5]); + }); + + test('invert non-invertible', () => { + const data = [1, 2, 2, 4]; + const m = Mat2.identity(); + m.set(data); + expect(m.invert()).toBe(false); + expectArrayEqual(m, data); + }); }); describe('Mat3', () => { @@ -41,6 +99,79 @@ describe('Mat3', () => { m.set([1, 2, 3, 4, 5, 6, 7, 8, 9]); expectArrayEqual(m, [1, 2, 3, 4, 5, 6, 7, 8, 9]); }); + + test('add', () => { + const m = Mat3.identity(); + const m2 = Mat3.identity(); + m.set([1, 2, 3, 4, 5, 6, 7, 8, 9]); + m2.set([0, 9, 7, 2, 1, 6, 3, 1, 8]); + expectArrayEqual(m.add(m2), [1, 11, 10, 6, 6, 12, 10, 9, 17]); + }); + + test('sub', () => { + const m = Mat3.identity(); + const m2 = Mat3.identity(); + m.set([1, 2, 3, 4, 5, 6, 7, 8, 9]); + m2.set([0, 9, 7, 2, 1, 6, 3, 1, 8]); + expectArrayEqual(m.sub(m2), [1, -7, -4, 2, 4, 0, 4, 7, 1]); + }); + + test('mul', () => { + const m = Mat3.identity(); + const m2 = Mat3.identity(); + m.set([1, 2, 3, 4, 5, 6, 7, 8, 9]); + m2.set([0, 9, 7, 2, 1, 6, 3, 1, 8]); + expectArrayEqual(m.mul(m2), [85, 101, 117, 48, 57, 66, 63, 75, 87]); + }); + + test('scale', () => { + const m = Mat3.identity(); + m.set([1, 2, 3, 4, 5, 6, 7, 8, 9]); + expectArrayEqual(m.scale(2), [2, 4, 6, 8, 10, 12, 14, 16, 18]); + }); + + test('transpose', () => { + const m = Mat3.identity(); + m.set([1, 2, 3, 4, 5, 6, 7, 8, 9]); + m.transpose(); + expectArrayEqual(m, [1, 4, 7, 2, 5, 8, 3, 6, 9]); + }); + + test('det', () => { + const m = Mat3.identity(); + m.set([1, 0, 5, 2, 1, 6, 3, 4, 0]); + expect(m.det()).toBe(1); + }); + + test('invert', () => { + const m = Mat3.identity(); + m.set([1, 0, 5, 2, 1, 6, 3, 4, 0]); + expect(m.invert()).toBe(true); + expectArrayEqual(m, [-24, 20, -5, 18, -15, 4, 5, -4, 1]); + }); + + test('invert non-invertible', () => { + const data = [1, 0, 1, 0, 1, 0, 0, 0, 0]; + const m = Mat3.identity(); + m.set(data); + expect(m.invert()).toBe(false); + expectArrayEqual(m, data); + }); + + test('normalMat', () => { + const m = Mat3.identity(); + m.set([0, 0, 1, 1, 0, 0, 0, 1, 0]); + expect(m.normalMat()).toBe(true); + expectArrayEqual(m, [0, 0, 1, 1, 0, 0, 0, 1, 0]); + }); + + test('normalMat for non-invertible', () => { + const data = [1, 0, 1, 0, 1, 0, 0, 0, 0]; + const m = Mat3.identity(); + m.set(data); + expect(m.normalMat()).toBe(false); + expectArrayEqual(m, data); + }); }); describe('Mat4', () => { @@ -59,4 +190,62 @@ describe('Mat4', () => { m.set([1, 2, 3, 10, 4, 5, 6, 11, 7, 8, 9, 12, 13, 14, 15, 16]); expectArrayEqual(m, [1, 2, 3, 10, 4, 5, 6, 11, 7, 8, 9, 12, 13, 14, 15, 16]); }); + + test('add', () => { + const m = Mat4.identity(); + const m2 = Mat4.identity(); + m.set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]); + m2.set([0, 3, 2, 1, 7, 6, 5, 4, 9, 3, 2, 2, 0, 3, 3, 1]); + expectArrayEqual(m.add(m2), [1, 5, 5, 5, 12, 12, 12, 12, 18, 13, 13, 14, 13, 17, 18, 17]); + }); + + test('sub', () => { + const m = Mat4.identity(); + const m2 = Mat4.identity(); + m.set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]); + m2.set([0, 3, 2, 1, 7, 6, 5, 4, 9, 3, 2, 2, 0, 3, 3, 1]); + expectArrayEqual(m.sub(m2), [1, -1, 1, 3, -2, 0, 2, 4, 0, 7, 9, 10, 13, 11, 12, 15]); + }); + + test('mul', () => { + const m = Mat4.identity(); + const m2 = Mat4.identity(); + m.set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]); + m2.set([0, 3, 2, 1, 7, 6, 5, 4, 9, 3, 2, 2, 0, 3, 3, 1]); + expectArrayEqual(m.mul(m2), [46, 52, 58, 64, 134, 156, 178, 200, 68, 84, 100, 116, 55, 62, 69, 76]); + }); + + test('scale', () => { + const m = Mat4.identity(); + m.set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]); + expectArrayEqual(m.scale(2), [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32]); + }); + + test('transpose', () => { + const m = Mat4.identity(); + m.set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]); + m.transpose(); + expectArrayEqual(m, [1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15, 4, 8, 12, 16]); + }); + + test('det', () => { + const m = Mat4.identity(); + m.set([1, 1, 1, -1, 1, 1, -1, 1, 1, -1, 1, 1, -1, 1, 1, 1]); + expect(m.det()).toBe(-16); + }); + + test('invert', () => { + const m = Mat4.identity(); + m.set([1, 1, 1, -1, 1, 1, -1, 1, 1, -1, 1, 1, -1, 1, 1, 1]); + expect(m.invert()).toBe(true); + expectArrayEqual(m, [.25, .25, .25, -.25, .25, .25, -.25, .25, .25, -.25, .25, .25, -.25, .25, .25, .25]); + }); + + test('invert non-invertible', () => { + const data = [1, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0, 0, 9, 10, 11, 12]; + const m = Mat4.identity(); + m.set(data); + expect(m.invert()).toBe(false); + expectArrayEqual(m, data); + }); }); diff --git a/js/wasm/mat.ts b/js/wasm/mat.ts index 14c0874..fc25adf 100644 --- a/js/wasm/mat.ts +++ b/js/wasm/mat.ts @@ -1,7 +1,7 @@ import { mat2identity, mat2add, mat2det, mat2frommat3, mat2invert, mat2mul, mat2scale, mat2sub, mat2transpose, mat3identity, mat3add, mat3det, mat3frommat2, mat3frommat4, mat3invert, mat3mul, mat3scale, mat3sub, mat3transpose, - mat4identity, mat4add, mat4det, mat4frommat3, mat4invert, mat4mul, mat4scale, mat4sub, mat4transpose, + mat4identity, mat4add, mat4det, mat4frommat3, mat4invert, mat4mul, mat4scale, mat4sub, mat4transpose, normalmat3, } from '../../wasm/index.js'; import { Indexable, Mat } from '../types.ts'; import { ManagedFloat64Array } from './memory.ts'; @@ -37,8 +37,8 @@ export class Mat2 extends ManagedFloat64Array<4> implements Mat<2>, Indexable<4> return this; } - public mul(m: Mat2): this { - mat2mul(this.byteOffset, m.byteOffset, this.byteOffset); + public mul(rhs: Mat2): this { + mat2mul(this.byteOffset, this.byteOffset, rhs.byteOffset); return this; } @@ -101,8 +101,8 @@ export class Mat3 extends ManagedFloat64Array<9> implements Mat<3>, Indexable<9> return this; } - public mul(m: Mat3): this { - mat3mul(this.byteOffset, m.byteOffset, this.byteOffset); + public mul(rhs: Mat3): this { + mat3mul(this.byteOffset, this.byteOffset, rhs.byteOffset); return this; } @@ -122,6 +122,11 @@ export class Mat3 extends ManagedFloat64Array<9> implements Mat<3>, Indexable<9> public det(): number { return mat3det(this.byteOffset); } + + /** Coverts this to a normal matrix, which is the inverse transpose matrix. */ + public normalMat(): boolean { + return !!normalmat3(this.byteOffset, this.byteOffset); + } } /** A 4x4 matrix. */ @@ -167,8 +172,8 @@ export class Mat4 extends ManagedFloat64Array<16> implements Mat<4>, Indexable<1 return this; } - public mul(m: Mat4): this { - mat4mul(this.byteOffset, m.byteOffset, this.byteOffset); + public mul(rhs: Mat4): this { + mat4mul(this.byteOffset, this.byteOffset, rhs.byteOffset); return this; }