Tensor: Standardize Vector2, Vector3, Vector4, Color3, Color4, Quaternion, and Matrix #14235

james-pre · 2023-08-30T22:55:36Z

Discussion of this PR is available on the Babylon.js forum in this thread.
Resolves #14201

TL;DR:

Tensor would be added, which provides a standardized API for interacting with vectors, colors, matrices, quaternions, etc.

Rational

This PR aims to create a standard interface from which various math constructs are defined.

Take the current difference in behavior between vectors and colors:

const c1 = Color3.Random(),
	c2 = Color3.Random(),
	c3 = new Color3(),
	v1 = Vector3.Random(),
	v2 = Vector3.Random(),
	v3 = new Vector3();

c1.addToRef(c2, c3) === c3 // false
v1.addToRef(v2, v3) === v3 // true

And the lack of a method that should exist in Color3:

const v1 = Vector3.Random(),
	v2 = Vector3.Random(),
	c1 = Color3.Random(),
	c2 = Color3.Random();


v1.addInPlace(v2) // ok
c1.addInPlace(c2) // ReferenceError! addInPlace does not exist

Tensor provides a single interface for tensor-like objects which users can depend on. By having tensor-like classes implement Tensor, it ensures that all the methods exist and have the same and correct behavior. It is meant for organization and standardization.

Semantics

Note:

