Remove redundant _isDirty sets (#17407)

Vector **classes** already set _isDirty to true when setting individual
properties like `x`, `y`, and `z`, so the _isDirty handling from the
previous change is not actually needed. Keeping the tests but removing
the _isDirty-related validation.

Author: kircher1

packages/dev/core/src/Maths/math.like.ts

@@ -34,17 +34,11 @@ export interface IVector3Like extends IVector2Like {
 /**
  * @internal
  */
-export interface IDirtyFlagLike {
-    _isDirty?: boolean;
-}
-
-/**
- * @internal
- */
-export interface IVector3LikeInternal extends IDirtyFlagLike {
+export interface IVector3LikeInternal {
     _x: number;
     _y: number;
     _z: number;
+    _isDirty?: boolean;
 }
 
 /**

packages/dev/core/src/Maths/math.vector.functions.ts

@@ -1,14 +1,8 @@
 import { Clamp } from "./math.scalar.functions";
 import type { DeepImmutable } from "../types";
-import type { IDirtyFlagLike, IQuaternionLike, IVector2Like, IVector3Like, IVector4Like } from "./math.like";
+import type { IQuaternionLike, IVector2Like, IVector3Like, IVector4Like } from "./math.like";
 import { Quaternion, Vector3 } from "./math.vector";
 
-function SetDirtyFlag(x: IDirtyFlagLike) {
-    if (x._isDirty !== undefined) {
-        x._isDirty = true;
-    }
-}
-
 /**
  * Creates a string representation of the IVector2Like
  * @param vector defines the IVector2Like to stringify
@@ -72,49 +66,43 @@ export function Vector3Distance(a: DeepImmutable<IVector3Like>, b: DeepImmutable
 
 /**
  * Sets the given floats into the result.
- * Marks the result as dirty if an `_isDirty` flag is defined on the object.
  * @param x defines the x coordinate
  * @param y defines the y coordinate
  * @param z defines the z coordinate
- * @param result defines the target vector
+ * @param result defines the result vector
  * @returns the result vector
  */
-export function Vector3FromFloatsToRef<T extends IVector3Like & IDirtyFlagLike>(x: number, y: number, z: number, result: T): T {
+export function Vector3FromFloatsToRef<T extends IVector3Like>(x: number, y: number, z: number, result: T): T {
     result.x = x;
     result.y = y;
     result.z = z;
-    SetDirtyFlag(result);
     return result;
 }
 
 /**
  * Stores the scaled values of a vector into the result.
- * Marks the result as dirty if an `_isDirty` flag is defined on the object.
  * @param a defines the source vector
  * @param scale defines the scale factor
- * @param result defines the target vector
+ * @param result defines the result vector
  * @returns the scaled vector
  */
-export function Vector3ScaleToRef<T extends IVector3Like & IDirtyFlagLike>(a: DeepImmutable<IVector3Like>, scale: number, result: T): T {
+export function Vector3ScaleToRef<T extends IVector3Like>(a: DeepImmutable<IVector3Like>, scale: number, result: T): T {
     result.x = a.x * scale;
     result.y = a.y * scale;
     result.z = a.z * scale;
-    SetDirtyFlag(result);
     return result;
 }
 
 /**
  * Scales the current vector values in place by a factor.
- * Marks the result as dirty if an `_isDirty` flag is defined on the object.
  * @param vector defines the vector to scale
  * @param scale defines the scale factor
- * @returns the input scaled vector
+ * @returns the scaled vector
  */
-export function Vector3ScaleInPlace<T extends IVector3Like & IDirtyFlagLike>(vector: T, scale: number): T {
+export function Vector3ScaleInPlace<T extends IVector3Like>(vector: T, scale: number): T {
     vector.x *= scale;
     vector.y *= scale;
     vector.z *= scale;
-    SetDirtyFlag(vector);
     return vector;
 }
 

packages/dev/core/test/unit/Math/babylon.math.vector.functions.test.ts

@@ -2,33 +2,26 @@ import { Vector3FromFloatsToRef, Vector3ScaleInPlace, Vector3ScaleToRef } from "
 
 describe("Vector functions tests", () => {
     describe("Vector3", () => {
-        it("writes floats into result and honors dirty flag", () => {
-            const target = { x: 0, y: 0, z: 0, _isDirty: false };
-            const result = Vector3FromFloatsToRef(7, 8, 9, target);
-            expect(result).toBe(target);
-            expect(target).toEqual({ x: 7, y: 8, z: 9, _isDirty: true });
-        });
-
-        it("does not create a dirty flag when one is absent", () => {
+        it("writes floats into result", () => {
             const target = { x: 0, y: 0, z: 0 };
-            const result = Vector3FromFloatsToRef(1, 2, 3, target);
+            const result = Vector3FromFloatsToRef(7, 8, 9, target);
             expect(result).toBe(target);
-            expect(Object.prototype.hasOwnProperty.call(target, "_isDirty")).toBe(false);
+            expect(target).toEqual({ x: 7, y: 8, z: 9 });
         });
 
-        it("scales to ref and sets the dirty flag", () => {
+        it("scales to ref", () => {
             const target = { x: 1, y: 2, z: 3 };
-            const result = Vector3ScaleToRef(target, 2, { x: 0, y: 0, z: 0, _isDirty: false });
+            const result = Vector3ScaleToRef(target, 2, { x: 0, y: 0, z: 0 });
             expect(result).not.toBe(target);
             expect(target).toEqual({ x: 1, y: 2, z: 3 });
-            expect(result).toEqual({ x: 2, y: 4, z: 6, _isDirty: true });
+            expect(result).toEqual({ x: 2, y: 4, z: 6 });
         });
 
-        it("scales in place and sets the dirty flag", () => {
-            const vector = { x: -1, y: 2, z: -3, _isDirty: false };
+        it("scales in place", () => {
+            const vector = { x: -1, y: 2, z: -3 };
             const result = Vector3ScaleInPlace(vector, 3);
             expect(result).toBe(vector);
-            expect(vector).toEqual({ x: -3, y: 6, z: -9, _isDirty: true });
+            expect(vector).toEqual({ x: -3, y: 6, z: -9 });
         });
     });
 });