CurrentClass is a placeholder for a class that implements Tensor. In fields, it is the current class.
Tensor and its related types will be defined in src/Maths/tensor.ts unless otherwise noted
Signatures are shown, not implementation.
The shown signatures are not necessarily the same as implementation (e.g. Signature<T extends number> may be shown when it is implemented as Signature<T> = T extends number ? ... : never

Status

* May not be included in the proposal

Vector

Defined in src/Maths/math.vector.ts

This PR includes Vector from #13699. Vector extends Tensor and adds normalization methods, length, and lengthSquared. It is implemented by Vector2, Vector3, and Vector4.

Tuple manipulation and math types

Defined in src/types.ts
The following types are being added for compile-time math and tuple manipulation, which is necessary for MultidimensionalArray. They are included as a single block for brevity.

type Empty = [];
type Shift<T extends unknown[]>;
type First<T extends unknown[]>;
type Unshift<T extends unknown[], A>;
type Pop<T extends unknown[]>;
type Last<T extends unknown[]>;
type Push<T extends unknown[], A>;
type Concat<A extends unknown[], B extends unknown[]>;
type Remove<A extends unknown[], B extends unknown[]>;
type Length<T extends unknown[]>;
type FromLength<N extends number>;
type Increment<N extends number>;
type Decrement<N extends number>;
type Add<A extends number, B extends number>;
type Subtract<A extends number, B extends number>;
type Member<T, D>;
type Flatten<A extends unknown[], D>;
type MultidimensionalArray<T, D extends number>
type Tuple<T, N extends number>;
type FlattenTuple<T>;
type IsTuple<T>;

Constructor

Defined in src/types.ts

type Constructor<C extends new (...args: any[]) => any, I extends InstanceType<C>>

Defines a single type for constructors. This replaces Vector2Constructor, Vector3Constructor, Vector4Constructor, QuaternionConstructor, and MatrixConstructor.

Instead of using Vector3Constructor<this>, you would instead use Constructor<typeof Vector3, this>. The typeof is needed to get the type for the class instead of the instance, and can't be done inside the type since Typescript prohibits taking the typeof a type.

MultidimensionalArray

Defined in src/types.ts

type MultidimensionalArray<T, D extends number>

Represents a multidimensional array of T with depth D.

TensorValue

type TensorValue<T> = T extends Tensor<infer V> ? V : never;

Tensor

declare class Tensor<V>

Tensor is a declare class for tensor-like classes to implement.

Tensor includes all of the methods in Vector from #13699. This includes

Math operations (add, subtract, multiply, divide, scale, ...)
Array conversion (fromArray, toArray, asArray, ...)
- Since the type parameter is no longer assignable to number[], the return type for array-related methods is number[]. See Tensor.value
Transferring (clone, copyFrom, copyFromFloats, ...)
The above methods' InPlace, ToRef, FromFloats, etc.

It adds or changes the following methods:

Tensor.dimension

public abstract dimension: number[];

dimension is the mathematical dimension² of the tensor. In dynamic tensor types, it can be defined as a getter.

Example:

const vec3 = new Vector3(),
	vec4 = new Vector4(),
	matrix = new Matrix();

vec3.dimension // [3]
vec4.dimension // [4]
matrix.dimension // [4, 4]

Tensor.From

public static From(source: Tensor, fillValue: number = 0): CurrentClass;

From creates a new instance of CurrentClass from source.
source: The tensor to copy data from.
fillValue: The value to use for filling empty parts of the resulting CurrentClass.

Example:

const vec3 = new Vector3(1, 2, 3);
const vec4 = Vector4.From(vec3, 4); // { 1, 2, 3, 4 }
const matrix = Matrix.From(vec3, 0); // this is possible!

Additionally, From could be changed to From(...args: [...Tensor[], number]): CurrentClass to allow multiple inputs. This is better understood by this invalid Typescript signature (since rest parameters must be last):

public static From(...source: Tensor[], fillValue: number = 0): CurrentClass;

🛈 Implementations may write their own conversion code or use convertTensor.

Tensor.as

public as<T extends typeof Tensor>(type: T, fillValue: number = 0): InstanceType<T>;

as creates an instance of type from an instance of CurrentClass.
type: The class to create an instance of.
fillValue: The value to use for filling empty parts of the resulting instance.

Example:

const vec3 = new Vector3(1, 2, 3);
const vec4 = vec3.as(Vector4, 4); // { 1, 2, 3, 4 }
const matrix = vec3.as(Matrix, 0);

🛈 Implementations may write their own conversion code or use convertTensor.

Tensor.sum

public sum(): number;

sum return the sum of the components of the Tensor.

Example:

const vec3 = new Vector3(1, 2, 3),
	vec4 = new Vector4(4, 5, 6, 7),
	matrix = new Matrix();

vec3.sum() // 6
vec4.sum() // 22
matrix.sum() // 0

⚠ The return value of the lengthSquared or length method of vectors is not the same as the return value of sum.

Tensor.rank

public abstract rank: number;

The rank of a tensor is the number of indices required to uniquely select each element of the tensor.

Example:

const vec3 = new Vector3(),
	matrix = new Matrix();

vec3.rank // 1
matrix.rank // 2

🛈 The rank of a Tensor is the same as its dimension.length.

Tensor.value

public get value(): V;
public set value(value: V): void;

value is the values of the tensor in a multidimensional array with the type V (the type parameter of the class). Unlike dimension, this must be implemented as a getter and setter.

Example:

const vec3 = new Vector3(),
	matrix = new Matrix();

vec3.value
// [0, 0, 0]

matrix.value
// [ [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ] ]

vec3.value = [ 1, 2, 3 ];
vec3.x // 1

isTensor

function isTensor<V>(value: unknown): value is Tensor<V>;

Checks if a value is a Tensor.
Example:

const vec3 = new Vector3();
isTensor(vec3) // true
isTensor(vec3.value) // false
isTensor([1, 2, 3]) // false
isTensor(0) // false
isTensor(null) // false

isTensorValue

function isTensorValue<T>(value: unknown): value is TensorValue<T>;

Checks if a value is a TensorValue.
Example:

const vec3 = new Vector3();
isTensorValue<1>(vec3) // false
isTensorValue<Vector3>(vec3.value) // true
isTensorValue<1>([1, 2, 3]) // true
isTensorValue<0>([1, 2, 3]) // false
isTensorValue<1>(0) // false
isTensorValue<0>(0) // true
isTensorValue<1>(null) // false

getTensorDimension

function getTensorDimension(value: Tensor | TensorValue): number[];

getTensorDimension returns the mathimatical dimension² of value, similar to Tensor.dimension. If value is not a Tensor or TensorValue, it will throw a TypeError

🛈 Dynamic Tensor based classes should use getTensorDimension for their dimension implementations. Fixed-dimension Tensor sub-classes need not use getTensorDimension.

(optional) convertTensor

function convertTensor<T extends  typeof Tensor>(TensorClass: T, tensor: Tensor, fillValue: number = 0): InstanceType<T>;

Creates a new T with the values of tensor. Unlike Tensor.as, it performs more error checking and does not need a starting instance (and therefore avoids the dreaded 'methodName' does not exist on undefined error).

Behavior changes

The Color3 and Color4 methods multiplyToRef, scaleToRef, scaleAndAddToRef, clampToRef, addToRef, and subtractToRef have had their return types changed from this to the reference instance.

Considerations

Static methods related to data manipulation (e.g. Add, Normalize, Lerp) and non-static normalization methods are outside the scope of this PR. While Tensor may include them in the future, this PR does not
This PR does not include a dimensionally dynamic Tensor.
Performance: Since Tensor is defined using the declare class and classes that follow Tensor do so using the implements keyword, there are no runtime changes to Tensor-based classes.
Bundle size: The JS bundle size will increase only by the size of the added functions (isTensor, getTensorDimension, etc.). The TS declaration size will also increase slightly due to Tensor and the added utility types.
Maintenance: Since there is no implementation (just a class declaration), the extra maintenance is minimized to member signatures.

Questions

For the BabylonJS team concerning the PR

What other classes (e.g. Size) would be included and standardized?

FAQs

What use cases does this proposal have?

Tensor is not intended to be used by users. It is meant for internal organization and standardization. The functions (isTensor, getTensorDimension, etc.) are intended to be public and may be used by users. Their use cases may be inferred from their descriptions.

What is the difference between this and #13699?

The capabilities of the type. Vector supports any rank 1 tensor. Tensor generalizes Vector, and supports any rank tensor. A mathematical vector can be represented as number[]. A mathematical tensor can be represented as a number, number[], number[][], and so on. This table highlights the capability:

tensor rank	TS representation	BJS class (if exists)
1	`number[]`	`Vector`
1	`[number, number]`	`Vector2`
1	`[number, number, number]`	`Vector3`, `Color3`
1	`[number, number, number, number]`	`Vector4`, `Color4`, `Quaternion`
2	`number[][]`	`Matrix`
3	`number[][][]`
4	`number[][][][]`
N	`TensorValue`

How is incompatibility managed? Are incompatible classes dropped or are they modified to follow `Tensor`?

Any classes included will be modified to follow the standard. In many cases, the diverging behavior makes the engine difficult to use, and changing the claseses to follow the Tensor standard benefits end users.

https://www.typescriptlang.org/play?#code/JYOwLgpgTgZghgYwgAgJIDUILAeygZTDjGAWQG8AoZG5ECAdwAoBKALjU2zwG5rkAwgBs4AWwAOrDhiy4ofAL6VKoSLEQoZ3KBX5wAJvqmdZvSksoIcIAM5hkXOQGZpjvIWKlkAXmQIRNjbIwBJCEKIQ4EFacro0VrZgUACu2qwUSjQGRuwm2nG0UBBgyVAgyGAAFsA2PMj8mch2nmTCYpK5MXgFNEUlZXSMDqZQTqx8NEoWCXbIAG4+gwzD2mMsfHMAdNnjlG6jm20S40A

I am not the biggest fan of this way, but this is the only way (I know :-)) to define static members for a class. @sebavan - we can discuss this offline and see whether or not this solves the issue.

james-pre · 2024-02-20T18:08:24Z

@sebavan @RaananW,

I've separated the instance and static sides into interfaces for both Tensor and Vector, as described in (B) in my last message. I also mentioned that using interfaces comes with the benefit of allowing a type parameter on the static side, which is very useful.

I also looked into defining Tensor.constructor (instance property) as TensorStatic<this>, which would narrow the type of this.constructor in all Tensor subclass instance methods to the class (again, very useful). This does not work unfortunately as TS narrows the type of constructor to something not very useful, which is not compatible with the static side interface. This unfortunately means we need to keep the this.constructor as ... type assertions throughout the instance code.

I apologize for not responding sooner @RaananW, I was experimenting with the constructor property and types.

The only way I know how to manage static members with interfaces is this

The way I prefer, which also preserves the class syntax, is with the satisfies keyword, like in this example:

export class Vector2 implements Vector<Tuple<number, 2>> {
    // ...
}
Vector2 satisfies VectorStatic<Vector2>;

Please note that the left-hand side of satisfies is a value and the right-hand side is a type.

Added Vector2 and Vector3 RandomToRef Removed DistanceOfPointFromSegment from Vector Added static side checks to Vector2 and Vector3

bjsplat · 2024-02-20T20:53:31Z

Visualization tests for WebGPU (Experimental)
Important - these might fail sporadically. This is an optional test.

https://babylonsnapshots.z22.web.core.windows.net/refs/pull/14235/merge/testResults/webgpuplaywright/index.html

Moved Clamp and ClampToRef from Vector to Tensor

sebavan · 2024-02-27T21:11:12Z

Let s use @RaananW proposal to do it instead of satisfies as it has only been introduced really late in TS and could create compat issues with the users I guess.

james-pre · 2024-02-28T13:31:36Z

@sebavan,

Typescript < 4.9 is already not usable with BJS so using satisfies should be fine. When trying to npm run build:dev with TS ~4.8.0:

packages/dev/core/src/Engines/WebGPU/webgpuTextureManager.ts:1164:99 - error TS2304: Cannot find name 'VideoFrame'.

1164         imageBitmap: ImageBitmap | Uint8Array | ImageData | HTMLImageElement | HTMLVideoElement | VideoFrame | HTMLCanvasElement | OffscreenCanvas,
                                                                                                       ~~~~~~~~~~

packages/dev/core/src/Engines/WebGPU/webgpuTextureManager.ts:1275:106 - error TS2304: Cannot find name 'VideoFrame'.

1275             imageBitmap = imageBitmap as ImageBitmap | ImageData | HTMLImageElement | HTMLVideoElement | VideoFrame | HTMLCanvasElement | OffscreenCanvas;

RaananW · 2024-02-28T17:49:38Z

@sebavan,

Typescript < 4.9 is already not usable with BJS so using satisfies should be fine. When trying to npm run build:dev with TS ~4.8.0:

packages/dev/core/src/Engines/WebGPU/webgpuTextureManager.ts:1164:99 - error TS2304: Cannot find name 'VideoFrame'.

1164         imageBitmap: ImageBitmap | Uint8Array | ImageData | HTMLImageElement | HTMLVideoElement | VideoFrame | HTMLCanvasElement | OffscreenCanvas,
                                                                                                       ~~~~~~~~~~

packages/dev/core/src/Engines/WebGPU/webgpuTextureManager.ts:1275:106 - error TS2304: Cannot find name 'VideoFrame'.

1275             imageBitmap = imageBitmap as ImageBitmap | ImageData | HTMLImageElement | HTMLVideoElement | VideoFrame | HTMLCanvasElement | OffscreenCanvas;

I am not a big fan of any of these ways. Each way of validating statics has its downside. the downside of satisfies is that it fails not as part of the class. It's an assertion line (i know you can claim any typing is basically assertion). So the error is shown during the assertion, and not during the class declaration.

The typescript version that Seb mentioned is not necessarily the version we use to compile the framework, it is the language that typescript developers can use. If not using WebGPU you would be able to continue using the same typescript version that you were using, if that's your decision. It is also possible to add the definition of the missing declaration. However, satisfies is a typescript keyword that doesn't allow it. We try our best not to do that.

james-pre · 2024-02-29T13:27:15Z

Unfortunately using const Class: StaticSide = class { ... will not work since it is an assignment. This means that any members present on the static side of the class will not be known by TS in the Class variable, since it is declared as StaticSide. For example:

interface StaticSide {
    DoSomething(): void;
}

const Class: StaticSide = class {
    DoSomething() {
        // ...
    }
    
    OtherThing() {
        // ...
    }
}

Class.OtherThing(); // <-- Error! OtherThing does not exist on StaticSide

This can be solved by using a separate variable though:

interface StaticSide { /* ... */ }
export class Class { /* ... */ }

/*
This does not change the type of Class.
It is also not exported
Because declare is used this will not exist at runtime
*/
declare const $typecheck$Class: StaticSide = Class;
```

RaananW · 2024-02-29T15:48:30Z

Unfortunately using const Class: StaticSide = class { ... will not work since it is an assignment. This means that any members present on the static side of the class will not be known by TS in the Class variable, since it is declared as StaticSide. For example:
interface StaticSide {
    DoSomething(): void;
}

const Class: StaticSide = class {
    DoSomething() {
        // ...
    }
    
    OtherThing() {
        // ...
    }
}

Class.OtherThing(); // <-- Error! OtherThing does not exist on StaticSide
This can be solved by using a separate variable though:
interface StaticSide { /* ... */ }
export class Class { /* ... */ }

/*
This does not change the type of Class.
It is also not exported
Because declare is used this will not exist at runtime
*/
declare const $typecheck$Class: StaticSide = Class;

have you seen this -

https://www.typescriptlang.org/play?#code/JYOwLgpgTgZghgYwgAgJIDUILAeygZTDjGAWQG8AoZG5ECAdwAoBKALjU2zwG5rkAwgBs4AWwAOrDhiy4ofAL6VKoSLEQoZ3KBX5wAJvqmdZvSksoIcIAM5hkXOQGZpjvIWKlkAXmQIRNjbIwBJCEKIQ4EFacro0VrZgUACu2qwUSjQGRuwm2nG0UBBgyVAgyGAAFsA2PMj8mch2nmTCYpK5MXgFNEUlZXSMDqZQTqx8NEoWCXbIAG4+gwzD2mMsfHMAdNnjlG6jm20S40A

Of course, if you implement it the way you showed it wouldn't work :-)

Again - there is no good solution here. I am, in general, not in favor of any of those solutions. I have the least resistance to this solution.

james-pre · 2024-02-29T16:54:59Z

Since Vector3 (as an example) is a proper superset of Vector (i.e. Vector3 contains members Vector does not), the method you showcase will not work. Here is an example analogous to the real Vector3:

https://www.typescriptlang.org/play?#code/JYOwLgpgTgZghgYwgAgGoQWA9lAymOMYBZAbwChkrkQIB3ACgEoAuNDbKAbkuQGEANnAC2AB2Zt0mHDwC+5cqEixEKKZzK84AE20T207uXnkEWEAGcwBzgGZJHHPkLFkAXmQIhFizZy3kYDEBCGEIcF91HE0qM0swKABXQ2YyeSodPVY-KBjqKAgwRKgQZDAAC2ALLmRedOQrFxJBEXFsqNyKamQCopKaehzbZh4qesaiEgB5Cuh9DoCu-MLi0to6IZG64wU4q2QAN3cBjYWtg4A6TK2Fi5axG8coWwuZ8rmmLiA

sebavan · 2024-02-29T22:09:21Z

What is the issue with this one (besides the ridiculous syntax :-) )? https://www.typescriptlang.org/play?#code/C4TwDgpgBAysCGwCWBjAkgWzAGwhiAdsAM4A8aUEAHsIQCbFQEQDuUAFAHTfwBOA5sQBcUeARABtALoBKKAF4AfKPEAaKAGFKNeozTL5UNAWIICKCABVwEcooDcAKEdIiEXgDN4FqADUIKMAA9rxwiKhQAN6OULFMrOwyIv6BIU6xGtjwWInJAcG8TgC+zq60nt7QKQVRMaJ0dLl++WmOJY4oWcSM1SEAzFBIWLj4RIxhyOjDeIQkpL2hCJPqoJBBHs2pvH3K0bEoQSbAvACuW4lRJbHwDU0LtXFQvBDAJ7wEUMAAFkjE9lB1K5QUzhFCaLI5JKbGp7OLPV7veJsBZ9RLpKBAkGTKAAeW+7juLW2DzhLzeH2YyKJqJk6JK7U68G60P6ADkgsYQeZoEMcDMxrAlqhMHzRnMFhNUCsbOsWdt2ZyzBZdnUDkdTuc5JFMUKwZlsmBCVsSbF4eSkXKaXS6liInivgSoSiTU8yYjKZa0YC2s5GcyUezJWDeSNZuNdSLQ2N5kSg9K1hsA0Egyr9odTBqChdtXUbo0nUSXWbEd9fv9vbFbWD7Y68lsBrDTW6KaxPbTvQz08AoAA3BQWlFenucPNelGcfWQpzjmu8NFAA

I double checked and satisfies does not appear in .d.ts so at least static thingies do not pollute emitted runtime code.

The only issue is the lack of detailed error message for us in dev:

RaananW · 2024-03-01T16:21:46Z

I'll be honest - this discussion is way too deep for something we won't change for a long time :-)

Whatever fits. Satisfies as assertion feels a bit off, but typescript does support it. Other things are as hacky as it is. I am fine with satisfies (in THIS case) for the same reason as I wrote above - Vectors won't change any time soon.

@dr-vortex - I am getting to the last question on my side, and it is perf. Let's run a few more perf tests, sharing what we use to run them, to know 100% we don't hurt anything (and maybe even improve a bit). This won't be affected by any interface/satisfies changes.

deltakosh · 2024-03-04T18:38:26Z

I'm for it! Let's merge it

james-pre · 2024-03-05T00:06:34Z

@sebavan,

If you have no other concerns could you please approve the PR (it currently says you are requesting changes)? Thank you very much!

sebavan · 2024-03-05T00:13:46Z

Waiting on @RaananW perf check so it prevents accidental merge

RaananW · 2024-03-05T17:14:03Z

@sebavan - want to resolve your review? there are still open change requests

sebavan · 2024-03-05T18:40:16Z

@RaananW approved but let us know your perf results

RaananW · 2024-03-05T19:41:21Z

@RaananW approved but let us know your perf results

Every scene I have tested was on par with the current implementation. I tested heavy scenes (like the performance priority PG and the physics stress testing), and the PG i pasted before testing the function implementations directly (including creation and basic math).
There was no perf bottleneck from the vector implementation when profiling any of the scenes.
I am pressing the merge button :-)

james-pre and others added 5 commits August 30, 2023 17:09

Added new types

35af7f2

Added Member, Flatten, and tensor

0f5e219

Updated classes in vector.ts to use Constructor

09ca803

Removed TensorValue and fixed comments

bd84e4a

Fixed wikipedia link

dfeb3b1

james-pre added 3 commits August 31, 2023 13:55

Added Tensor to vector and color classes

78fc212

Added FlattenTuple

Added IsTuple types

1438578

Fixed Flatten Added comment for Vector Formatting

Added public to Tensor and Vector members

ab26305

james-pre and others added 3 commits September 5, 2023 16:51

Fixed types being or not being DeepImmutable

f6fe9da

Formatting

1e989fd

Added Tuple

9f9e655

kzhsw reviewed Sep 8, 2023

View reviewed changes

packages/dev/core/src/Maths/math.color.ts Outdated Show resolved Hide resolved

kzhsw reviewed Sep 11, 2023

View reviewed changes

packages/dev/core/src/Maths/math.vector.ts Outdated Show resolved Hide resolved

james-pre added 2 commits September 11, 2023 13:03

Updated arrayTools to use new Tuple type

9fda9b5

Updated to use object.defineProperty for dimension

1083709

kzhsw reviewed Sep 12, 2023

View reviewed changes

packages/dev/core/src/Maths/math.color.ts Outdated Show resolved Hide resolved

kzhsw reviewed Sep 12, 2023

View reviewed changes

packages/dev/core/src/Maths/math.color.ts Outdated Show resolved Hide resolved

Fixed dimension values

ecf9981

james-pre added 2 commits September 12, 2023 13:32

Added Dimension

df6d705

Updated MultidimensionalArray to correctly handle nesting

Fixed Dimension import

94bdb99

sebavan mentioned this pull request Nov 10, 2023

Dot normal angle #14511

Merged

james-pre and others added 3 commits November 10, 2023 08:39

Fixed Tensor not working with non number[] types

57a238e

Added RecursiveArray

Fixed equalsToFloats not using Flatten

1474e02

Made Matrix Tensor-compatible

21b6534

Seperated instance and static of Tensor and Vector into interfaces

24cd34a

Fixed some type paramters

Added TensorStatic.prototype

266017c

james-pre added 2 commits February 20, 2024 13:49

Removed type parameters in Tensor and Vector methods

0691ccf

Added Vector2 and Vector3 RandomToRef Removed DistanceOfPointFromSegment from Vector Added static side checks to Vector2 and Vector3

Added Vector4 static side

60f0496

Added static side to Quaternion

2bd3676

Moved Clamp and ClampToRef from Vector to Tensor

james-pre added 2 commits March 2, 2024 08:55

Merge branch 'master' into tensor

55efc41

Formatting

c3764d8

deltakosh approved these changes Mar 4, 2024

View reviewed changes

sebavan approved these changes Mar 5, 2024

View reviewed changes

RaananW added the new feature label Mar 5, 2024

RaananW merged commit 9258609 into BabylonJS:master Mar 5, 2024
11 checks passed

james-pre deleted the tensor branch March 5, 2024 22:55

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Tensor: Standardize Vector2, Vector3, Vector4, Color3, Color4, Quaternion, and Matrix #14235

Tensor: Standardize Vector2, Vector3, Vector4, Color3, Color4, Quaternion, and Matrix #14235

james-pre commented Aug 30, 2023 •

edited

Loading

bjsplat commented Aug 30, 2023

bjsplat commented Aug 30, 2023

RaananW commented Sep 4, 2023

james-pre commented Sep 12, 2023

jstroh commented Sep 13, 2023

GuoBinyong commented Nov 10, 2023

bjsplat commented Feb 20, 2024

RaananW commented Feb 20, 2024 •

edited

Loading

james-pre commented Feb 20, 2024

bjsplat commented Feb 20, 2024

sebavan commented Feb 27, 2024

james-pre commented Feb 28, 2024 •

edited

Loading

RaananW commented Feb 28, 2024

james-pre commented Feb 29, 2024

RaananW commented Feb 29, 2024

james-pre commented Feb 29, 2024

sebavan commented Feb 29, 2024

RaananW commented Mar 1, 2024

deltakosh commented Mar 4, 2024

james-pre commented Mar 5, 2024

sebavan commented Mar 5, 2024

RaananW commented Mar 5, 2024

sebavan commented Mar 5, 2024

RaananW commented Mar 5, 2024

Tensor: Standardize Vector2, Vector3, Vector4, Color3, Color4, Quaternion, and Matrix #14235

Tensor: Standardize Vector2, Vector3, Vector4, Color3, Color4, Quaternion, and Matrix #14235

Conversation

james-pre commented Aug 30, 2023 • edited Loading

TL;DR:

Rational

Semantics

Note:

Status

(optional) convertTensor

Considerations

Questions

FAQs

What use cases does this proposal have?

What is the difference between this and #13699?

How is incompatibility managed? Are incompatible classes dropped or are they modified to follow Tensor?

Further reading

bjsplat commented Aug 30, 2023

bjsplat commented Aug 30, 2023

RaananW commented Sep 4, 2023

james-pre commented Sep 12, 2023

jstroh commented Sep 13, 2023

GuoBinyong commented Nov 10, 2023

bjsplat commented Feb 20, 2024

RaananW commented Feb 20, 2024 • edited Loading

james-pre commented Feb 20, 2024

bjsplat commented Feb 20, 2024

sebavan commented Feb 27, 2024

james-pre commented Feb 28, 2024 • edited Loading

RaananW commented Feb 28, 2024

james-pre commented Feb 29, 2024

RaananW commented Feb 29, 2024

james-pre commented Feb 29, 2024

sebavan commented Feb 29, 2024

RaananW commented Mar 1, 2024

deltakosh commented Mar 4, 2024

james-pre commented Mar 5, 2024

sebavan commented Mar 5, 2024

RaananW commented Mar 5, 2024

sebavan commented Mar 5, 2024

RaananW commented Mar 5, 2024

james-pre commented Aug 30, 2023 •

edited

Loading

How is incompatibility managed? Are incompatible classes dropped or are they modified to follow `Tensor`?

RaananW commented Feb 20, 2024 •

edited

Loading

james-pre commented Feb 28, 2024 •

edited

Loading