Prepare iron to c port

armorforge/Sources/TabObjects.ts

@@ -15,7 +15,7 @@ class TabObjects {
 			ui.row([1 / 4]);
 			if (ui.button("Import")) {
 				Project.importMesh(false, () => {
-					Project.paintObjects.pop().base.setParent(null);
+					BaseObject.setParent(Project.paintObjects.pop().base, null);
 				});
 			}
 			ui.endSticky();
@@ -28,7 +28,7 @@ class TabObjects {
 				let listW = ui._w;
 
 				let lineCounter = 0;
-				let drawList = (listHandle: Handle, currentObject: BaseObject) => {
+				let drawList = (listHandle: Handle, currentObject: TBaseObject) => {
 					if (currentObject.name.charAt(0) == ".") return; // Hidden
 					let b = false;
 
@@ -96,7 +96,7 @@ class TabObjects {
 								}
 
 								Data.getMaterial("Scene", "TempMaterial" + TabObjects.materialId, (md: TMaterialData) => {
-									let mo: MeshObject = currentObject.ext;
+									let mo: TMeshObject = currentObject.ext;
 									mo.materials = [md];
 									MakeMaterial.parseMeshPreviewMaterial(md);
 								});
@@ -135,11 +135,11 @@ class TabObjects {
 
 					let t = Context.raw.selectedObject.transform;
 					let localPos = t.loc;
-					let worldPos = new Vec4(t.worldx(), t.worldy(), t.worldz(), 1.0);
+					let worldPos = Vec4.create(Transform.worldx(t), Transform.worldy(t), Transform.worldz(t), 1.0);
 					let scale = t.scale;
-					let rot = t.rot.getEuler();
+					let rot = Quat.getEuler(t.rot);
 					let dim = t.dim;
-					rot.mult(180 / 3.141592);
+					Vec4.mult(rot, 180 / 3.141592);
 					let f = 0.0;
 
 					ui.row([1 / 4, 1 / 4, 1 / 4, 1 / 4]);
@@ -180,9 +180,9 @@ class TabObjects {
 					if (h.changed) { changed = true; rot.z = f; }
 
 					if (changed && Context.raw.selectedObject.name != "Scene") {
-						rot.mult(3.141592 / 180);
-						Context.raw.selectedObject.transform.rot.fromEuler(rot.x, rot.y, rot.z);
-						Context.raw.selectedObject.transform.buildMatrix();
+						Vec4.mult(rot, 3.141592 / 180);
+						Quat.fromEuler(Context.raw.selectedObject.transform.rot, rot.x, rot.y, rot.z);
+						Transform.buildMatrix(Context.raw.selectedObject.transform);
 						// ///if arm_physics
 						// if (rb != null) rb.syncTransform();
 						// ///end
@@ -230,19 +230,19 @@ class TabObjects {
 						let p = Scene.world;
 						p.strength = ui.slider(Zui.handle("tabobjects_16", {value: p.strength}), "Environment", 0.0, 5.0, true);
 					}
-					else if (Context.raw.selectedObject.constructor == LightObject) {
-						let light = (Context.raw.selectedObject as LightObject);
+					else if (Context.raw.selectedObject.ext.constructor == TLightObject) {
+						let light = Context.raw.selectedObject.ext;
 						let lightHandle = Zui.handle("tabobjects_17");
 						lightHandle.value = light.data.strength / 10;
 						light.data.strength = ui.slider(lightHandle, "Strength", 0.0, 5.0, true) * 10;
 					}
-					else if (Context.raw.selectedObject.constructor == CameraObject) {
-						let cam = (Context.raw.selectedObject as CameraObject);
+					else if (Context.raw.selectedObject.ext.constructor == TCameraObject) {
+						let cam = Context.raw.selectedObject.ext;
 						let fovHandle = Zui.handle("tabobjects_18");
 						fovHandle.value = Math.floor(cam.data.fov * 100) / 100;
 						cam.data.fov = ui.slider(fovHandle, "FoV", 0.3, 2.0, true);
 						if (fovHandle.changed) {
-							cam.buildProjection();
+							CameraObject.buildProjection(cam);
 						}
 					}
 				}

armorlab/Sources/RenderPathPaint.ts

@@ -197,12 +197,12 @@ class RenderPathPaint {
 		g.setFloat2(Base.cursorMouse, mx, my);
 		g.setFloat2(Base.cursorTexStep, 1 / gbuffer0.width, 1 / gbuffer0.height);
 		g.setFloat(Base.cursorRadius, radius);
-		let right = Scene.camera.rightWorld().normalize();
+		let right = Vec4.normalize(CameraObject.rightWorld(Scene.camera));
 		g.setFloat3(Base.cursorCameraRight, right.x, right.y, right.z);
 		g.setFloat3(Base.cursorTint, tintR, tintG, tintB);
 		g.setMatrix(Base.cursorVP, Scene.camera.VP);
 		let helpMat = Mat4.identity();
-		helpMat.getInverse(Scene.camera.VP);
+		Mat4.getInverse(helpMat, Scene.camera.VP);
 		g.setMatrix(Base.cursorInvVP, helpMat);
 		///if (krom_metal || krom_vulkan)
 		g.setVertexBuffer(MeshData.get(geom, [{name: "tex", data: "short2norm"}]));

armorpaint/Sources/RenderPathPaint.ts

@@ -7,8 +7,8 @@ class RenderPathPaint {
 	static dilated = true;
 	static initVoxels = true; // Bake AO
 	static pushUndoLast: bool;
-	static painto: MeshObject = null;
-	static planeo: MeshObject = null;
+	static painto: TMeshObject = null;
+	static planeo: TMeshObject = null;
 	static visibles: bool[] = null;
 	static mergedObjectVisible = false;
 	static savedFov = 0.0;
@@ -121,14 +121,14 @@ class RenderPathPaint {
 					RenderPath.bindTarget("gbuffer0", "gbuffer0");
 				}
 
-				let mo: MeshObject = Scene.getChild(".ParticleEmitter").ext;
+				let mo: TMeshObject = Scene.getChild(".ParticleEmitter").ext;
 				mo.base.visible = true;
-				mo.render(RenderPath.currentG, "mesh", RenderPath.bindParams);
+				MeshObject.render(mo, RenderPath.currentG, "mesh", RenderPath.bindParams);
 				mo.base.visible = false;
 
 				mo = Scene.getChild(".Particle").ext;
 				mo.base.visible = true;
-				mo.render(RenderPath.currentG, "mesh", RenderPath.bindParams);
+				MeshObject.render(mo, RenderPath.currentG, "mesh", RenderPath.bindParams);
 				mo.base.visible = false;
 				RenderPath.end();
 			}
@@ -348,7 +348,7 @@ class RenderPathPaint {
 			let materialContexts: TMaterialContext[] = [];
 			let shaderContexts: TShaderContext[] = [];
 			let mats = Project.paintObjects[0].materials;
-			Project.paintObjects[0].getContexts("paint", mats, materialContexts, shaderContexts);
+			MeshObject.getContexts(Project.paintObjects[0], "paint", mats, materialContexts, shaderContexts);
 
 			let cc_context = shaderContexts[0];
 			if (ConstData.screenAlignedVB == null) ConstData.createScreenAlignedData();
@@ -495,7 +495,7 @@ class RenderPathPaint {
 	}
 
 	static drawCursor = (mx: f32, my: f32, radius: f32, tintR = 1.0, tintG = 1.0, tintB = 1.0) => {
-		let plane: MeshObject = Scene.getChild(".Plane").ext;
+		let plane: TMeshObject = Scene.getChild(".Plane").ext;
 		let geom = plane.data;
 
 		let g = RenderPath.frameG;
@@ -512,12 +512,12 @@ class RenderPathPaint {
 		g.setFloat2(Base.cursorMouse, mx, my);
 		g.setFloat2(Base.cursorTexStep, 1 / gbuffer0.width, 1 / gbuffer0.height);
 		g.setFloat(Base.cursorRadius, radius);
-		let right = Scene.camera.rightWorld().normalize();
+		let right = Vec4.normalize(CameraObject.rightWorld(Scene.camera));
 		g.setFloat3(Base.cursorCameraRight, right.x, right.y, right.z);
 		g.setFloat3(Base.cursorTint, tintR, tintG, tintB);
 		g.setMatrix(Base.cursorVP, Scene.camera.VP);
 		let helpMat = Mat4.identity();
-		helpMat.getInverse(Scene.camera.VP);
+		Mat4.getInverse(helpMat, Scene.camera.VP);
 		g.setMatrix(Base.cursorInvVP, helpMat);
 		///if (krom_metal || krom_vulkan)
 		g.setVertexBuffer(MeshData.get(geom, [{name: "tex", data: "short2norm"}]));
@@ -539,42 +539,42 @@ class RenderPathPaint {
 			let sy = t.scale.y;
 			let sz = t.scale.z;
 			if (Context.raw.symX) {
-				t.scale.set(-sx, sy, sz);
-				t.buildMatrix();
+				Vec4.set(t.scale, -sx, sy, sz);
+				Transform.buildMatrix(t);
 				RenderPathPaint.commandsPaint(false);
 			}
 			if (Context.raw.symY) {
-				t.scale.set(sx, -sy, sz);
-				t.buildMatrix();
+				Vec4.set(t.scale, sx, -sy, sz);
+				Transform.buildMatrix(t);
 				RenderPathPaint.commandsPaint(false);
 			}
 			if (Context.raw.symZ) {
-				t.scale.set(sx, sy, -sz);
-				t.buildMatrix();
+				Vec4.set(t.scale, sx, sy, -sz);
+				Transform.buildMatrix(t);
 				RenderPathPaint.commandsPaint(false);
 			}
 			if (Context.raw.symX && Context.raw.symY) {
-				t.scale.set(-sx, -sy, sz);
-				t.buildMatrix();
+				Vec4.set(t.scale, -sx, -sy, sz);
+				Transform.buildMatrix(t);
 				RenderPathPaint.commandsPaint(false);
 			}
 			if (Context.raw.symX && Context.raw.symZ) {
-				t.scale.set(-sx, sy, -sz);
-				t.buildMatrix();
+				Vec4.set(t.scale, -sx, sy, -sz);
+				Transform.buildMatrix(t);
 				RenderPathPaint.commandsPaint(false);
 			}
 			if (Context.raw.symY && Context.raw.symZ) {
-				t.scale.set(sx, -sy, -sz);
-				t.buildMatrix();
+				Vec4.set(t.scale, sx, -sy, -sz);
+				Transform.buildMatrix(t);
 				RenderPathPaint.commandsPaint(false);
 			}
 			if (Context.raw.symX && Context.raw.symY && Context.raw.symZ) {
-				t.scale.set(-sx, -sy, -sz);
-				t.buildMatrix();
+				Vec4.set(t.scale, -sx, -sy, -sz);
+				Transform.buildMatrix(t);
 				RenderPathPaint.commandsPaint(false);
 			}
-			t.scale.set(sx, sy, sz);
-			t.buildMatrix();
+			Vec4.set(t.scale, sx, sy, sz);
+			Transform.buildMatrix(t);
 		}
 	}
 
@@ -794,25 +794,25 @@ class RenderPathPaint {
 		}
 
 		let cam = Scene.camera;
-		Context.raw.savedCamera.setFrom(cam.base.transform.local);
+		Mat4.setFrom(Context.raw.savedCamera, cam.base.transform.local);
 		RenderPathPaint.savedFov = cam.data.fov;
 		Viewport.updateCameraType(CameraType.CameraPerspective);
 		let m = Mat4.identity();
-		m.translate(0, 0, 0.5);
-		cam.base.transform.setMatrix(m);
+		Mat4.translate(m, 0, 0, 0.5);
+		Transform.setMatrix(cam.base.transform, m);
 		cam.data.fov = Base.defaultFov;
-		cam.buildProjection();
-		cam.buildMatrix();
+		CameraObject.buildProjection(cam);
+		CameraObject.buildMatrix(cam);
 
 		let tw = 0.95 * UIView2D.panScale;
 		let tx = UIView2D.panX / UIView2D.ww;
 		let ty = UIView2D.panY / App.h();
-		m.setIdentity();
-		m.scale(new Vec4(tw, tw, 1));
-		m.setLoc(new Vec4(tx, ty, 0));
+		Mat4.setIdentity(m);
+		Mat4.scale(m, Vec4.create(tw, tw, 1));
+		Mat4.setLoc(m, Vec4.create(tx, ty, 0));
 		let m2 = Mat4.identity();
-		m2.getInverse(Scene.camera.VP);
-		m.multmat(m2);
+		Mat4.getInverse(m2, Scene.camera.VP);
+		Mat4.multmat(m, m2);
 
 		let tiled = UIView2D.tiledShow;
 		if (tiled && Scene.getChild(".PlaneTiled") == null) {
@@ -845,19 +845,19 @@ class RenderPathPaint {
 		RenderPathPaint.planeo.base.visible = true;
 		Context.raw.paintObject = RenderPathPaint.planeo;
 
-		let v = new Vec4();
-		let sx = v.set(m._00, m._01, m._02).length();
-		RenderPathPaint.planeo.base.transform.rot.fromEuler(-Math.PI / 2, 0, 0);
-		RenderPathPaint.planeo.base.transform.scale.set(sx, 1.0, sx);
+		let v = Vec4.create();
+		let sx = Vec4.vec4_length(Vec4.set(v, m._00, m._01, m._02));
+		Quat.fromEuler(RenderPathPaint.planeo.base.transform.rot, -Math.PI / 2, 0, 0);
+		Vec4.set(RenderPathPaint.planeo.base.transform.scale, sx, 1.0, sx);
 		RenderPathPaint.planeo.base.transform.scale.z *= Config.getTextureResY() / Config.getTextureResX();
-		RenderPathPaint.planeo.base.transform.loc.set(m._30, -m._31, 0.0);
-		RenderPathPaint.planeo.base.transform.buildMatrix();
+		Vec4.set(RenderPathPaint.planeo.base.transform.loc, m._30, -m._31, 0.0);
+		Transform.buildMatrix(RenderPathPaint.planeo.base.transform);
 	}
 
 	static restorePlaneMesh = () => {
 		Context.raw.paint2dView = false;
 		RenderPathPaint.planeo.base.visible = false;
-		RenderPathPaint.planeo.base.transform.loc.set(0.0, 0.0, 0.0);
+		Vec4.set(RenderPathPaint.planeo.base.transform.loc, 0.0, 0.0, 0.0);
 		for (let i = 0; i < Project.paintObjects.length; ++i) {
 			Project.paintObjects[i].base.visible = RenderPathPaint.visibles[i];
 		}
@@ -865,11 +865,11 @@ class RenderPathPaint {
 			Context.raw.mergedObject.base.visible = RenderPathPaint.mergedObjectVisible;
 		}
 		Context.raw.paintObject = RenderPathPaint.painto;
-		Scene.camera.base.transform.setMatrix(Context.raw.savedCamera);
+		Transform.setMatrix(Scene.camera.base.transform, Context.raw.savedCamera);
 		Scene.camera.data.fov = RenderPathPaint.savedFov;
 		Viewport.updateCameraType(Context.raw.cameraType);
-		Scene.camera.buildProjection();
-		Scene.camera.buildMatrix();
+		CameraObject.buildProjection(Scene.camera);
+		CameraObject.buildMatrix(Scene.camera);
 
 		RenderPathBase.drawGbuffer();
 	}

armorpaint/Sources/TabLayers.ts

@@ -171,7 +171,7 @@ class TabLayers {
 				UtilMesh.mergeMesh();
 			}
 			else if (Context.raw.layerFilter > Project.paintObjects.length) { // Atlas
-				let visibles: MeshObject[] = [];
+				let visibles: TMeshObject[] = [];
 				for (let p of Project.paintObjects) if (p.base.visible) visibles.push(p);
 				UtilMesh.mergeMesh(visibles);
 			}

armorpaint/Sources/nodes/InputNode.ts

@@ -1,7 +1,7 @@
 
 class InputNode extends LogicNode {
 
-	static coords = new Vec4();
+	static coords = Vec4.create();
 
 	static startX = 0.0;
 	static startY = 0.0;
@@ -90,17 +90,17 @@ class InputNode extends LogicNode {
 		}
 
 		if (Context.raw.brushLazyRadius > 0) {
-			let v1 = new Vec4(Context.raw.brushLazyX * App.w(), Context.raw.brushLazyY * App.h(), 0.0);
-			let v2 = new Vec4(InputNode.coords.x * App.w(), InputNode.coords.y * App.h(), 0.0);
+			let v1 = Vec4.create(Context.raw.brushLazyX * App.w(), Context.raw.brushLazyY * App.h(), 0.0);
+			let v2 = Vec4.create(InputNode.coords.x * App.w(), InputNode.coords.y * App.h(), 0.0);
 			let d = Vec4.distance(v1, v2);
 			let r = Context.raw.brushLazyRadius * 85;
 			if (d > r) {
-				let v3 = new Vec4();
-				v3.subvecs(v2, v1);
-				v3.normalize();
-				v3.mult(1.0 - Context.raw.brushLazyStep);
-				v3.mult(r);
-				v2.addvecs(v1, v3);
+				let v3 = Vec4.create();
+				Vec4.subvecs(v3, v2, v1);
+				Vec4.normalize(v3, );
+				Vec4.mult(v3, 1.0 - Context.raw.brushLazyStep);
+				Vec4.mult(v3, r);
+				Vec4.addvecs(v2, v1, v3);
 				InputNode.coords.x = v2.x / App.w();
 				InputNode.coords.y = v2.y / App.h();
 				// Parse brush inputs once on next draw

armorsculpt/Sources/ExportObj.ts

@@ -7,7 +7,7 @@ class ExportObj {
 		}
 	}
 
-	static run = (path: string, paintObjects: MeshObject[], applyDisplacement = false) => {
+	static run = (path: string, paintObjects: TMeshObject[], applyDisplacement = false) => {
 		let o: i32[] = [];
 		ExportObj.writeString(o, "# armorsculpt.org\n");
 

armorsculpt/Sources/ImportMesh.ts

@@ -34,7 +34,7 @@ class ImportMesh {
 
 	static finishImport = () => {
 		if (Context.raw.mergedObject != null) {
-			Context.raw.mergedObject.remove();
+			MeshObject.remove(Context.raw.mergedObject);
 			Data.deleteMesh(Context.raw.mergedObject.data._handle);
 			Context.raw.mergedObject = null;
 		}
@@ -87,7 +87,7 @@ class ImportMesh {
 					let p = Project.paintObjects[i];
 					if (p == Context.raw.paintObject) continue;
 					Data.deleteMesh(p.data._handle);
-					p.remove();
+					MeshObject.remove(p);
 				}
 				let handle = Context.raw.paintObject.data._handle;
 				if (handle != "SceneSphere" && handle != "ScenePlane") {
@@ -104,7 +104,7 @@ class ImportMesh {
 					History.reset();
 				}
 
-				Context.raw.paintObject.setData(md);
+				MeshObject.setData(Context.raw.paintObject, md);
 				Context.raw.paintObject.base.name = mesh.name;
 				Project.paintObjects = [Context.raw.paintObject];
 

base/Sources/Base.ts

@@ -209,7 +209,7 @@ class Base {
 					if (Config.raw.layout[LayoutSize.LayoutHeader] == 1) Base.appy += UIHeader.headerh;
 					let cam = Scene.camera;
 					cam.data.fov = Math.floor(cam.data.fov * 100) / 100;
-					cam.buildProjection();
+					CameraObject.buildProjection(cam);
 
 					Args.run();
 
@@ -389,7 +389,7 @@ class Base {
 			cam.data.ortho[2] = -2 * (App.h() / App.w());
 			cam.data.ortho[3] =  2 * (App.h() / App.w());
 		}
-		cam.buildProjection();
+		CameraObject.buildProjection(cam);
 
 		if (Context.raw.cameraType == CameraType.CameraOrthographic) {
 			Viewport.updateCameraType(Context.raw.cameraType);
@@ -2069,7 +2069,7 @@ class Base {
 		return l;
 	}
 
-	static createFillLayer = (uvType = UVType.UVMap, decalMat: Mat4 = null, position = -1) => {
+	static createFillLayer = (uvType = UVType.UVMap, decalMat: TMat4 = null, position = -1) => {
 		let _init = () => {
 			let l = Base.newLayer(false, position);
 			History.newLayer();

base/Sources/BoxPreferences.ts

@@ -477,7 +477,7 @@ class BoxPreferences {
 				camRaw.near_plane = ui.slider(near_handle, tr("Clip Start"), 0.001, 1.0, true);
 				camRaw.far_plane = ui.slider(far_handle, tr("Clip End"), 50.0, 100.0, true);
 				if (near_handle.changed || far_handle.changed) {
-					cam.buildProjection();
+					CameraObject.buildProjection(cam);
 				}
 
 				let dispHandle = Zui.handle("boxpreferences_49", { value: Config.raw.displace_strength });

base/Sources/Camera.ts

@@ -1,10 +1,10 @@
 
 class Camera {
 
-	static origins: Vec4[];
-	static views: Mat4[];
+	static origins: TVec4[];
+	static views: TMat4[];
 	static redraws = 0;
-	static dir = new Vec4();
+	static dir = Vec4.create();
 	static ease = 1.0;
 	static controlsDown = false;
 
@@ -81,24 +81,24 @@ class Camera {
 		if (controls == CameraControls.ControlsOrbit && (Operator.shortcut(Config.keymap.action_rotate, ShortcutType.ShortcutDown) || (Mouse.down("right") && !modif && defaultKeymap))) {
 			Camera.redraws = 2;
 			let dist = Camera.distance();
-			camera.base.transform.move(camera.lookWorld(), dist);
-			camera.base.transform.rotate(Vec4.zAxis(), -Mouse.movementX / 100 * Config.raw.camera_rotation_speed);
-			camera.base.transform.rotate(camera.rightWorld(), -Mouse.movementY / 100 * Config.raw.camera_rotation_speed);
-			if (camera.upWorld().z < 0) {
-				camera.base.transform.rotate(camera.rightWorld(), Mouse.movementY / 100 * Config.raw.camera_rotation_speed);
+			Transform.move(camera.base.transform, CameraObject.lookWorld(camera), dist);
+			Transform.rotate(camera.base.transform, Vec4.zAxis(), -Mouse.movementX / 100 * Config.raw.camera_rotation_speed);
+			Transform.rotate(camera.base.transform, CameraObject.rightWorld(camera), -Mouse.movementY / 100 * Config.raw.camera_rotation_speed);
+			if (CameraObject.upWorld(camera).z < 0) {
+				Transform.rotate(camera.base.transform, CameraObject.rightWorld(camera), Mouse.movementY / 100 * Config.raw.camera_rotation_speed);
 			}
-			camera.base.transform.move(camera.lookWorld(), -dist);
+			Transform.move(camera.base.transform, CameraObject.lookWorld(camera), -dist);
 		}
 		else if (controls == CameraControls.ControlsRotate && (Operator.shortcut(Config.keymap.action_rotate, ShortcutType.ShortcutDown) || (Mouse.down("right") && !modif && defaultKeymap))) {
 			Camera.redraws = 2;
 			let t = Context.mainObject().base.transform;
-			let up = t.up().normalize();
-			t.rotate(up, Mouse.movementX / 100 * Config.raw.camera_rotation_speed);
-			let right = camera.rightWorld().normalize();
-			t.rotate(right, Mouse.movementY / 100 * Config.raw.camera_rotation_speed);
-			t.buildMatrix();
-			if (t.up().z < 0) {
-				t.rotate(right, -Mouse.movementY / 100 * Config.raw.camera_rotation_speed);
+			let up = Vec4.normalize(Transform.up(t));
+			Transform.rotate(t, up, Mouse.movementX / 100 * Config.raw.camera_rotation_speed);
+			let right = Vec4.normalize(CameraObject.rightWorld(camera));
+			Transform.rotate(t, right, Mouse.movementY / 100 * Config.raw.camera_rotation_speed);
+			Transform.buildMatrix(t);
+			if (Transform.up(t).z < 0) {
+				Transform.rotate(t, right, -Mouse.movementY / 100 * Config.raw.camera_rotation_speed);
 			}
 		}
 
@@ -109,14 +109,14 @@ class Camera {
 				Camera.redraws = 2;
 				let f = Camera.getZoomDelta() / 150;
 				f *= Camera.getCameraZoomSpeed();
-				camera.base.transform.move(camera.look(), f);
+				Transform.move(camera.base.transform, CameraObject.look(camera), f);
 			}
 
 			if (Mouse.wheelDelta != 0 && !modifKey) {
 				Camera.redraws = 2;
 				let f = Mouse.wheelDelta * (-0.1);
 				f *= Camera.getCameraZoomSpeed();
-				camera.base.transform.move(camera.look(), f);
+				Transform.move(camera.base.transform, CameraObject.look(camera), f);
 			}
 		}
 		else if (controls == CameraControls.ControlsFly && Mouse.down("right")) {
@@ -134,13 +134,13 @@ class Camera {
 			if (moveForward || moveBackward || strafeRight || strafeLeft || strafeUp || strafeDown) {
 				Camera.ease += Time.delta * 15;
 				if (Camera.ease > 1.0) Camera.ease = 1.0;
-				Camera.dir.set(0, 0, 0);
-				if (moveForward) Camera.dir.addf(camera.look().x, camera.look().y, camera.look().z);
-				if (moveBackward) Camera.dir.addf(-camera.look().x, -camera.look().y, -camera.look().z);
-				if (strafeRight) Camera.dir.addf(camera.right().x, camera.right().y, camera.right().z);
-				if (strafeLeft) Camera.dir.addf(-camera.right().x, -camera.right().y, -camera.right().z);
-				if (strafeUp) Camera.dir.addf(0, 0, 1);
-				if (strafeDown) Camera.dir.addf(0, 0, -1);
+				Vec4.set(Camera.dir, 0, 0, 0);
+				if (moveForward) Vec4.addf(Camera.dir, CameraObject.look(camera).x, CameraObject.look(camera).y, CameraObject.look(camera).z);
+				if (moveBackward) Vec4.addf(Camera.dir, -CameraObject.look(camera).x, -CameraObject.look(camera).y, -CameraObject.look(camera).z);
+				if (strafeRight) Vec4.addf(Camera.dir, CameraObject.right(camera).x, CameraObject.right(camera).y, CameraObject.right(camera).z);
+				if (strafeLeft) Vec4.addf(Camera.dir, -CameraObject.right(camera).x, -CameraObject.right(camera).y, -CameraObject.right(camera).z);
+				if (strafeUp) Vec4.addf(Camera.dir, 0, 0, 1);
+				if (strafeDown) Vec4.addf(Camera.dir, 0, 0, -1);
 			}
 			else {
 				Camera.ease -= Time.delta * 20.0 * Camera.ease;
@@ -150,15 +150,15 @@ class Camera {
 
 			let d = Time.delta * fast * Camera.ease * 2.0 * ((moveForward || moveBackward) ? Config.raw.camera_zoom_speed : Config.raw.camera_pan_speed);
 			if (d > 0.0) {
-				camera.base.transform.move(Camera.dir, d);
+				Transform.move(camera.base.transform, Camera.dir, d);
 				if (Context.raw.cameraType == CameraType.CameraOrthographic) {
 					Viewport.updateCameraType(Context.raw.cameraType);
 				}
 			}
 
 			Camera.redraws = 2;
-			camera.base.transform.rotate(Vec4.zAxis(), -Mouse.movementX / 200 * Config.raw.camera_rotation_speed);
-			camera.base.transform.rotate(camera.right(), -Mouse.movementY / 200 * Config.raw.camera_rotation_speed);
+			Transform.rotate(camera.base.transform, Vec4.zAxis(), -Mouse.movementX / 200 * Config.raw.camera_rotation_speed);
+			Transform.rotate(camera.base.transform, CameraObject.right(camera), -Mouse.movementY / 200 * Config.raw.camera_rotation_speed);
 		}
 
 		if (Operator.shortcut(Config.keymap.rotate_light, ShortcutType.ShortcutDown)) {
@@ -166,8 +166,8 @@ class Camera {
 			let light = Scene.lights[0];
 			Context.raw.lightAngle = (Context.raw.lightAngle + ((Mouse.movementX / 100) % (2 * Math.PI) + 2 * Math.PI)) % (2 * Math.PI);
 			let m = Mat4.rotationZ(Mouse.movementX / 100);
-			light.base.transform.local.multmat(m);
-			light.base.transform.decompose();
+			Mat4.multmat(light.base.transform.local, m);
+			Transform.decompose(light.base.transform);
 		}
 
 		if (Operator.shortcut(Config.keymap.rotate_envmap, ShortcutType.ShortcutDown)) {
@@ -204,12 +204,12 @@ class Camera {
 	static reset = (viewIndex = -1) => {
 		let camera = Scene.camera;
 		if (viewIndex == -1) {
-			Camera.origins = [new Vec4(0, 0, 0), new Vec4(0, 0, 0)];
-			Camera.views = [camera.base.transform.local.clone(), camera.base.transform.local.clone()];
+			Camera.origins = [Vec4.create(0, 0, 0), Vec4.create(0, 0, 0)];
+			Camera.views = [Mat4.clone(camera.base.transform.local), Mat4.clone(camera.base.transform.local)];
 		}
 		else {
-			Camera.origins[viewIndex] = new Vec4(0, 0, 0);
-			Camera.views[viewIndex] = camera.base.transform.local.clone();
+			Camera.origins[viewIndex] = Vec4.create(0, 0, 0);
+			Camera.views[viewIndex] = Mat4.clone(camera.base.transform.local);
 		}
 	}
 
@@ -217,13 +217,13 @@ class Camera {
 		let camera = Scene.camera;
 		if (Operator.shortcut(Config.keymap.action_pan, ShortcutType.ShortcutDown) || (Mouse.down("middle") && !modif && defaultKeymap)) {
 			Camera.redraws = 2;
-			let look = camera.base.transform.look().normalize().mult(Mouse.movementY / 150 * Config.raw.camera_pan_speed);
-			let right = camera.base.transform.right().normalize().mult(-Mouse.movementX / 150 * Config.raw.camera_pan_speed);
-			camera.base.transform.loc.add(look);
-			camera.base.transform.loc.add(right);
-			Camera.origins[Camera.index()].add(look);
-			Camera.origins[Camera.index()].add(right);
-			camera.buildMatrix();
+			let look = Vec4.mult(Vec4.normalize(Transform.look(camera.base.transform)), Mouse.movementY / 150 * Config.raw.camera_pan_speed);
+			let right = Vec4.mult(Vec4.normalize(Transform.right(camera.base.transform)), -Mouse.movementX / 150 * Config.raw.camera_pan_speed);
+			Vec4.add(camera.base.transform.loc, look);
+			Vec4.add(camera.base.transform.loc, right);
+			Vec4.add(Camera.origins[Camera.index()], look);
+			Vec4.add(Camera.origins[Camera.index()], right);
+			CameraObject.buildMatrix(camera);
 		}
 	}
 

base/Sources/Context.ts

@@ -141,7 +141,7 @@ class Context {
 	}
 	///end
 
-	static selectPaintObject = (o: MeshObject) => {
+	static selectPaintObject = (o: TMeshObject) => {
 		///if (is_paint || is_sculpt)
 		UIHeader.headerHandle.redraws = 2;
 		for (let p of Project.paintObjects) p.skip_context = "paint";
@@ -163,7 +163,7 @@ class Context {
 		///end
 	}
 
-	static mainObject = (): MeshObject => {
+	static mainObject = (): TMeshObject => {
 		///if (is_paint || is_sculpt)
 		for (let po of Project.paintObjects) if (po.base.children.length > 0) return po;
 		return Project.paintObjects[0];

base/Sources/ContextFormat.ts

@@ -4,8 +4,8 @@
 // type TContext = {
 class TContext {
 	texture?: TAsset = null;
-	paintObject?: MeshObject;
-	mergedObject?: MeshObject = null; // For object mask
+	paintObject?: TMeshObject;
+	mergedObject?: TMeshObject = null; // For object mask
 	mergedObjectIsAtlas? = false; // Only objects referenced by atlas are merged
 
 	ddirty? = 0; // depth
@@ -66,7 +66,7 @@ class TContext {
 	exportMeshIndex? = 0;
 	packAssetsOnExport? = true;
 
-	paintVec? = new Vec4();
+	paintVec? = Vec4.create();
 	lastPaintX? = -1.0;
 	lastPaintY? = -1.0;
 	foregroundEvent? = false;
@@ -80,7 +80,7 @@ class TContext {
 	showCompass? = true;
 	projectType? = ProjectModel.ModelRoundedCube;
 	projectAspectRatio? = 0; // 1:1, 2:1, 1:2
-	projectObjects?: MeshObject[];
+	projectObjects?: TMeshObject[];
 
 	lastPaintVecX? = -1.0;
 	lastPaintVecY? = -1.0;
@@ -185,16 +185,16 @@ class TContext {
 	runBrush?: (i: i32)=>void = null;
 	parseBrushInputs?: ()=>void = null;
 
-	gizmo?: BaseObject = null;
-	gizmoTranslateX?: BaseObject = null;
-	gizmoTranslateY?: BaseObject = null;
-	gizmoTranslateZ?: BaseObject = null;
-	gizmoScaleX?: BaseObject = null;
-	gizmoScaleY?: BaseObject = null;
-	gizmoScaleZ?: BaseObject = null;
-	gizmoRotateX?: BaseObject = null;
-	gizmoRotateY?: BaseObject = null;
-	gizmoRotateZ?: BaseObject = null;
+	gizmo?: TBaseObject = null;
+	gizmoTranslateX?: TBaseObject = null;
+	gizmoTranslateY?: TBaseObject = null;
+	gizmoTranslateZ?: TBaseObject = null;
+	gizmoScaleX?: TBaseObject = null;
+	gizmoScaleY?: TBaseObject = null;
+	gizmoScaleZ?: TBaseObject = null;
+	gizmoRotateX?: TBaseObject = null;
+	gizmoRotateY?: TBaseObject = null;
+	gizmoRotateZ?: TBaseObject = null;
 	gizmoStarted? = false;
 	gizmoOffset? = 0.0;
 	gizmoDrag? = 0.0;
@@ -287,7 +287,7 @@ class TContext {
 	brushRadiusHandle? = new Handle({ value: 0.25 });
 	brushScale? = 1.0;
 
-	coords? = new Vec4();
+	coords? = Vec4.create();
 	startX? = 0.0;
 	startY? = 0.0;
 
@@ -301,6 +301,6 @@ class TContext {
 	///end
 
 	///if is_forge
-	selectedObject?: BaseObject = null;
+	selectedObject?: TBaseObject = null;
 	///end
 }

base/Sources/ExportArm.ts

@@ -1,7 +1,7 @@
 
 class ExportArm {
 
-	static runMesh = (path: string, paintObjects: MeshObject[]) => {
+	static runMesh = (path: string, paintObjects: TMeshObject[]) => {
 		let mesh_datas: TMeshData[] = [];
 		for (let p of paintObjects) mesh_datas.push(p.data);
 		let raw: TSceneFormat = { mesh_datas: mesh_datas };
@@ -66,7 +66,7 @@ class ExportArm {
 				uv_scale: l.scale,
 				uv_rot: l.angle,
 				uv_type: l.uvType,
-				decal_mat: l.uvType == UVType.UVProject ? l.decalMat.toFloat32Array() : null,
+				decal_mat: l.uvType == UVType.UVProject ? Mat4.toFloat32Array(l.decalMat) : null,
 				opacity_mask: l.maskOpacity,
 				fill_layer: l.fill_layer != null ? Project.materials.indexOf(l.fill_layer) : -1,
 				object_mask: l.objectMask,
@@ -107,7 +107,7 @@ class ExportArm {
 			swatches: Project.raw.swatches,
 			envmap: Project.raw.envmap != null ? (sameDrive ? Path.toRelative(Project.filepath, Project.raw.envmap) : Project.raw.envmap) : null,
 			envmap_strength: Scene.world.strength,
-			camera_world: Scene.camera.base.transform.local.toFloat32Array(),
+			camera_world: Mat4.toFloat32Array(Scene.camera.base.transform.local),
 			camera_origin: ExportArm.vec3f32(Camera.origins[0]),
 			camera_fov: Scene.camera.data.fov,
 
@@ -454,7 +454,7 @@ class ExportArm {
 		Krom.fileSaveBytes(path, buffer, buffer.byteLength + 1);
 	}
 
-	static vec3f32 = (v: Vec4): Float32Array => {
+	static vec3f32 = (v: TVec4): Float32Array => {
 		let res = new Float32Array(3);
 		res[0] = v.x;
 		res[1] = v.y;

base/Sources/ExportMesh.ts

@@ -1,7 +1,7 @@
 
 class ExportMesh {
 
-	static run = (path: string, paintObjects: MeshObject[] = null, applyDisplacement = false) => {
+	static run = (path: string, paintObjects: TMeshObject[] = null, applyDisplacement = false) => {
 		if (paintObjects == null) paintObjects = Project.paintObjects;
 		if (Context.raw.exportMeshFormat == MeshFormat.FormatObj) ExportObj.run(path, paintObjects, applyDisplacement);
 		else ExportArm.runMesh(path, paintObjects);

base/Sources/ExportObj.ts

@@ -7,7 +7,7 @@ class ExportObj {
 		}
 	}
 
-	static run = (path: string, paintObjects: MeshObject[], applyDisplacement = false) => {
+	static run = (path: string, paintObjects: TMeshObject[], applyDisplacement = false) => {
 		let o: i32[] = [];
 		ExportObj.writeString(o, "# armorpaint.org\n");
 

base/Sources/ExportTexture.ts

@@ -94,7 +94,7 @@ class ExportTexture {
 		Context.raw.tool = WorkspaceTool.ToolFill;
 		MakeMaterial.parsePaintMaterial();
 		let _paintObject = Context.raw.paintObject;
-		let planeo: MeshObject = Scene.getChild(".Plane").ext;
+		let planeo: TMeshObject = Scene.getChild(".Plane").ext;
 		planeo.base.visible = true;
 		Context.raw.paintObject = planeo;
 		Context.raw.pdirty = 1;

base/Sources/Geom.ts

@@ -70,7 +70,7 @@ class Geom {
 		mesh.texa = new Int16Array(widthVerts * heightVerts * 2);
 		mesh.inda = new Uint32Array(widthSegments * heightSegments * 6 - widthSegments * 6);
 
-		let nor = new Vec4();
+		let nor = Vec4.create();
 		let pos = 0;
 		for (let y = 0; y < heightVerts; ++y) {
 			let v = y / heightSegments;
@@ -90,7 +90,7 @@ class Geom {
 				mesh.posa[i4    ] = Math.floor(vx * inv);
 				mesh.posa[i4 + 1] = Math.floor(vy * inv);
 				mesh.posa[i4 + 2] = Math.floor(vz * inv);
-				nor.set(vx, vy, vz).normalize();
+				Vec4.normalize(Vec4.set(nor, vx, vy, vz));
 				mesh.posa[i4 + 3] = Math.floor(nor.z * 32767);
 				mesh.nora[i2    ] = Math.floor(nor.x * 32767);
 				mesh.nora[i2 + 1] = Math.floor(nor.y * 32767);

base/Sources/Gizmo.ts

@@ -3,10 +3,10 @@
 
 class Gizmo {
 
-	static v = new Vec4();
-	static v0 = new Vec4();
-	static q = new Quat();
-	static q0 = new Quat();
+	static v = Vec4.create();
+	static v0 = Vec4.create();
+	static q = Quat.create();
+	static q0 = Quat.create();
 
 	static update = () => {
 		let isObject = Context.raw.tool == WorkspaceTool.ToolGizmo;
@@ -17,7 +17,7 @@ class Gizmo {
 		gizmo.visible = (isObject || isDecal) && !hide;
 		if (!gizmo.visible) return;
 
-		let paintObject: BaseObject = Context.raw.paintObject.base;
+		let paintObject: TBaseObject = Context.raw.paintObject.base;
 		///if is_forge
 		if (Context.raw.selectedObject != null) {
 			paintObject = Context.raw.selectedObject;
@@ -25,25 +25,25 @@ class Gizmo {
 		///end
 
 		if (isObject) {
-			gizmo.transform.loc.setFrom(paintObject.transform.loc);
+			Vec4.setFrom(gizmo.transform.loc, paintObject.transform.loc);
 		}
 		else if (isDecal) {
-			gizmo.transform.loc.set(Context.raw.layer.decalMat._30, Context.raw.layer.decalMat._31, Context.raw.layer.decalMat._32);
+			Vec4.set(gizmo.transform.loc, Context.raw.layer.decalMat._30, Context.raw.layer.decalMat._31, Context.raw.layer.decalMat._32);
 		}
 		let cam = Scene.camera;
 		let fov = cam.data.fov;
 		let dist = Vec4.distance(cam.base.transform.loc, gizmo.transform.loc) / 8 * fov;
-		gizmo.transform.scale.set(dist, dist, dist);
-		Context.raw.gizmoTranslateX.transform.scale.set(dist, dist, dist);
-		Context.raw.gizmoTranslateY.transform.scale.set(dist, dist, dist);
-		Context.raw.gizmoTranslateZ.transform.scale.set(dist, dist, dist);
-		Context.raw.gizmoScaleX.transform.scale.set(dist, dist, dist);
-		Context.raw.gizmoScaleY.transform.scale.set(dist, dist, dist);
-		Context.raw.gizmoScaleZ.transform.scale.set(dist, dist, dist);
-		Context.raw.gizmoRotateX.transform.scale.set(dist, dist, dist);
-		Context.raw.gizmoRotateY.transform.scale.set(dist, dist, dist);
-		Context.raw.gizmoRotateZ.transform.scale.set(dist, dist, dist);
-		gizmo.transform.buildMatrix();
+		Vec4.set(gizmo.transform.scale, dist, dist, dist);
+		Vec4.set(Context.raw.gizmoTranslateX.transform.scale, dist, dist, dist);
+		Vec4.set(Context.raw.gizmoTranslateY.transform.scale, dist, dist, dist);
+		Vec4.set(Context.raw.gizmoTranslateZ.transform.scale, dist, dist, dist);
+		Vec4.set(Context.raw.gizmoScaleX.transform.scale, dist, dist, dist);
+		Vec4.set(Context.raw.gizmoScaleY.transform.scale, dist, dist, dist);
+		Vec4.set(Context.raw.gizmoScaleZ.transform.scale, dist, dist, dist);
+		Vec4.set(Context.raw.gizmoRotateX.transform.scale, dist, dist, dist);
+		Vec4.set(Context.raw.gizmoRotateY.transform.scale, dist, dist, dist);
+		Vec4.set(Context.raw.gizmoRotateZ.transform.scale, dist, dist, dist);
+		Transform.buildMatrix(gizmo.transform);
 
 		// Scene control
 		if (isObject) {
@@ -67,20 +67,20 @@ class Gizmo {
 					paintObject.transform.scale.z += Context.raw.gizmoDrag - Context.raw.gizmoDragLast;
 				}
 				else if (Context.raw.rotateX) {
-					Gizmo.q0.fromAxisAngle(Vec4.xAxis(), Context.raw.gizmoDrag - Context.raw.gizmoDragLast);
-					paintObject.transform.rot.mult(Gizmo.q0);
+					Quat.fromAxisAngle(Gizmo.q0, Vec4.xAxis(), Context.raw.gizmoDrag - Context.raw.gizmoDragLast);
+					Quat.mult(paintObject.transform.rot, Gizmo.q0);
 				}
 				else if (Context.raw.rotateY) {
-					Gizmo.q0.fromAxisAngle(Vec4.yAxis(), Context.raw.gizmoDrag - Context.raw.gizmoDragLast);
-					paintObject.transform.rot.mult(Gizmo.q0);
+					Quat.fromAxisAngle(Gizmo.q0, Vec4.yAxis(), Context.raw.gizmoDrag - Context.raw.gizmoDragLast);
+					Quat.mult(paintObject.transform.rot, Gizmo.q0);
 				}
 				else if (Context.raw.rotateZ) {
-					Gizmo.q0.fromAxisAngle(Vec4.zAxis(), Context.raw.gizmoDrag - Context.raw.gizmoDragLast);
-					paintObject.transform.rot.mult(Gizmo.q0);
+					Quat.fromAxisAngle(Gizmo.q0, Vec4.zAxis(), Context.raw.gizmoDrag - Context.raw.gizmoDragLast);
+					Quat.mult(paintObject.transform.rot, Gizmo.q0);
 				}
 				Context.raw.gizmoDragLast = Context.raw.gizmoDrag;
 
-				paintObject.transform.buildMatrix();
+				Transform.buildMatrix(paintObject.transform);
 				///if arm_physics
 				let pb = (paintObject as any).physicsBody;
 				if (pb != null) pb.syncTransform();
@@ -100,37 +100,37 @@ class Gizmo {
 					Context.raw.layer.decalMat._32 = Context.raw.gizmoDrag;
 				}
 				else if (Context.raw.scaleX) {
-					Context.raw.layer.decalMat.decompose(Gizmo.v, Gizmo.q, Gizmo.v0);
+					Mat4.decompose(Context.raw.layer.decalMat, Gizmo.v, Gizmo.q, Gizmo.v0);
 					Gizmo.v0.x += Context.raw.gizmoDrag - Context.raw.gizmoDragLast;
-					Context.raw.layer.decalMat.compose(Gizmo.v, Gizmo.q, Gizmo.v0);
+					Mat4.compose(Context.raw.layer.decalMat, Gizmo.v, Gizmo.q, Gizmo.v0);
 				}
 				else if (Context.raw.scaleY) {
-					Context.raw.layer.decalMat.decompose(Gizmo.v, Gizmo.q, Gizmo.v0);
+					Mat4.decompose(Context.raw.layer.decalMat, Gizmo.v, Gizmo.q, Gizmo.v0);
 					Gizmo.v0.y += Context.raw.gizmoDrag - Context.raw.gizmoDragLast;
-					Context.raw.layer.decalMat.compose(Gizmo.v, Gizmo.q, Gizmo.v0);
+					Mat4.compose(Context.raw.layer.decalMat, Gizmo.v, Gizmo.q, Gizmo.v0);
 				}
 				else if (Context.raw.scaleZ) {
-					Context.raw.layer.decalMat.decompose(Gizmo.v, Gizmo.q, Gizmo.v0);
+					Mat4.decompose(Context.raw.layer.decalMat, Gizmo.v, Gizmo.q, Gizmo.v0);
 					Gizmo.v0.z += Context.raw.gizmoDrag - Context.raw.gizmoDragLast;
-					Context.raw.layer.decalMat.compose(Gizmo.v, Gizmo.q, Gizmo.v0);
+					Mat4.compose(Context.raw.layer.decalMat, Gizmo.v, Gizmo.q, Gizmo.v0);
 				}
 				else if (Context.raw.rotateX) {
-					Context.raw.layer.decalMat.decompose(Gizmo.v, Gizmo.q, Gizmo.v0);
-					Gizmo.q0.fromAxisAngle(Vec4.xAxis(), -Context.raw.gizmoDrag + Context.raw.gizmoDragLast);
-					Gizmo.q.multquats(Gizmo.q0, Gizmo.q);
-					Context.raw.layer.decalMat.compose(Gizmo.v, Gizmo.q, Gizmo.v0);
+					Mat4.decompose(Context.raw.layer.decalMat, Gizmo.v, Gizmo.q, Gizmo.v0);
+					Quat.fromAxisAngle(Gizmo.q0, Vec4.xAxis(), -Context.raw.gizmoDrag + Context.raw.gizmoDragLast);
+					Quat.multquats(Gizmo.q, Gizmo.q0, Gizmo.q);
+					Mat4.compose(Context.raw.layer.decalMat, Gizmo.v, Gizmo.q, Gizmo.v0);
 				}
 				else if (Context.raw.rotateY) {
-					Context.raw.layer.decalMat.decompose(Gizmo.v, Gizmo.q, Gizmo.v0);
-					Gizmo.q0.fromAxisAngle(Vec4.yAxis(), -Context.raw.gizmoDrag + Context.raw.gizmoDragLast);
-					Gizmo.q.multquats(Gizmo.q0, Gizmo.q);
-					Context.raw.layer.decalMat.compose(Gizmo.v, Gizmo.q, Gizmo.v0);
+					Mat4.decompose(Context.raw.layer.decalMat, Gizmo.v, Gizmo.q, Gizmo.v0);
+					Quat.fromAxisAngle(Gizmo.q0, Vec4.yAxis(), -Context.raw.gizmoDrag + Context.raw.gizmoDragLast);
+					Quat.multquats(Gizmo.q, Gizmo.q0, Gizmo.q);
+					Mat4.compose(Context.raw.layer.decalMat, Gizmo.v, Gizmo.q, Gizmo.v0);
 				}
 				else if (Context.raw.rotateZ) {
-					Context.raw.layer.decalMat.decompose(Gizmo.v, Gizmo.q, Gizmo.v0);
-					Gizmo.q0.fromAxisAngle(Vec4.zAxis(), Context.raw.gizmoDrag - Context.raw.gizmoDragLast);
-					Gizmo.q.multquats(Gizmo.q0, Gizmo.q);
-					Context.raw.layer.decalMat.compose(Gizmo.v, Gizmo.q, Gizmo.v0);
+					Mat4.decompose(Context.raw.layer.decalMat, Gizmo.v, Gizmo.q, Gizmo.v0);
+					Quat.fromAxisAngle(Gizmo.q0, Vec4.zAxis(), Context.raw.gizmoDrag - Context.raw.gizmoDragLast);
+					Quat.multquats(Gizmo.q, Gizmo.q0, Gizmo.q);
+					Mat4.compose(Context.raw.layer.decalMat, Gizmo.v, Gizmo.q, Gizmo.v0);
 				}
 				Context.raw.gizmoDragLast = Context.raw.gizmoDrag;
 
@@ -185,10 +185,10 @@ class Gizmo {
 
 			if (isObject) {
 				let t = paintObject.transform;
-				Gizmo.v.set(t.worldx(), t.worldy(), t.worldz());
+				Vec4.set(Gizmo.v, Transform.worldx(t), Transform.worldy(t), Transform.worldz(t));
 			}
 			else if (isDecal) {
-				Gizmo.v.set(Context.raw.layer.decalMat._30, Context.raw.layer.decalMat._31, Context.raw.layer.decalMat._32);
+				Vec4.set(Gizmo.v, Context.raw.layer.decalMat._30, Context.raw.layer.decalMat._31, Context.raw.layer.decalMat._32);
 			}
 
 			if (Context.raw.translateX || Context.raw.scaleX) {
@@ -216,7 +216,7 @@ class Gizmo {
 				let hit = RayCaster.planeIntersect(Vec4.xAxis(), Gizmo.v, Mouse.viewX, Mouse.viewY, Scene.camera);
 				if (hit != null) {
 					if (Context.raw.gizmoStarted) {
-						Context.raw.layer.decalMat.decompose(Gizmo.v, Gizmo.q, Gizmo.v0);
+						Mat4.decompose(Context.raw.layer.decalMat, Gizmo.v, Gizmo.q, Gizmo.v0);
 						Context.raw.gizmoOffset = Math.atan2(hit.y - Gizmo.v.y, hit.z - Gizmo.v.z);
 					}
 					Context.raw.gizmoDrag = Math.atan2(hit.y - Gizmo.v.y, hit.z - Gizmo.v.z) - Context.raw.gizmoOffset;
@@ -226,7 +226,7 @@ class Gizmo {
 				let hit = RayCaster.planeIntersect(Vec4.yAxis(), Gizmo.v, Mouse.viewX, Mouse.viewY, Scene.camera);
 				if (hit != null) {
 					if (Context.raw.gizmoStarted) {
-						Context.raw.layer.decalMat.decompose(Gizmo.v, Gizmo.q, Gizmo.v0);
+						Mat4.decompose(Context.raw.layer.decalMat, Gizmo.v, Gizmo.q, Gizmo.v0);
 						Context.raw.gizmoOffset = Math.atan2(hit.z - Gizmo.v.z, hit.x - Gizmo.v.x);
 					}
 					Context.raw.gizmoDrag = Math.atan2(hit.z - Gizmo.v.z, hit.x - Gizmo.v.x) - Context.raw.gizmoOffset;
@@ -236,7 +236,7 @@ class Gizmo {
 				let hit = RayCaster.planeIntersect(Vec4.zAxis(), Gizmo.v, Mouse.viewX, Mouse.viewY, Scene.camera);
 				if (hit != null) {
 					if (Context.raw.gizmoStarted) {
-						Context.raw.layer.decalMat.decompose(Gizmo.v, Gizmo.q, Gizmo.v0);
+						Mat4.decompose(Context.raw.layer.decalMat, Gizmo.v, Gizmo.q, Gizmo.v0);
 						Context.raw.gizmoOffset = Math.atan2(hit.y - Gizmo.v.y, hit.x - Gizmo.v.x);
 					}
 					Context.raw.gizmoDrag = Math.atan2(hit.y - Gizmo.v.y, hit.x - Gizmo.v.x) - Context.raw.gizmoOffset;

base/Sources/ImportArm.ts

@@ -79,9 +79,9 @@ class ImportArm {
 			}
 			if (Project.raw.camera_world != null) {
 				Scene.camera.base.transform.local = Mat4.fromFloat32Array(Project.raw.camera_world);
-				Scene.camera.base.transform.decompose();
+				Transform.decompose(Scene.camera.base.transform);
 				Scene.camera.data.fov = Project.raw.camera_fov;
-				Scene.camera.buildProjection();
+				CameraObject.buildProjection(Scene.camera);
 				let origin = Project.raw.camera_origin;
 				Camera.origins[0].x = origin[0];
 				Camera.origins[0].y = origin[1];
@@ -133,9 +133,9 @@ class ImportArm {
 			MeshData.create(project.mesh_data, (md: TMeshData) => {
 			///end
 
-				Context.raw.paintObject.setData(md);
-				Context.raw.paintObject.base.transform.scale.set(1, 1, 1);
-				Context.raw.paintObject.base.transform.buildMatrix();
+				MeshObject.setData(Context.raw.paintObject, md);
+				Vec4.set(Context.raw.paintObject.base.transform.scale, 1, 1, 1);
+				Transform.buildMatrix(Context.raw.paintObject.base.transform);
 				Context.raw.paintObject.base.name = md.name;
 				Project.paintObjects = [Context.raw.paintObject];
 			});
@@ -365,9 +365,9 @@ class ImportArm {
 		Project.paintObjects = [];
 		for (let i = 0; i < raw.mesh_datas.length; ++i) {
 			MeshData.create(raw.mesh_datas[i], (md: TMeshData) => {
-				let object: MeshObject = null;
+				let object: TMeshObject = null;
 				if (i == 0) {
-					Context.raw.paintObject.setData(md);
+					MeshObject.setData(Context.raw.paintObject, md);
 					object = Context.raw.paintObject;
 				}
 				else {
@@ -377,8 +377,8 @@ class ImportArm {
 					md._handle = md.name;
 					Data.cachedMeshes.set(md._handle, md);
 				}
-				object.base.transform.scale.set(1, 1, 1);
-				object.base.transform.buildMatrix();
+				Vec4.set(object.base.transform.scale, 1, 1, 1);
+				Transform.buildMatrix(object.base.transform);
 				object.base.name = md.name;
 				Project.paintObjects.push(object);
 				UtilMesh.mergeMesh();

base/Sources/ImportBlendMesh.ts

@@ -80,9 +80,9 @@ class ImportBlendMesh {
 				let cola = hascol ? new Int16Array(numtri * 3 * 3) : null;
 
 				let tri = 0;
-				let vec0 = new Vec4();
-				let vec1 = new Vec4();
-				let vec2 = new Vec4();
+				let vec0 = Vec4.create();
+				let vec1 = Vec4.create();
+				let vec2 = Vec4.create();
 				for (let i = 0; i < totpoly; ++i) {
 					let poly = BlHandle.get(m, "mpoly", i);
 					// let smooth = BlHandle.get(poly, "flag") & 1 == 1; // ME_SMOOTH
@@ -97,8 +97,8 @@ class ImportBlendMesh {
 						let no0 = BlHandle.get(v0, "no");
 						let no1 = BlHandle.get(v1, "no");
 						if (smooth) {
-							vec0.set(no0[0] / 32767, no0[1] / 32767, no0[2] / 32767).normalize(); // shortmax
-							vec1.set(no1[0] / 32767, no1[1] / 32767, no1[2] / 32767).normalize();
+							Vec4.normalize(Vec4.set(vec0, no0[0] / 32767, no0[1] / 32767, no0[2] / 32767)); // shortmax
+							Vec4.normalize(Vec4.set(vec1, no1[0] / 32767, no1[1] / 32767, no1[2] / 32767));
 						}
 						let uv0: Float32Array = null;
 						let uv1: Float32Array = null;
@@ -137,16 +137,16 @@ class ImportBlendMesh {
 							let co2 = BlHandle.get(v2, "co");
 							let no2 = BlHandle.get(v2, "no");
 							if (smooth) {
-								vec2.set(no2[0] / 32767, no2[1] / 32767, no2[2] / 32767).normalize();
+								Vec4.normalize(Vec4.set(vec2, no2[0] / 32767, no2[1] / 32767, no2[2] / 32767));
 							}
 							else {
-								vec2.set(co2[0], co2[1], co2[2]);
-								vec1.set(co1[0], co1[1], co1[2]);
-								vec0.subvecs(vec2, vec1);
-								vec2.set(co0[0], co0[1], co0[2]);
-								vec1.subvecs(vec2, vec1);
-								vec0.cross(vec1);
-								vec0.normalize();
+								Vec4.set(vec2, co2[0], co2[1], co2[2]);
+								Vec4.set(vec1, co1[0], co1[1], co1[2]);
+								Vec4.subvecs(vec0, vec2, vec1);
+								Vec4.set(vec2, co0[0], co0[1], co0[2]);
+								Vec4.subvecs(vec1, vec2, vec1);
+								Vec4.cross(vec0, vec1);
+								Vec4.normalize(vec0);
 							}
 							posa32[tri * 9    ] = co0[0];
 							posa32[tri * 9 + 1] = co0[1];
@@ -168,7 +168,7 @@ class ImportBlendMesh {
 							nora[tri * 6 + 5] = Math.floor((smooth ? vec2.y : vec0.y) * 32767);
 							co1 = co2;
 							no1 = no2;
-							vec1.setFrom(vec2);
+							Vec4.setFrom(vec1, vec2);
 							if (hasuv) {
 								bl.pos = uvdata_pos + (loopstart + j + 1) * 4 * 3;
 								uv2 = ParserBlend.readf32array(bl, 2);
@@ -212,13 +212,13 @@ class ImportBlendMesh {
 						let co0 = BlHandle.get(v0, "co");
 						let co1 = BlHandle.get(v1, "co");
 						let co2 = BlHandle.get(v2, "co");
-						vec2.set(co2[0], co2[1], co2[2]);
-						vec1.set(co1[0], co1[1], co1[2]);
-						vec0.subvecs(vec2, vec1);
-						vec2.set(co0[0], co0[1], co0[2]);
-						vec1.subvecs(vec2, vec1);
-						vec0.cross(vec1);
-						vec0.normalize();
+						Vec4.set(vec2, co2[0], co2[1], co2[2]);
+						Vec4.set(vec1, co1[0], co1[1], co1[2]);
+						Vec4.subvecs(vec0, vec2, vec1);
+						Vec4.set(vec2, co0[0], co0[1], co0[2]);
+						Vec4.subvecs(vec1, vec2, vec1);
+						Vec4.cross(vec0, vec1);
+						Vec4.normalize(vec0, );
 
 						let nx = vec0.x;
 						let ny = vec0.y;
@@ -291,18 +291,18 @@ class ImportBlendMesh {
 								let no1 = BlHandle.get(v1, "no");
 								let no2 = BlHandle.get(v2, "no");
 								if (smooth) {
-									vec0.set(no0[0] / 32767, no0[1] / 32767, no0[2] / 32767).normalize(); // shortmax
-									vec1.set(no1[0] / 32767, no1[1] / 32767, no1[2] / 32767).normalize();
-									vec2.set(no2[0] / 32767, no2[1] / 32767, no2[2] / 32767).normalize();
+									Vec4.normalize(Vec4.set(vec0, no0[0] / 32767, no0[1] / 32767, no0[2] / 32767)); // shortmax
+									Vec4.normalize(Vec4.set(vec1, no1[0] / 32767, no1[1] / 32767, no1[2] / 32767));
+									Vec4.normalize(Vec4.set(vec2, no2[0] / 32767, no2[1] / 32767, no2[2] / 32767));
 								}
 								else {
-									vec2.set(co2[0], co2[1], co2[2]);
-									vec1.set(co1[0], co1[1], co1[2]);
-									vec0.subvecs(vec2, vec1);
-									vec2.set(co0[0], co0[1], co0[2]);
-									vec1.subvecs(vec2, vec1);
-									vec0.cross(vec1);
-									vec0.normalize();
+									Vec4.set(vec2, co2[0], co2[1], co2[2]);
+									Vec4.set(vec1, co1[0], co1[1], co1[2]);
+									Vec4.subvecs(vec0, vec2, vec1);
+									Vec4.set(vec2, co0[0], co0[1], co0[2]);
+									Vec4.subvecs(vec1, vec2, vec1);
+									Vec4.cross(vec0, vec1);
+									Vec4.normalize(vec0, );
 								}
 								let uv0: Float32Array = null;
 								let uv1: Float32Array = null;
@@ -396,22 +396,22 @@ class ImportBlendMesh {
 
 				// Apply world matrix
 				let obmat = BlHandle.get(ob, "obmat", 0, "float", 16);
-				let mat = Mat4.fromFloat32Array(obmat).transpose();
-				let v = new Vec4();
+				let mat = Mat4.transpose(Mat4.fromFloat32Array(obmat));
+				let v = Vec4.create();
 				for (let i = 0; i < Math.floor(posa32.length / 3); ++i) {
-					v.set(posa32[i * 3], posa32[i * 3 + 1], posa32[i * 3 + 2]);
-					v.applymat4(mat);
+					Vec4.set(v, posa32[i * 3], posa32[i * 3 + 1], posa32[i * 3 + 2]);
+					Vec4.applymat4(v, mat);
 					posa32[i * 3    ] = v.x;
 					posa32[i * 3 + 1] = v.y;
 					posa32[i * 3 + 2] = v.z;
 				}
-				mat.getInverse(mat);
-				mat.transpose3x3();
+				Mat4.getInverse(mat, mat);
+				Mat4.transpose3x3(mat);
 				mat._30 = mat._31 = mat._32 = mat._33 = 0;
 				for (let i = 0; i < Math.floor(nora.length / 2); ++i) {
-					v.set(nora[i * 2] / 32767, nora[i * 2 + 1] / 32767, posa[i * 4 + 3] / 32767);
-					v.applymat(mat);
-					v.normalize();
+					Vec4.set(v, nora[i * 2] / 32767, nora[i * 2 + 1] / 32767, posa[i * 4 + 3] / 32767);
+					Vec4.applymat(v, mat);
+					Vec4.normalize(v);
 					nora[i * 2    ] = Math.floor(v.x * 32767);
 					nora[i * 2 + 1] = Math.floor(v.y * 32767);
 					posa[i * 4 + 3] = Math.floor(v.z * 32767);

base/Sources/ImportEnvmap.ts

@@ -3,8 +3,8 @@ class ImportEnvmap {
 
 	static pipeline: PipelineState = null;
 	static paramsLocation: ConstantLocation;
-	static params = new Vec4();
-	static n = new Vec4();
+	static params = Vec4.create();
+	static n = Vec4.create();
 	static radianceLocation: TextureUnit;
 	static radiance: Image = null;
 	static radianceCpu: Image = null;
@@ -103,11 +103,11 @@ class ImportEnvmap {
 		mip.g4.end();
 	}
 
-	static reverseEquirect = (x: f32, y: f32): Vec4 => {
+	static reverseEquirect = (x: f32, y: f32): TVec4 => {
 		let theta = x * Math.PI * 2 - Math.PI;
 		let phi = y * Math.PI;
 		// return n.set(Math.sin(phi) * Math.cos(theta), -(Math.sin(phi) * Math.sin(theta)), Math.cos(phi));
-		return ImportEnvmap.n.set(-Math.cos(phi), Math.sin(phi) * Math.cos(theta), -(Math.sin(phi) * Math.sin(theta)));
+		return Vec4.set(ImportEnvmap.n, -Math.cos(phi), Math.sin(phi) * Math.cos(theta), -(Math.sin(phi) * Math.sin(theta)));
 	}
 
 	// https://ndotl.wordpress.com/2015/03/07/pbr-cubemap-filtering

base/Sources/ImportMesh.ts

@@ -62,7 +62,7 @@ class ImportMesh {
 	static finishImport = () => {
 		if (Context.raw.mergedObject != null) {
 			MeshData.delete(Context.raw.mergedObject.data);
-			Context.raw.mergedObject.remove();
+			MeshObject.remove(Context.raw.mergedObject);
 			Context.raw.mergedObject = null;
 		}
 
@@ -114,14 +114,14 @@ class ImportMesh {
 				let p = Project.paintObjects[i];
 				if (p == Context.raw.paintObject) continue;
 				Data.deleteMesh(p.data._handle);
-				p.remove();
+				MeshObject.remove(p);
 			}
 			let handle = Context.raw.paintObject.data._handle;
 			if (handle != "SceneSphere" && handle != "ScenePlane") {
 				Data.deleteMesh(handle);
 			}
 
-			Context.raw.paintObject.setData(md);
+			MeshObject.setData(Context.raw.paintObject, md);
 			Context.raw.paintObject.base.name = mesh.name;
 			Project.paintObjects = [Context.raw.paintObject];
 

base/Sources/LineDraw.ts

@@ -3,14 +3,14 @@ class LineDraw {
 
 	static color: Color = 0xffff0000;
 	static strength = 0.005;
-	static mat: Mat4 = null;
-	static dim: Vec4 = null;
+	static mat: TMat4 = null;
+	static dim: TVec4 = null;
 
 	static vertexBuffer: VertexBuffer;
 	static indexBuffer: IndexBuffer;
 	static pipeline: PipelineState = null;
 
-	static vp: Mat4;
+	static vp: TMat4;
 	static vpID: ConstantLocation;
 
 	static vbData: DataView;
@@ -23,10 +23,10 @@ class LineDraw {
 
 	static g: Graphics4;
 
-	static render = (g4: Graphics4, matrix: Mat4) => {
+	static render = (g4: Graphics4, matrix: TMat4) => {
 		LineDraw.g = g4;
 		LineDraw.mat = matrix;
-		LineDraw.dim = matrix.getScale();
+		LineDraw.dim = Mat4.getScale(matrix);
 
 		if (LineDraw.pipeline == null) {
 			let structure = new VertexStructure();
@@ -56,30 +56,30 @@ class LineDraw {
 		LineDraw.end();
 	}
 
-	static wpos: Vec4;
-	static vx = new Vec4();
-	static vy = new Vec4();
-	static vz = new Vec4();
+	static wpos: TVec4;
+	static vx = Vec4.create();
+	static vy = Vec4.create();
+	static vz = Vec4.create();
 
-	static bounds = (mat: Mat4, dim: Vec4) => {
-		LineDraw.wpos = mat.getLoc();
+	static bounds = (mat: TMat4, dim: TVec4) => {
+		LineDraw.wpos = Mat4.getLoc(mat);
 		let dx = dim.x / 2;
 		let dy = dim.y / 2;
 		let dz = dim.z / 2;
 
-		let up = mat.up();
-		let look = mat.look();
-		let right = mat.right();
-		up.normalize();
-		look.normalize();
-		right.normalize();
+		let up = Mat4.up(mat);
+		let look = Mat4.look(mat);
+		let right = Mat4.right(mat);
+		Vec4.normalize(up);
+		Vec4.normalize(look);
+		Vec4.normalize(right);
 
-		LineDraw.vx.setFrom(right);
-		LineDraw.vx.mult(dx);
-		LineDraw.vy.setFrom(look);
-		LineDraw.vy.mult(dy);
-		LineDraw.vz.setFrom(up);
-		LineDraw.vz.mult(dz);
+		Vec4.setFrom(LineDraw.vx, right);
+		Vec4.mult(LineDraw.vx, dx);
+		Vec4.setFrom(LineDraw.vy, look);
+		Vec4.mult(LineDraw.vy, dy);
+		Vec4.setFrom(LineDraw.vz, up);
+		Vec4.mult(LineDraw.vz, dz);
 
 		LineDraw.lineb(-1, -1, -1,  1, -1, -1);
 		LineDraw.lineb(-1,  1, -1,  1,  1, -1);
@@ -97,31 +97,31 @@ class LineDraw {
 		LineDraw.lineb( 1,  1, -1,  1,  1,  1);
 	}
 
-	static v1 = new Vec4();
-	static v2 = new Vec4();
-	static t = new Vec4();
+	static v1 = Vec4.create();
+	static v2 = Vec4.create();
+	static t = Vec4.create();
 
 	static lineb = (a: i32, b: i32, c: i32, d: i32, e: i32, f: i32) => {
-		LineDraw.v1.setFrom(LineDraw.wpos);
-		LineDraw.t.setFrom(LineDraw.vx); LineDraw.t.mult(a); LineDraw.v1.add(LineDraw.t);
-		LineDraw.t.setFrom(LineDraw.vy); LineDraw.t.mult(b); LineDraw.v1.add(LineDraw.t);
-		LineDraw.t.setFrom(LineDraw.vz); LineDraw.t.mult(c); LineDraw.v1.add(LineDraw.t);
+		Vec4.setFrom(LineDraw.v1, LineDraw.wpos);
+		Vec4.setFrom(LineDraw.t, LineDraw.vx); Vec4.mult(LineDraw.t, a); Vec4.add(LineDraw.v1, LineDraw.t);
+		Vec4.setFrom(LineDraw.t, LineDraw.vy); Vec4.mult(LineDraw.t, b); Vec4.add(LineDraw.v1, LineDraw.t);
+		Vec4.setFrom(LineDraw.t, LineDraw.vz); Vec4.mult(LineDraw.t, c); Vec4.add(LineDraw.v1, LineDraw.t);
 
-		LineDraw.v2.setFrom(LineDraw.wpos);
-		LineDraw.t.setFrom(LineDraw.vx); LineDraw.t.mult(d); LineDraw.v2.add(LineDraw.t);
-		LineDraw.t.setFrom(LineDraw.vy); LineDraw.t.mult(e); LineDraw.v2.add(LineDraw.t);
-		LineDraw.t.setFrom(LineDraw.vz); LineDraw.t.mult(f); LineDraw.v2.add(LineDraw.t);
+		Vec4.setFrom(LineDraw.v2, LineDraw.wpos);
+		Vec4.setFrom(LineDraw.t, LineDraw.vx); Vec4.mult(LineDraw.t, d); Vec4.add(LineDraw.v2, LineDraw.t);
+		Vec4.setFrom(LineDraw.t, LineDraw.vy); Vec4.mult(LineDraw.t, e); Vec4.add(LineDraw.v2, LineDraw.t);
+		Vec4.setFrom(LineDraw.t, LineDraw.vz); Vec4.mult(LineDraw.t, f); Vec4.add(LineDraw.v2, LineDraw.t);
 
 		LineDraw.line(LineDraw.v1.x, LineDraw.v1.y, LineDraw.v1.z, LineDraw.v2.x, LineDraw.v2.y, LineDraw.v2.z);
 	}
 
-	static midPoint = new Vec4();
-	static midLine = new Vec4();
-	static corner1 = new Vec4();
-	static corner2 = new Vec4();
-	static corner3 = new Vec4();
-	static corner4 = new Vec4();
-	static cameraLook = new Vec4();
+	static midPoint = Vec4.create();
+	static midLine = Vec4.create();
+	static corner1 = Vec4.create();
+	static corner2 = Vec4.create();
+	static corner3 = Vec4.create();
+	static corner4 = Vec4.create();
+	static cameraLook = Vec4.create();
 
 	static line = (x1: f32, y1: f32, z1: f32, x2: f32, y2: f32, z2: f32) => {
 		if (LineDraw.lines >= LineDraw.maxLines) {
@@ -129,24 +129,24 @@ class LineDraw {
 			LineDraw.begin();
 		}
 
-		LineDraw.midPoint.set(x1 + x2, y1 + y2, z1 + z2);
-		LineDraw.midPoint.mult(0.5);
+		Vec4.set(LineDraw.midPoint, x1 + x2, y1 + y2, z1 + z2);
+		Vec4.mult(LineDraw.midPoint, 0.5);
 
-		LineDraw.midLine.set(x1, y1, z1);
-		LineDraw.midLine.sub(LineDraw.midPoint);
+		Vec4.set(LineDraw.midLine, x1, y1, z1);
+		Vec4.sub(LineDraw.midLine, LineDraw.midPoint);
 
 		let camera = Scene.camera;
-		LineDraw.cameraLook = camera.base.transform.world.getLoc();
-		LineDraw.cameraLook.sub(LineDraw.midPoint);
+		LineDraw.cameraLook = Mat4.getLoc(camera.base.transform.world);
+		Vec4.sub(LineDraw.cameraLook, LineDraw.midPoint);
 
-		let lineWidth = LineDraw.cameraLook.cross(LineDraw.midLine);
-		lineWidth.normalize();
-		lineWidth.mult(LineDraw.strength);
+		let lineWidth = Vec4.cross(LineDraw.cameraLook, LineDraw.midLine);
+		Vec4.normalize(lineWidth, );
+		Vec4.mult(lineWidth, LineDraw.strength);
 
-		LineDraw.corner1.set(x1, y1, z1).add(lineWidth);
-		LineDraw.corner2.set(x1, y1, z1).sub(lineWidth);
-		LineDraw.corner3.set(x2, y2, z2).sub(lineWidth);
-		LineDraw.corner4.set(x2, y2, z2).add(lineWidth);
+		Vec4.add(Vec4.set(LineDraw.corner1, x1, y1, z1), lineWidth);
+		Vec4.sub(Vec4.set(LineDraw.corner2, x1, y1, z1), lineWidth);
+		Vec4.sub(Vec4.set(LineDraw.corner3, x2, y2, z2), lineWidth);
+		Vec4.add(Vec4.set(LineDraw.corner4, x2, y2, z2), lineWidth);
 
 		let i = LineDraw.lines * 24; // 4 * 6 (structure len)
 		LineDraw.addVbData(i, [LineDraw.corner1.x, LineDraw.corner1.y, LineDraw.corner1.z, color_get_rb(LineDraw.color) / 255, color_get_gb(LineDraw.color) / 255, color_get_ab(LineDraw.color) / 255]);
@@ -182,8 +182,8 @@ class LineDraw {
 		LineDraw.g.setIndexBuffer(LineDraw.indexBuffer);
 		LineDraw.g.setPipeline(LineDraw.pipeline);
 		let camera = Scene.camera;
-		LineDraw.vp.setFrom(camera.V);
-		LineDraw.vp.multmat(camera.P);
+		Mat4.setFrom(LineDraw.vp, camera.V);
+		Mat4.multmat(LineDraw.vp, camera.P);
 		LineDraw.g.setMatrix(LineDraw.vpID, LineDraw.vp);
 		LineDraw.g.drawIndexedVertices(0, LineDraw.lines * 6);
 	}

base/Sources/MakeVoxel.ts

@@ -13,8 +13,8 @@ class MakeVoxel {
 		data.vertex_elements = [{name: "pos", data: "short4norm"}, {name: "nor", data: "short2norm"}, {name: "tex", data: "short2norm"}];
 
 		// ///if arm_skin
-		// let isMesh = Context.raw.object.constructor == MeshObject;
-		// let skin = isMesh && cast(Context.raw.object, MeshObject).data.geom.bones != null;
+		// let isMesh = Context.raw.object.constructor == TMeshObject;
+		// let skin = isMesh && cast(Context.raw.object, TMeshObject).data.geom.bones != null;
 		// if (skin) {
 		// 	structure.add("bone", VertexData.I16_4X_Normalized);
 		// 	structure.add("weight", VertexData.I16_4X_Normalized);

base/Sources/PhysicsBody.ts

@@ -19,7 +19,7 @@ class PhysicsBodyRaw {
 		else this._mass = f;
 	}
 
-	object: BaseObject;
+	object: TBaseObject;
 	friction = 0.5;
 	restitution = 0.0;
 	collisionMargin = 0.0;
@@ -62,7 +62,7 @@ class PhysicsBody {
 	static quat1: Ammo.btQuaternion;
 	static trans1: Ammo.btTransform;
 	static trans2: Ammo.btTransform;
-	static quat = new Quat();
+	static quat = Quat.create();
 
 	static convexHullCache = new Map<TMeshData, Ammo.btConvexHullShape>();
 	static triangleMeshCache = new Map<TMeshData, Ammo.btTriangleMesh>();
@@ -86,12 +86,12 @@ class PhysicsBody {
 		return f - f * pb.collisionMargin;
 	}
 
-	static init = (pb: PhysicsBodyRaw, o: BaseObject) => {
+	static init = (pb: PhysicsBodyRaw, o: TBaseObject) => {
 		pb.object = o;
 		if (pb.ready) return;
 		pb.ready = true;
 
-		if (pb.object.constructor != MeshObject) return; // No mesh data
+		if (pb.object.ext.constructor != TMeshObject) return; // No mesh data
 		let transform = o.transform;
 		let physics = PhysicsWorld.active;
 
@@ -170,11 +170,11 @@ class PhysicsBody {
 		}
 
 		PhysicsBody.trans1.setIdentity();
-		PhysicsBody.vec1.setX(transform.worldx());
-		PhysicsBody.vec1.setY(transform.worldy());
-		PhysicsBody.vec1.setZ(transform.worldz());
+		PhysicsBody.vec1.setX(Transform.worldx(transform));
+		PhysicsBody.vec1.setY(Transform.worldy(transform));
+		PhysicsBody.vec1.setZ(Transform.worldz(transform));
 		PhysicsBody.trans1.setOrigin(PhysicsBody.vec1);
-		PhysicsBody.quat.fromMat(transform.world);
+		Quat.fromMat(PhysicsBody.quat, transform.world);
 		PhysicsBody.quat1.setValue(PhysicsBody.quat.x, PhysicsBody.quat.y, PhysicsBody.quat.z, PhysicsBody.quat.w);
 		PhysicsBody.trans1.setRotation(PhysicsBody.quat1);
 		PhysicsBody.trans2.setIdentity();
@@ -226,15 +226,15 @@ class PhysicsBody {
 		let qw: Ammo.btQuadWord = q;
 
 		let transform = pb.object.transform;
-		transform.loc.set(p.x(), p.y(), p.z());
-		transform.rot.set(qw.x(), qw.y(), qw.z(), qw.w());
+		Vec4.set(transform.loc, p.x(), p.y(), p.z());
+		Quat.set(transform.rot, qw.x(), qw.y(), qw.z(), qw.w());
 		if (pb.object.parent != null) {
 			let ptransform = pb.object.parent.transform;
-			transform.loc.x -= ptransform.worldx();
-			transform.loc.y -= ptransform.worldy();
-			transform.loc.z -= ptransform.worldz();
+			transform.loc.x -= Transform.worldx(ptransform);
+			transform.loc.y -= Transform.worldy(ptransform);
+			transform.loc.z -= Transform.worldz(ptransform);
 		}
-		transform.buildMatrix();
+		Transform.buildMatrix(transform);
 	}
 
 	static removeFromWorld = (pb: PhysicsBodyRaw) => {
@@ -245,12 +245,12 @@ class PhysicsBody {
 		pb.body.activate(false);
 	}
 
-	static setGravity = (pb: PhysicsBodyRaw, v: Vec4) => {
+	static setGravity = (pb: PhysicsBodyRaw, v: TVec4) => {
 		PhysicsBody.vec1.setValue(v.x, v.y, v.z);
 		pb.body.setGravity(PhysicsBody.vec1);
 	}
 
-	static applyForce = (pb: PhysicsBodyRaw, force: Vec4, loc: Vec4 = null) => {
+	static applyForce = (pb: PhysicsBodyRaw, force: TVec4, loc: TVec4 = null) => {
 		PhysicsBody.activate(pb);
 		PhysicsBody.vec1.setValue(force.x, force.y, force.z);
 		if (loc == null) {
@@ -262,7 +262,7 @@ class PhysicsBody {
 		}
 	}
 
-	static applyImpulse = (pb: PhysicsBodyRaw, impulse: Vec4, loc: Vec4 = null) => {
+	static applyImpulse = (pb: PhysicsBodyRaw, impulse: TVec4, loc: TVec4 = null) => {
 		PhysicsBody.activate(pb);
 		PhysicsBody.vec1.setValue(impulse.x, impulse.y, impulse.z);
 		if (loc == null) {
@@ -274,13 +274,13 @@ class PhysicsBody {
 		}
 	}
 
-	static applyTorque = (pb: PhysicsBodyRaw, torque: Vec4) => {
+	static applyTorque = (pb: PhysicsBodyRaw, torque: TVec4) => {
 		PhysicsBody.activate(pb);
 		PhysicsBody.vec1.setValue(torque.x, torque.y, torque.z);
 		pb.body.applyTorque(PhysicsBody.vec1);
 	}
 
-	static applyTorqueImpulse = (pb: PhysicsBodyRaw, torque: Vec4) => {
+	static applyTorqueImpulse = (pb: PhysicsBodyRaw, torque: TVec4) => {
 		PhysicsBody.activate(pb);
 		PhysicsBody.vec1.setValue(torque.x, torque.y, torque.z);
 		pb.body.applyTorqueImpulse(PhysicsBody.vec1);
@@ -296,9 +296,9 @@ class PhysicsBody {
 		pb.body.setAngularFactor(PhysicsBody.vec1);
 	}
 
-	static getLinearVelocity = (pb: PhysicsBodyRaw): Vec4 => {
+	static getLinearVelocity = (pb: PhysicsBodyRaw): TVec4 => {
 		let v = pb.body.getLinearVelocity();
-		return new Vec4(v.x(), v.y(), v.z());
+		return Vec4.create(v.x(), v.y(), v.z());
 	}
 
 	static setLinearVelocity = (pb: PhysicsBodyRaw, x: f32, y: f32, z: f32) => {
@@ -306,9 +306,9 @@ class PhysicsBody {
 		pb.body.setLinearVelocity(PhysicsBody.vec1);
 	}
 
-	static getAngularVelocity = (pb: PhysicsBodyRaw): Vec4 => {
+	static getAngularVelocity = (pb: PhysicsBodyRaw): TVec4 => {
 		let v = pb.body.getAngularVelocity();
-		return new Vec4(v.x(), v.y(), v.z());
+		return Vec4.create(v.x(), v.y(), v.z());
 	}
 
 	static setAngularVelocity = (pb: PhysicsBodyRaw, x: f32, y: f32, z: f32) => {
@@ -321,7 +321,7 @@ class PhysicsBody {
 		pb.friction = f;
 	}
 
-	static setScale = (pb: PhysicsBodyRaw, v: Vec4) => {
+	static setScale = (pb: PhysicsBodyRaw, v: TVec4) => {
 		pb.currentScaleX = v.x;
 		pb.currentScaleY = v.y;
 		pb.currentScaleZ = v.z;
@@ -336,10 +336,10 @@ class PhysicsBody {
 
 	static syncTransform = (pb: PhysicsBodyRaw) => {
 		let t = pb.object.transform;
-		t.buildMatrix();
-		PhysicsBody.vec1.setValue(t.worldx(), t.worldy(), t.worldz());
+		Transform.buildMatrix(t);
+		PhysicsBody.vec1.setValue(Transform.worldx(t), Transform.worldy(t), Transform.worldz(t));
 		PhysicsBody.trans1.setOrigin(PhysicsBody.vec1);
-		PhysicsBody.quat.fromMat(t.world);
+		Quat.fromMat(PhysicsBody.quat, t.world);
 		PhysicsBody.quat1.setValue(PhysicsBody.quat.x, PhysicsBody.quat.y, PhysicsBody.quat.z, PhysicsBody.quat.w);
 		PhysicsBody.trans1.setRotation(PhysicsBody.quat1);
 		pb.body.setWorldTransform(PhysicsBody.trans1);
@@ -352,7 +352,7 @@ class PhysicsBody {
 		pb.body.setCcdMotionThreshold(motionThreshold);
 	}
 
-	static fillConvexHull = (pb: PhysicsBodyRaw, scale: Vec4, margin: f32): Ammo.btConvexHullShape => {
+	static fillConvexHull = (pb: PhysicsBodyRaw, scale: TVec4, margin: f32): Ammo.btConvexHullShape => {
 		// Check whether shape already exists
 		let data = pb.object.ext.data;
 		let shape = PhysicsBody.convexHullCache.get(data);
@@ -384,7 +384,7 @@ class PhysicsBody {
 		return shape;
 	}
 
-	static fillTriangleMesh = (pb: PhysicsBodyRaw, scale: Vec4): Ammo.btTriangleMesh => {
+	static fillTriangleMesh = (pb: PhysicsBodyRaw, scale: TVec4): Ammo.btTriangleMesh => {
 		// Check whether shape already exists
 		let data = pb.object.ext.data;
 		let triangleMesh = PhysicsBody.triangleMeshCache.get(data);

base/Sources/PhysicsWorld.ts

@@ -16,8 +16,8 @@ class PhysicsWorld {
 	static active: PhysicsWorldRaw = null;
 	static vec1: Ammo.btVector3 = null;
 	static vec2: Ammo.btVector3 = null;
-	static v1 = new Vec4();
-	static v2 = new Vec4();
+	static v1 = Vec4.create();
+	static v2 = Vec4.create();
 
 	static load = (done: ()=>void) => {
 		let b = Krom.loadBlob("data/plugins/ammo.js");
@@ -45,10 +45,10 @@ class PhysicsWorld {
 		pw.dispatcher = new Ammo.btCollisionDispatcher(collisionConfiguration);
 		let solver = new Ammo.btSequentialImpulseConstraintSolver();
 		pw.world = new Ammo.btDiscreteDynamicsWorld(pw.dispatcher, broadphase, solver, collisionConfiguration);
-		PhysicsWorld.setGravity(pw, new Vec4(0, 0, -9.81));
+		PhysicsWorld.setGravity(pw, Vec4.create(0, 0, -9.81));
 	}
 
-	static setGravity = (pw: PhysicsWorldRaw, v: Vec4) => {
+	static setGravity = (pw: PhysicsWorldRaw, v: TVec4) => {
 		PhysicsWorld.vec1.setValue(v.x, v.y, v.z);
 		pw.world.setGravity(PhysicsWorld.vec1);
 	}
@@ -122,9 +122,9 @@ class PhysicsWorld {
 				let cp: TPair = {
 					a: body0.userIndex,
 					b: body1.userIndex,
-					posA: new Vec4(posA.x(), posA.y(), posA.z()),
-					posB: new Vec4(posB.x(), posB.y(), posB.z()),
-					normOnB: new Vec4(nor.x(), nor.y(), nor.z()),
+					posA: Vec4.create(posA.x(), posA.y(), posA.z()),
+					posB: Vec4.create(posB.x(), posB.y(), posB.z()),
+					normOnB: Vec4.create(nor.x(), nor.y(), nor.z()),
 					impulse: pt.getAppliedImpulse(),
 					distance: pt.getDistance()
 				};
@@ -135,15 +135,15 @@ class PhysicsWorld {
 
 	static pickClosest = (pw: PhysicsWorldRaw, inputX: f32, inputY: f32): PhysicsBodyRaw => {
 		let camera = Scene.camera;
-		let start = new Vec4();
-		let end = new Vec4();
+		let start = Vec4.create();
+		let end = Vec4.create();
 		RayCaster.getDirection(start, end, inputX, inputY, camera);
-		let hit = PhysicsWorld.rayCast(pw, camera.base.transform.world.getLoc(), end);
+		let hit = PhysicsWorld.rayCast(pw, Mat4.getLoc(camera.base.transform.world), end);
 		let body = (hit != null) ? hit.body : null;
 		return body;
 	}
 
-	static rayCast = (pw: PhysicsWorldRaw, from: Vec4, to: Vec4, group: i32 = 0x00000001, mask = 0xffffffff): THit => {
+	static rayCast = (pw: PhysicsWorldRaw, from: TVec4, to: TVec4, group: i32 = 0x00000001, mask = 0xffffffff): THit => {
 		let rayFrom = PhysicsWorld.vec1;
 		let rayTo = PhysicsWorld.vec2;
 		rayFrom.setValue(from.x, from.y, from.z);
@@ -165,9 +165,9 @@ class PhysicsWorld {
 			let co = rayCallback.get_m_collisionObject();
 			let body = Ammo.btRigidBody.prototype.upcast(co);
 			let hit = rayCallback.get_m_hitPointWorld();
-			PhysicsWorld.v1.set(hit.x(), hit.y(), hit.z());
+			Vec4.set(PhysicsWorld.v1, hit.x(), hit.y(), hit.z());
 			let norm = rayCallback.get_m_hitNormalWorld();
-			PhysicsWorld.v2.set(norm.x(), norm.y(), norm.z());
+			Vec4.set(PhysicsWorld.v2, norm.x(), norm.y(), norm.z());
 			pb = pw.bodyMap.get(body.userIndex);
 			hitInfo = {
 				body: pb,
@@ -183,16 +183,16 @@ class PhysicsWorld {
 
 type THit = {
 	body: PhysicsBodyRaw;
-	pos: Vec4;
-	normal: Vec4;
+	pos: TVec4;
+	normal: TVec4;
 }
 
 type TPair = {
 	a: i32;
 	b: i32;
-	posA: Vec4;
-	posB: Vec4;
-	normOnB: Vec4;
+	posA: TVec4;
+	posB: TVec4;
+	normOnB: TVec4;
 	impulse: f32;
 	distance: f32;
 }

base/Sources/Project.ts

@@ -8,7 +8,7 @@ class Project {
 	static assetId = 0;
 	static meshAssets: string[] = [];
 	static materialGroups: TNodeGroup[] = [];
-	static paintObjects: MeshObject[] = null;
+	static paintObjects: TMeshObject[] = null;
 	static assetMap = new Map<i32, any>(); // Image | Font
 	static meshList: string[] = null;
 	///if (is_paint || is_sculpt)
@@ -123,7 +123,7 @@ class Project {
 
 		///if (is_paint || is_sculpt)
 		if (Context.raw.mergedObject != null) {
-			Context.raw.mergedObject.remove();
+			MeshObject.remove(Context.raw.mergedObject);
 			Data.deleteMesh(Context.raw.mergedObject.data._handle);
 			Context.raw.mergedObject = null;
 		}
@@ -140,7 +140,7 @@ class Project {
 			let p = Project.paintObjects[i];
 			if (p == Context.raw.paintObject) continue;
 			Data.deleteMesh(p.data._handle);
-			p.remove();
+			MeshObject.remove(p);
 		}
 		let meshes = Scene.meshes;
 		let len = meshes.length;
@@ -150,7 +150,7 @@ class Project {
 				m.base.name != ".ParticleEmitter" &&
 				m.base.name != ".Particle") {
 				Data.deleteMesh(m.data._handle);
-				m.remove();
+				MeshObject.remove(m);
 			}
 		}
 		let handle = Context.raw.paintObject.data._handle;
@@ -213,9 +213,9 @@ class Project {
 			Context.raw.pickerMaskHandle.position = PickerMask.MaskNone;
 			///end
 
-			Context.raw.paintObject.setData(md);
-			Context.raw.paintObject.base.transform.scale.set(1, 1, 1);
-			Context.raw.paintObject.base.transform.buildMatrix();
+			MeshObject.setData(Context.raw.paintObject, md);
+			Vec4.set(Context.raw.paintObject.base.transform.scale, 1, 1, 1);
+			Transform.buildMatrix(Context.raw.paintObject.base.transform);
 			Context.raw.paintObject.base.name = n;
 			Project.paintObjects = [Context.raw.paintObject];
 			///if (is_paint || is_sculpt)
@@ -570,17 +570,17 @@ class Project {
 		else return null;
 	}
 
-	static isAtlasObject = (p: MeshObject): bool => {
+	static isAtlasObject = (p: TMeshObject): bool => {
 		if (Context.raw.layerFilter <= Project.paintObjects.length) return false;
 		let atlasName = Project.getUsedAtlases()[Context.raw.layerFilter - Project.paintObjects.length - 1];
 		let atlasI = Project.atlasNames.indexOf(atlasName);
 		return atlasI == Project.atlasObjects[Project.paintObjects.indexOf(p)];
 	}
 
-	static getAtlasObjects = (objectMask: i32): MeshObject[] => {
+	static getAtlasObjects = (objectMask: i32): TMeshObject[] => {
 		let atlasName = Project.getUsedAtlases()[objectMask - Project.paintObjects.length - 1];
 		let atlasI = Project.atlasNames.indexOf(atlasName);
-		let visibles: MeshObject[] = [];
+		let visibles: TMeshObject[] = [];
 		for (let i = 0; i < Project.paintObjects.length; ++i) if (Project.atlasObjects[i] == atlasI) visibles.push(Project.paintObjects[i]);
 		return visibles;
 	}

base/Sources/RenderPathBase.ts

@@ -58,7 +58,7 @@ class RenderPathBase {
 	static drawCompass = (currentG: Graphics4) => {
 		if (Context.raw.showCompass) {
 			let cam = Scene.camera;
-			let compass: MeshObject = Scene.getChild(".Compass").ext;
+			let compass: TMeshObject = Scene.getChild(".Compass").ext;
 
 			let _visible = compass.base.visible;
 			let _parent = compass.base.parent;
@@ -70,19 +70,19 @@ class RenderPathBase {
 			cam.P = Mat4.ortho(-8 * ratio, 8 * ratio, -8, 8, -2, 2);
 			compass.base.visible = true;
 			compass.base.parent = cam.base;
-			compass.base.transform.loc = new Vec4(7.4 * ratio, 7.0, -1);
-			compass.base.transform.rot = new Quat(-crot.x, -crot.y, -crot.z, crot.w);
-			compass.base.transform.scale.set(0.4, 0.4, 0.4);
-			compass.base.transform.buildMatrix();
+			compass.base.transform.loc = Vec4.create(7.4 * ratio, 7.0, -1);
+			compass.base.transform.rot = Quat.create(-crot.x, -crot.y, -crot.z, crot.w);
+			Vec4.set(compass.base.transform.scale, 0.4, 0.4, 0.4);
+			Transform.buildMatrix(compass.base.transform);
 			compass.frustumCulling = false;
-			compass.render(currentG, "overlay", []);
+			MeshObject.render(compass, currentG, "overlay", []);
 
 			cam.P = _P;
 			compass.base.visible = _visible;
 			compass.base.parent = _parent;
 			compass.base.transform.loc = _loc;
 			compass.base.transform.rot = _rot;
-			compass.base.transform.buildMatrix();
+			Transform.buildMatrix(compass.base.transform);
 		}
 	}
 
@@ -101,7 +101,7 @@ class RenderPathBase {
 			let cam = Scene.camera;
 			if (Context.raw.viewIndexLast > -1) {
 				// Save current viewport camera
-				Camera.views[Context.raw.viewIndexLast].setFrom(cam.base.transform.local);
+				Mat4.setFrom(Camera.views[Context.raw.viewIndexLast], cam.base.transform.local);
 			}
 
 			let decal = Context.raw.tool == WorkspaceTool.ToolDecal || Context.raw.tool == WorkspaceTool.ToolText;
@@ -111,16 +111,16 @@ class RenderPathBase {
 				Context.raw.ddirty = 1;
 			}
 
-			cam.base.transform.setMatrix(Camera.views[Context.raw.viewIndex]);
-			cam.buildMatrix();
-			cam.buildProjection();
+			Transform.setMatrix(cam.base.transform, Camera.views[Context.raw.viewIndex]);
+			CameraObject.buildMatrix(cam);
+			CameraObject.buildProjection(cam);
 		}
 
 		// Match projection matrix jitter
 		let skipTaa = Context.raw.splitView || ((Context.raw.tool == WorkspaceTool.ToolClone || Context.raw.tool == WorkspaceTool.ToolBlur || Context.raw.tool == WorkspaceTool.ToolSmudge) && Context.raw.pdirty > 0);
 		Scene.camera.frame = skipTaa ? 0 : RenderPathBase.taaFrame;
-		Scene.camera.projectionJitter();
-		Scene.camera.buildMatrix();
+		CameraObject.projectionJitter(Scene.camera);
+		CameraObject.buildMatrix(Scene.camera);
 	}
 
 	static end = () => {
@@ -253,9 +253,9 @@ class RenderPathBase {
 			let cam = Scene.camera;
 
 			Context.raw.viewIndex = Context.raw.viewIndex == 0 ? 1 : 0;
-			cam.base.transform.setMatrix(Camera.views[Context.raw.viewIndex]);
-			cam.buildMatrix();
-			cam.buildProjection();
+			Transform.setMatrix(cam.base.transform, Camera.views[Context.raw.viewIndex]);
+			CameraObject.buildMatrix(cam);
+			CameraObject.buildProjection(cam);
 
 			RenderPathBase.drawGbuffer();
 
@@ -271,9 +271,9 @@ class RenderPathBase {
 			///end
 
 			Context.raw.viewIndex = Context.raw.viewIndex == 0 ? 1 : 0;
-			cam.base.transform.setMatrix(Camera.views[Context.raw.viewIndex]);
-			cam.buildMatrix();
-			cam.buildProjection();
+			Transform.setMatrix(cam.base.transform, Camera.views[Context.raw.viewIndex]);
+			CameraObject.buildMatrix(cam);
+			CameraObject.buildProjection(cam);
 		}
 	}
 

base/Sources/RenderPathRaytrace.ts

@@ -79,12 +79,12 @@ class RenderPathRaytrace {
 
 		let cam = Scene.camera;
 		let ct = cam.base.transform;
-		RenderPathRaytrace.helpMat.setFrom(cam.V);
-		RenderPathRaytrace.helpMat.multmat(cam.P);
-		RenderPathRaytrace.helpMat.getInverse(RenderPathRaytrace.helpMat);
-		RenderPathRaytrace.f32a[0] = ct.worldx();
-		RenderPathRaytrace.f32a[1] = ct.worldy();
-		RenderPathRaytrace.f32a[2] = ct.worldz();
+		Mat4.setFrom(RenderPathRaytrace.helpMat, cam.V);
+		Mat4.multmat(RenderPathRaytrace.helpMat, cam.P);
+		Mat4.getInverse(RenderPathRaytrace.helpMat, RenderPathRaytrace.helpMat);
+		RenderPathRaytrace.f32a[0] = Transform.worldx(ct);
+		RenderPathRaytrace.f32a[1] = Transform.worldy(ct);
+		RenderPathRaytrace.f32a[2] = Transform.worldz(ct);
 		RenderPathRaytrace.f32a[3] = RenderPathRaytrace.frame;
 		///if krom_metal
 		// frame = (frame % (16)) + 1; // _PAINT

base/Sources/TabMeshes.ts

@@ -116,17 +116,17 @@ class TabMeshes {
 							array_remove(Project.paintObjects, o);
 							while (o.base.children.length > 0) {
 								let child = o.base.children[0];
-								child.setParent(null);
+								BaseObject.setParent(child, null);
 								if (Project.paintObjects[0].base != child) {
-									child.setParent(Project.paintObjects[0].base);
+									BaseObject.setParent(child, Project.paintObjects[0].base);
 								}
 								if (o.base.children.length == 0) {
-									Project.paintObjects[0].base.transform.scale.setFrom(o.base.transform.scale);
-									Project.paintObjects[0].base.transform.buildMatrix();
+									Vec4.setFrom(Project.paintObjects[0].base.transform.scale, o.base.transform.scale);
+									Transform.buildMatrix(Project.paintObjects[0].base.transform);
 								}
 							}
 							Data.deleteMesh(o.data._handle);
-							o.remove();
+							MeshObject.remove(o);
 							Context.raw.paintObject = Context.mainObject();
 							UtilMesh.mergeMesh();
 							Context.raw.ddirty = 2;
@@ -134,7 +134,7 @@ class TabMeshes {
 					}, Project.paintObjects.length > 1 ? 2 : 1);
 				}
 				if (h.changed) {
-					let visibles: MeshObject[] = [];
+					let visibles: TMeshObject[] = [];
 					for (let p of Project.paintObjects) if (p.base.visible) visibles.push(p);
 					UtilMesh.mergeMesh(visibles);
 					Context.raw.ddirty = 2;
@@ -145,7 +145,7 @@ class TabMeshes {
 
 	///if is_lab
 	static setDefaultMesh = (name: string) => {
-		let mo: MeshObject = null;
+		let mo: TMeshObject = null;
 		if (name == ".Plane" || name == ".Sphere") {
 			let res = Config.raw.rp_supersample > 1.0 ? 2048 : 1024;
 			let mesh: any = name == ".Plane" ? Geom.make_plane(1, 1, res, res) : Geom.make_uv_sphere(1.0, res, Math.floor(res / 2), false, 2.0);
@@ -164,7 +164,7 @@ class TabMeshes {
 			};
 			let md: TMeshData;
 			MeshData.create(raw, (_md: TMeshData) => { md = _md; });
-			mo = new MeshObject(md, Context.raw.paintObject.materials);
+			mo = MeshObject.create(md, Context.raw.paintObject.materials);
 			array_remove(Scene.meshes, mo);
 			mo.base.name = "Tessellated";
 		}

base/Sources/UIBase.ts

@@ -219,15 +219,15 @@ class UIBase {
 
 		///if (is_paint || is_sculpt)
 		Context.raw.gizmo = Scene.getChild(".Gizmo");
-		Context.raw.gizmoTranslateX = Context.raw.gizmo.getChild(".TranslateX");
-		Context.raw.gizmoTranslateY = Context.raw.gizmo.getChild(".TranslateY");
-		Context.raw.gizmoTranslateZ = Context.raw.gizmo.getChild(".TranslateZ");
-		Context.raw.gizmoScaleX = Context.raw.gizmo.getChild(".ScaleX");
-		Context.raw.gizmoScaleY = Context.raw.gizmo.getChild(".ScaleY");
-		Context.raw.gizmoScaleZ = Context.raw.gizmo.getChild(".ScaleZ");
-		Context.raw.gizmoRotateX = Context.raw.gizmo.getChild(".RotateX");
-		Context.raw.gizmoRotateY = Context.raw.gizmo.getChild(".RotateY");
-		Context.raw.gizmoRotateZ = Context.raw.gizmo.getChild(".RotateZ");
+		Context.raw.gizmoTranslateX = BaseObject.getChild(Context.raw.gizmo, ".TranslateX");
+		Context.raw.gizmoTranslateY = BaseObject.getChild(Context.raw.gizmo, ".TranslateY");
+		Context.raw.gizmoTranslateZ = BaseObject.getChild(Context.raw.gizmo, ".TranslateZ");
+		Context.raw.gizmoScaleX = BaseObject.getChild(Context.raw.gizmo, ".ScaleX");
+		Context.raw.gizmoScaleY = BaseObject.getChild(Context.raw.gizmo, ".ScaleY");
+		Context.raw.gizmoScaleZ = BaseObject.getChild(Context.raw.gizmo, ".ScaleZ");
+		Context.raw.gizmoRotateX = BaseObject.getChild(Context.raw.gizmo, ".RotateX");
+		Context.raw.gizmoRotateY = BaseObject.getChild(Context.raw.gizmo, ".RotateY");
+		Context.raw.gizmoRotateZ = BaseObject.getChild(Context.raw.gizmo, ".RotateZ");
 		///end
 
 		Res.load(resources, () => {});
@@ -710,18 +710,18 @@ class UIBase {
 				}
 				History.pushUndo = true;
 				Context.raw.particleHitX = Context.raw.particleHitY = Context.raw.particleHitZ = 0;
-				Scene.spawnObject(".Sphere", null, (o: BaseObject) => {
+				Scene.spawnObject(".Sphere", null, (o: TBaseObject) => {
 					Data.getMaterial("Scene", ".Gizmo", (md: TMaterialData) => {
-						let mo: MeshObject = o.ext;
+						let mo: TMeshObject = o.ext;
 						mo.base.name = ".Bullet";
 						mo.materials[0] = md;
 						mo.base.visible = true;
 
 						let camera = Scene.camera;
 						let ct = camera.base.transform;
-						mo.base.transform.loc.set(ct.worldx(), ct.worldy(), ct.worldz());
-						mo.base.transform.scale.set(Context.raw.brushRadius * 0.2, Context.raw.brushRadius * 0.2, Context.raw.brushRadius * 0.2);
-						mo.base.transform.buildMatrix();
+						Vec4.set(mo.base.transform.loc, Transform.worldx(ct), Transform.worldy(ct), Transform.worldz(ct));
+						Vec4.set(mo.base.transform.scale, Context.raw.brushRadius * 0.2, Context.raw.brushRadius * 0.2, Context.raw.brushRadius * 0.2);
+						Transform.buildMatrix(mo.base.transform);
 
 						let body = PhysicsBody.create();
 						body.shape = ShapeType.ShapeSphere;
@@ -733,9 +733,9 @@ class UIBase {
 						mo.base.transform.radius *= 10;
 
 						let ray = RayCaster.getRay(Mouse.viewX, Mouse.viewY, camera);
-						PhysicsBody.applyImpulse(body, ray.direction.mult(0.15));
+						PhysicsBody.applyImpulse(body, Vec4.mult(ray.direction, 0.15));
 
-						Context.raw.particleTimer = Tween.timer(5, mo.remove);
+						Context.raw.particleTimer = Tween.timer(5, function() { MeshObject.remove(mo); });
 					});
 				});
 			}
@@ -1019,7 +1019,7 @@ class UIBase {
 						else if (Context.raw.tool == WorkspaceTool.ToolParticle) {
 							// Reset particles
 							///if arm_particles
-							let emitter: MeshObject = Scene.getChild(".ParticleEmitter").ext;
+							let emitter: TMeshObject = Scene.getChild(".ParticleEmitter").ext;
 							let psys = emitter.particleSystems[0];
 							psys.time = 0;
 							// psys.time = psys.seed * psys.animtime;
@@ -1280,7 +1280,7 @@ class UIBase {
 				let angle = Context.raw.brushStencilAngle;
 				let cx = r.x + r.w / 2;
 				let cy = r.y + r.h / 2;
-				g.transformation = Mat3.translation(cx, cy).multmat(Mat3.rotation(-angle)).multmat(Mat3.translation(-cx, -cy));
+				g.transformation = mat3_multmat(mat3_multmat(mat3_translation(cx, cy), mat3_rotation(-angle)), mat3_translation(-cx, -cy));
 				g.drawScaledImage(Context.raw.brushStencilImage, r.x, r.y, r.w, r.h);
 				g.transformation = null;
 				g.color = 0xffffffff;
@@ -1298,7 +1298,7 @@ class UIBase {
 				let angle = Context.raw.brushStencilAngle;
 				let cx = r.x + r.w / 2;
 				let cy = r.y + r.h / 2;
-				g.transformation = Mat3.translation(cx, cy).multmat(Mat3.rotation(-angle)).multmat(Mat3.translation(-cx, -cy));
+				g.transformation = mat3_multmat(mat3_multmat(mat3_translation(cx, cy), mat3_rotation(-angle)), mat3_translation(-cx, -cy));
 				g.fillCircle(r.x + r.w / 2, r.y - 4, 8);
 				g.transformation = null;
 			}
@@ -1361,7 +1361,7 @@ class UIBase {
 					let angle = (Context.raw.brushAngle + Context.raw.brushNodesAngle) * (Math.PI / 180);
 					let cx = decalX + psizex / 2;
 					let cy = decalY + psizey / 2;
-					g.transformation = Mat3.translation(cx, cy).multmat(Mat3.rotation(angle)).multmat(Mat3.translation(-cx, -cy));
+					g.transformation = mat3_multmat(mat3_multmat(mat3_translation(cx, cy), mat3_rotation(angle)), mat3_translation(-cx, -cy));
 					///if (krom_direct3d11 || krom_direct3d12 || krom_metal || krom_vulkan)
 					g.drawScaledImage(Context.raw.decalImage, decalX, decalY, psizex, psizey);
 					///else

base/Sources/UIMenu.ts

@@ -166,8 +166,8 @@ class UIMenu {
 						else if (newAngle > 2 * Math.PI) newAngle -= Math.floor(newAngle / (2 * Math.PI)) * 2 * Math.PI;
 						Context.raw.lightAngle = newAngle;
 						let m = Mat4.rotationZ(ldiff);
-						light.base.transform.local.multmat(m);
-						light.base.transform.decompose();
+						Mat4.multmat(light.base.transform.local, m);
+						Transform.decompose(light.base.transform);
 						Context.raw.ddirty = 2;
 					}
 

base/Sources/UIMenubar.ts

@@ -7,8 +7,8 @@ class UIMenubar {
 	static menubarw = UIMenubar.defaultMenubarW;
 
 	///if is_lab
-	static _savedCamera: Mat4 = null;
-	static _plane: MeshObject = null;
+	static _savedCamera: TMat4 = null;
+	static _plane: TMeshObject = null;
 	///end
 
 	constructor() {
@@ -115,7 +115,7 @@ class UIMenubar {
 
 				if (UIHeader.worktab.position == SpaceType.Space3D) {
 					if (UIMenubar._savedCamera != null) {
-						Scene.camera.base.transform.setMatrix(UIMenubar._savedCamera);
+						Transform.setMatrix(Scene.camera.base.transform, UIMenubar._savedCamera);
 						UIMenubar._savedCamera = null;
 					}
 					Scene.meshes = [Context.mainObject()];
@@ -138,18 +138,18 @@ class UIMenubar {
 						};
 						let md: TMeshData;
 						MeshData.create(raw, (_md: TMeshData) => { md = _md; });
-						let dotPlane: MeshObject = Scene.getChild(".Plane").ext;
-						UIMenubar._plane = new MeshObject(md, dotPlane.materials);
+						let dotPlane: TMeshObject = Scene.getChild(".Plane").ext;
+						UIMenubar._plane = MeshObject.create(md, dotPlane.materials);
 						array_remove(Scene.meshes, UIMenubar._plane);
 					}
 
 					if (UIMenubar._savedCamera == null) {
-						UIMenubar._savedCamera = Scene.camera.base.transform.local.clone();
+						UIMenubar._savedCamera = Mat4.clone(Scene.camera.base.transform.local);
 					}
 					Scene.meshes = [UIMenubar._plane];
 					let m = Mat4.identity();
-					m.translate(0, 0, 1.6);
-					Scene.camera.base.transform.setMatrix(m);
+					Mat4.translate(m, 0, 0, 1.6);
+					Transform.setMatrix(Scene.camera.base.transform, m);
 				}
 				///if (krom_direct3d12 || krom_vulkan || krom_metal)
 				RenderPathRaytrace.ready = false;

base/Sources/UniformsExt.ts

@@ -1,7 +1,7 @@
 
 class UniformsExt {
 
-	static vec = new Vec4();
+	static vec = Vec4.create();
 	static orthoP = Mat4.ortho(-0.5, 0.5, -0.5, 0.5, -0.5, 0.5);
 
 	static init = () => {
@@ -14,11 +14,11 @@ class UniformsExt {
 		Uniforms.externalTextureLinks = [UniformsExt.linkTex];
 	}
 
-	static linkInt = (object: BaseObject, mat: TMaterialData, link: string): Null<i32> => {
+	static linkInt = (object: TBaseObject, mat: TMaterialData, link: string): Null<i32> => {
 		return null;
 	}
 
-	static linkFloat = (object: BaseObject, mat: TMaterialData, link: string): Null<f32> => {
+	static linkFloat = (object: TBaseObject, mat: TMaterialData, link: string): Null<f32> => {
 		switch (link) {
 			case "_brushRadius": {
 				///if (is_paint || is_sculpt)
@@ -110,7 +110,7 @@ class UniformsExt {
 			}
 			///end
 			case "_decalLayerDim": {
-				return Context.raw.layer.decalMat.getScale().z * 0.5;
+				return Mat4.getScale(Context.raw.layer.decalMat).z * 0.5;
 			}
 			case "_pickerOpacity": {
 				return Context.raw.pickedColor.opacity;
@@ -148,20 +148,20 @@ class UniformsExt {
 		return null;
 	}
 
-	static linkVec2 = (object: BaseObject, mat: TMaterialData, link: string): Vec4 => {
+	static linkVec2 = (object: TBaseObject, mat: TMaterialData, link: string): TVec4 => {
 		switch (link) {
 			case "_gbufferSize": {
-				UniformsExt.vec.set(0, 0, 0);
+				Vec4.set(UniformsExt.vec, 0, 0, 0);
 				let gbuffer2 = RenderPath.renderTargets.get("gbuffer2");
-				UniformsExt.vec.set(gbuffer2.image.width, gbuffer2.image.height, 0);
+				Vec4.set(UniformsExt.vec, gbuffer2.image.width, gbuffer2.image.height, 0);
 				return UniformsExt.vec;
 			}
 			case "_cloneDelta": {
-				UniformsExt.vec.set(Context.raw.cloneDeltaX, Context.raw.cloneDeltaY, 0);
+				Vec4.set(UniformsExt.vec, Context.raw.cloneDeltaX, Context.raw.cloneDeltaY, 0);
 				return UniformsExt.vec;
 			}
 			case "_texpaintSize": {
-				UniformsExt.vec.set(Config.getTextureResX(), Config.getTextureResY(), 0);
+				Vec4.set(UniformsExt.vec, Config.getTextureResX(), Config.getTextureResY(), 0);
 				return UniformsExt.vec;
 			}
 			///if (is_paint || is_sculpt)
@@ -172,7 +172,7 @@ class UniformsExt {
 				if (Config.raw.pressure_angle && Pen.down()) {
 					angle *= Pen.pressure * Config.raw.pressure_sensitivity;
 				}
-				UniformsExt.vec.set(Math.cos(-angle), Math.sin(-angle), 0);
+				Vec4.set(UniformsExt.vec, Math.cos(-angle), Math.sin(-angle), 0);
 				return UniformsExt.vec;
 			}
 			///end
@@ -180,8 +180,8 @@ class UniformsExt {
 		return null;
 	}
 
-	static linkVec3 = (object: BaseObject, mat: TMaterialData, link: string): Vec4 => {
-		let v: Vec4 = null;
+	static linkVec3 = (object: TBaseObject, mat: TMaterialData, link: string): TVec4 => {
+		let v: TVec4 = null;
 		switch (link) {
 			///if (is_paint || is_sculpt)
 			case "_brushDirection": {
@@ -200,24 +200,24 @@ class UniformsExt {
 					lastx = UniformsExt.vec2d(lastx);
 				}
 				let angle = Math.atan2(-y + lasty, x - lastx) - Math.PI / 2;
-				v.set(Math.cos(angle), Math.sin(angle), allowPaint ? 1 : 0);
+				Vec4.set(v, Math.cos(angle), Math.sin(angle), allowPaint ? 1 : 0);
 				Context.raw.prevPaintVecX = Context.raw.lastPaintVecX;
 				Context.raw.prevPaintVecY = Context.raw.lastPaintVecY;
 				return v;
 			}
 			case "_decalLayerLoc": {
 				v = Uniforms.helpVec;
-				v.set(Context.raw.layer.decalMat._30, Context.raw.layer.decalMat._31, Context.raw.layer.decalMat._32);
+				Vec4.set(v, Context.raw.layer.decalMat._30, Context.raw.layer.decalMat._31, Context.raw.layer.decalMat._32);
 				return v;
 			}
 			case "_decalLayerNor": {
 				v = Uniforms.helpVec;
-				v.set(Context.raw.layer.decalMat._20, Context.raw.layer.decalMat._21, Context.raw.layer.decalMat._22).normalize();
+				Vec4.normalize(Vec4.set(v, Context.raw.layer.decalMat._20, Context.raw.layer.decalMat._21, Context.raw.layer.decalMat._22));
 				return v;
 			}
 			case "_pickerBase": {
 				v = Uniforms.helpVec;
-				v.set(
+				Vec4.set(v,
 					color_get_rb(Context.raw.pickedColor.base) / 255,
 					color_get_gb(Context.raw.pickedColor.base) / 255,
 					color_get_bb(Context.raw.pickedColor.base) / 255
@@ -226,7 +226,7 @@ class UniformsExt {
 			}
 			case "_pickerNormal": {
 				v = Uniforms.helpVec;
-				v.set(
+				Vec4.set(v,
 					color_get_rb(Context.raw.pickedColor.normal) / 255,
 					color_get_gb(Context.raw.pickedColor.normal) / 255,
 					color_get_bb(Context.raw.pickedColor.normal) / 255
@@ -236,12 +236,12 @@ class UniformsExt {
 			///if arm_physics
 			case "_particleHit": {
 				v = Uniforms.helpVec;
-				v.set(Context.raw.particleHitX, Context.raw.particleHitY, Context.raw.particleHitZ);
+				Vec4.set(v, Context.raw.particleHitX, Context.raw.particleHitY, Context.raw.particleHitZ);
 				return v;
 			}
 			case "_particleHitLast": {
 				v = Uniforms.helpVec;
-				v.set(Context.raw.lastParticleHitX, Context.raw.lastParticleHitY, Context.raw.lastParticleHitZ);
+				Vec4.set(v, Context.raw.lastParticleHitX, Context.raw.lastParticleHitY, Context.raw.lastParticleHitZ);
 				return v;
 			}
 			///end
@@ -261,11 +261,11 @@ class UniformsExt {
 	}
 	///end
 
-	static linkVec4 = (object: BaseObject, mat: TMaterialData, link: string): Vec4 => {
+	static linkVec4 = (object: TBaseObject, mat: TMaterialData, link: string): TVec4 => {
 		switch (link) {
 			case "_inputBrush": {
 				let down = Mouse.down() || Pen.down();
-				UniformsExt.vec.set(Context.raw.paintVec.x, Context.raw.paintVec.y, down ? 1.0 : 0.0, 0.0);
+				Vec4.set(UniformsExt.vec, Context.raw.paintVec.x, Context.raw.paintVec.y, down ? 1.0 : 0.0, 0.0);
 
 				///if (is_paint || is_sculpt)
 				if (Context.raw.paint2d) {
@@ -277,7 +277,7 @@ class UniformsExt {
 			}
 			case "_inputBrushLast": {
 				let down = Mouse.down() || Pen.down();
-				UniformsExt.vec.set(Context.raw.lastPaintVecX, Context.raw.lastPaintVecY, down ? 1.0 : 0.0, 0.0);
+				Vec4.set(UniformsExt.vec, Context.raw.lastPaintVecX, Context.raw.lastPaintVecY, down ? 1.0 : 0.0, 0.0);
 
 				///if (is_paint || is_sculpt)
 				if (Context.raw.paint2d) {
@@ -288,16 +288,16 @@ class UniformsExt {
 				return UniformsExt.vec;
 			}
 			case "_envmapData": {
-				UniformsExt.vec.set(Context.raw.envmapAngle, Math.sin(-Context.raw.envmapAngle), Math.cos(-Context.raw.envmapAngle), Scene.world.strength);
+				Vec4.set(UniformsExt.vec, Context.raw.envmapAngle, Math.sin(-Context.raw.envmapAngle), Math.cos(-Context.raw.envmapAngle), Scene.world.strength);
 				return UniformsExt.vec;
 			}
 			case "_envmapDataWorld": {
-				UniformsExt.vec.set(Context.raw.envmapAngle, Math.sin(-Context.raw.envmapAngle), Math.cos(-Context.raw.envmapAngle), Context.raw.showEnvmap ? Scene.world.strength : 1.0);
+				Vec4.set(UniformsExt.vec, Context.raw.envmapAngle, Math.sin(-Context.raw.envmapAngle), Math.cos(-Context.raw.envmapAngle), Context.raw.showEnvmap ? Scene.world.strength : 1.0);
 				return UniformsExt.vec;
 			}
 			///if (is_paint || is_sculpt)
 			case "_stencilTransform": {
-				UniformsExt.vec.set(Context.raw.brushStencilX, Context.raw.brushStencilY, Context.raw.brushStencilScale, Context.raw.brushStencilAngle);
+				Vec4.set(UniformsExt.vec, Context.raw.brushStencilX, Context.raw.brushStencilY, Context.raw.brushStencilScale, Context.raw.brushStencilAngle);
 				if (Context.raw.paint2d) UniformsExt.vec.x = UniformsExt.vec2d(UniformsExt.vec.x);
 				return UniformsExt.vec;
 			}
@@ -307,7 +307,7 @@ class UniformsExt {
 				let val = (Context.raw.brushRadius * Context.raw.brushNodesRadius) / 15.0;
 				let scale2d = (900 / Base.h()) * Config.raw.window_scale;
 				val *= scale2d; // Projection ratio
-				UniformsExt.vec.set(Context.raw.decalX, Context.raw.decalY, decalMask ? 1 : 0, val);
+				Vec4.set(UniformsExt.vec, Context.raw.decalX, Context.raw.decalY, decalMask ? 1 : 0, val);
 				if (Context.raw.paint2d) UniformsExt.vec.x = UniformsExt.vec2d(UniformsExt.vec.x);
 				return UniformsExt.vec;
 			}
@@ -316,15 +316,15 @@ class UniformsExt {
 		return null;
 	}
 
-	static linkMat4 = (object: BaseObject, mat: TMaterialData, link: string): Mat4 => {
+	static linkMat4 = (object: TBaseObject, mat: TMaterialData, link: string): TMat4 => {
 		switch (link) {
 			///if (is_paint || is_sculpt)
 			case "_decalLayerMatrix": { // Decal layer
 				let camera = Scene.camera;
 				let m = Uniforms.helpMat;
-				m.setFrom(Context.raw.layer.decalMat);
-				m.getInverse(m);
-				m.multmat(UniformsExt.orthoP);
+				Mat4.setFrom(m, Context.raw.layer.decalMat);
+				Mat4.getInverse(m, m);
+				Mat4.multmat(m, UniformsExt.orthoP);
 				return m;
 			}
 			///end
@@ -332,7 +332,7 @@ class UniformsExt {
 		return null;
 	}
 
-	static linkTex = (object: BaseObject, mat: TMaterialData, link: string): Image => {
+	static linkTex = (object: TBaseObject, mat: TMaterialData, link: string): Image => {
 		switch (link) {
 			case "_texpaint_undo": {
 				///if (is_paint || is_sculpt)

base/Sources/UtilMesh.ts

@@ -3,7 +3,7 @@ class UtilMesh {
 
 	static unwrappers: Map<string, ((a: any)=>void)> = new Map();
 
-	static mergeMesh = (paintObjects: MeshObject[] = null) => {
+	static mergeMesh = (paintObjects: TMeshObject[] = null) => {
 		if (paintObjects == null) paintObjects = Project.paintObjects;
 		if (paintObjects.length == 0) return;
 		Context.raw.mergedObjectIsAtlas = paintObjects.length < Project.paintObjects.length;
@@ -35,9 +35,9 @@ class UtilMesh {
 			// Translate
 			///if is_forge
 			for (let j = 0; j < Math.floor(va0.length / 4); ++j) {
-				va0[j * 4     + voff * 4] += Math.floor(paintObjects[i].base.transform.worldx() * 32767);
-				va0[j * 4 + 1 + voff * 4] += Math.floor(paintObjects[i].base.transform.worldy() * 32767);
-				va0[j * 4 + 2 + voff * 4] += Math.floor(paintObjects[i].base.transform.worldz() * 32767);
+				va0[j * 4     + voff * 4] += Math.floor(Transform.worldx(paintObjects[i].base.transform) * 32767);
+				va0[j * 4 + 1 + voff * 4] += Math.floor(Transform.worldy(paintObjects[i].base.transform) * 32767);
+				va0[j * 4 + 2 + voff * 4] += Math.floor(Transform.worldz(paintObjects[i].base.transform) * 32767);
 			}
 			///end
 
@@ -77,10 +77,10 @@ class UtilMesh {
 
 		UtilMesh.removeMergedMesh();
 		MeshData.create(raw, (md: TMeshData) => {
-			Context.raw.mergedObject = new MeshObject(md, Context.raw.paintObject.materials);
+			Context.raw.mergedObject = MeshObject.create(md, Context.raw.paintObject.materials);
 			Context.raw.mergedObject.base.name = Context.raw.paintObject.base.name + "_merged";
 			Context.raw.mergedObject.force_context = "paint";
-			Context.raw.mergedObject.base.setParent(Context.mainObject().base);
+			BaseObject.setParent(Context.raw.mergedObject.base, Context.mainObject().base);
 		});
 
 		///if (krom_direct3d12 || krom_vulkan || krom_metal)
@@ -91,7 +91,7 @@ class UtilMesh {
 	static removeMergedMesh = () => {
 		if (Context.raw.mergedObject != null) {
 			MeshData.delete(Context.raw.mergedObject.data);
-			Context.raw.mergedObject.remove();
+			MeshObject.remove(Context.raw.mergedObject);
 			Context.raw.mergedObject = null;
 		}
 	}
@@ -163,11 +163,11 @@ class UtilMesh {
 	}
 
 	static calcNormals = (smooth = false) => {
-		let va = new Vec4();
-		let vb = new Vec4();
-		let vc = new Vec4();
-		let cb = new Vec4();
-		let ab = new Vec4();
+		let va = Vec4.create();
+		let vb = Vec4.create();
+		let vc = Vec4.create();
+		let cb = Vec4.create();
+		let ab = Vec4.create();
 		let objects = Project.paintObjects;
 		for (let o of objects) {
 			let g = o.data;
@@ -178,13 +178,13 @@ class UtilMesh {
 				let i1 = inda[i * 3    ];
 				let i2 = inda[i * 3 + 1];
 				let i3 = inda[i * 3 + 2];
-				va.set(vertices.getInt16((i1 * l) * 2, true), vertices.getInt16((i1 * l + 1) * 2, true), vertices.getInt16((i1 * l + 2) * 2, true));
-				vb.set(vertices.getInt16((i2 * l) * 2, true), vertices.getInt16((i2 * l + 1) * 2, true), vertices.getInt16((i2 * l + 2) * 2, true));
-				vc.set(vertices.getInt16((i3 * l) * 2, true), vertices.getInt16((i3 * l + 1) * 2, true), vertices.getInt16((i3 * l + 2) * 2, true));
-				cb.subvecs(vc, vb);
-				ab.subvecs(va, vb);
-				cb.cross(ab);
-				cb.normalize();
+				Vec4.set(va, vertices.getInt16((i1 * l) * 2, true), vertices.getInt16((i1 * l + 1) * 2, true), vertices.getInt16((i1 * l + 2) * 2, true));
+				Vec4.set(vb, vertices.getInt16((i2 * l) * 2, true), vertices.getInt16((i2 * l + 1) * 2, true), vertices.getInt16((i2 * l + 2) * 2, true));
+				Vec4.set(vc, vertices.getInt16((i3 * l) * 2, true), vertices.getInt16((i3 * l + 1) * 2, true), vertices.getInt16((i3 * l + 2) * 2, true));
+				Vec4.subvecs(cb, vc, vb);
+				Vec4.subvecs(ab, va, vb);
+				Vec4.cross(cb, ab);
+				Vec4.normalize(cb, );
 				vertices.setInt16((i1 * l + 4) * 2, Math.floor(cb.x * 32767), true);
 				vertices.setInt16((i1 * l + 5) * 2, Math.floor(cb.y * 32767), true);
 				vertices.setInt16((i1 * l + 3) * 2, Math.floor(cb.z * 32767), true);
@@ -219,14 +219,14 @@ class UtilMesh {
 						}
 					}
 					if (sharedLen > 1) {
-						va.set(0, 0, 0);
+						Vec4.set(va, 0, 0, 0);
 						for (let j = 0; j < sharedLen; ++j) {
 							let i1 = shared[j];
 							let i1l = i1 * l;
-							va.addf(vertices.getInt16((i1l + 4) * 2, true), vertices.getInt16((i1l + 5) * 2, true), vertices.getInt16((i1l + 3) * 2, true));
+							Vec4.addf(va, vertices.getInt16((i1l + 4) * 2, true), vertices.getInt16((i1l + 5) * 2, true), vertices.getInt16((i1l + 3) * 2, true));
 						}
-						va.mult(1 / sharedLen);
-						va.normalize();
+						Vec4.mult(va, 1 / sharedLen);
+						Vec4.normalize(va, );
 						let vax = Math.floor(va.x * 32767);
 						let vay = Math.floor(va.y * 32767);
 						let vaz = Math.floor(va.z * 32767);
@@ -298,7 +298,7 @@ class UtilMesh {
 				if (Math.abs(va[i * 4 + 2] * sc - dz) > maxScale) maxScale = Math.abs(va[i * 4 + 2] * sc - dz);
 			}
 			o.base.transform.scaleWorld = o.data.scale_pos = o.data.scale_pos = maxScale;
-			o.base.transform.buildMatrix();
+			Transform.buildMatrix(o.base.transform);
 
 			for (let i = 0; i < Math.floor(va.length / 4); ++i) {
 				va[i * 4    ] = Math.floor((va[i * 4    ] * sc - dx) / maxScale * 32767);
@@ -350,9 +350,9 @@ class UtilMesh {
 	static equirectUnwrap = (mesh: any) => {
 		let verts = Math.floor(mesh.posa.length / 4);
 		mesh.texa = new Int16Array(verts * 2);
-		let n = new Vec4();
+		let n = Vec4.create();
 		for (let i = 0; i < verts; ++i) {
-			n.set(mesh.posa[i * 4] / 32767, mesh.posa[i * 4 + 1] / 32767, mesh.posa[i * 4 + 2] / 32767).normalize();
+			Vec4.normalize(Vec4.set(n, mesh.posa[i * 4] / 32767, mesh.posa[i * 4 + 1] / 32767, mesh.posa[i * 4 + 2] / 32767));
 			// Sphere projection
 			// mesh.texa[i * 2    ] = Math.atan2(n.x, n.y) / (Math.PI * 2) + 0.5;
 			// mesh.texa[i * 2 + 1] = n.z * 0.5 + 0.5;
@@ -371,11 +371,11 @@ class UtilMesh {
 		return c;
 	}
 
-	static calcNormal = (p0: Vec4, p1: Vec4, p2: Vec4): Vec4 => {
-		let cb = new Vec4().subvecs(p2, p1);
-		let ab = new Vec4().subvecs(p0, p1);
-		cb.cross(ab);
-		cb.normalize();
+	static calcNormal = (p0: TVec4, p1: TVec4, p2: TVec4): TVec4 => {
+		let cb = Vec4.subvecs(Vec4.create(), p2, p1);
+		let ab = Vec4.subvecs(Vec4.create(), p0, p1);
+		Vec4.cross(cb, ab);
+		Vec4.normalize(cb);
 		return cb;
 	}
 }

base/Sources/UtilParticle.ts

@@ -68,13 +68,13 @@ class UtilParticle {
 				}
 			}
 
-			Scene.spawnObject(".Sphere", null, (o: BaseObject) => {
-				let mo: MeshObject = o.ext;
+			Scene.spawnObject(".Sphere", null, (o: TBaseObject) => {
+				let mo: TMeshObject = o.ext;
 				mo.base.name = ".ParticleEmitter";
 				mo.base.raw = JSON.parse(JSON.stringify(mo.base.raw));
 				mo.base.raw.particle_refs = particle_refs;
 				///if arm_particles
-				mo.setupParticleSystem("Scene", particle_refs[0]);
+				MeshObject.setupParticleSystem(mo, "Scene", particle_refs[0]);
 				///end
 			});
 		});

base/Sources/UtilRender.ts

@@ -12,7 +12,7 @@ class UtilRender {
 	static makeMaterialPreview = () => {
 		Context.raw.materialPreview = true;
 
-		let sphere: MeshObject = Scene.getChild(".Sphere").ext;
+		let sphere: TMeshObject = Scene.getChild(".Sphere").ext;
 		sphere.base.visible = true;
 		let meshes = Scene.meshes;
 		Scene.meshes = [sphere];
@@ -22,9 +22,9 @@ class UtilRender {
 		sphere.materials[0] = Project.materials[0].data;
 		Context.raw.material.previewReady = true;
 
-		Context.raw.savedCamera.setFrom(Scene.camera.base.transform.local);
-		let m = new Mat4(0.9146286343879498, -0.0032648027153306235, 0.404281837254303, 0.4659988049397712, 0.404295023959927, 0.007367569133732468, -0.9145989516155143, -1.0687517188018691, 0.000007410128652369705, 0.9999675337275382, 0.008058532943908717, 0.015935682577325486, 0, 0, 0, 1);
-		Scene.camera.base.transform.setMatrix(m);
+		Mat4.setFrom(Context.raw.savedCamera, Scene.camera.base.transform.local);
+		let m = Mat4.create(0.9146286343879498, -0.0032648027153306235, 0.404281837254303, 0.4659988049397712, 0.404295023959927, 0.007367569133732468, -0.9145989516155143, -1.0687517188018691, 0.000007410128652369705, 0.9999675337275382, 0.008058532943908717, 0.015935682577325486, 0, 0, 0, 1);
+		Transform.setMatrix(Scene.camera.base.transform, m);
 		let savedFov = Scene.camera.data.fov;
 		Scene.camera.data.fov = 0.92;
 		Viewport.updateCameraType(CameraType.CameraPerspective);
@@ -45,8 +45,8 @@ class UtilRender {
 		// No resize
 		RenderPath.lastW = UtilRender.materialPreviewSize;
 		RenderPath.lastH = UtilRender.materialPreviewSize;
-		Scene.camera.buildProjection();
-		Scene.camera.buildMatrix();
+		CameraObject.buildProjection(Scene.camera);
+		CameraObject.buildMatrix(Scene.camera);
 
 		MakeMaterial.parseMeshPreviewMaterial();
 		let _commands = RenderPath.commands;
@@ -63,11 +63,11 @@ class UtilRender {
 		Scene.meshes = meshes;
 		Context.raw.paintObject = painto;
 
-		Scene.camera.base.transform.setMatrix(Context.raw.savedCamera);
+		Transform.setMatrix(Scene.camera.base.transform, Context.raw.savedCamera);
 		Viewport.updateCameraType(Context.raw.cameraType);
 		Scene.camera.data.fov = savedFov;
-		Scene.camera.buildProjection();
-		Scene.camera.buildMatrix();
+		CameraObject.buildProjection(Scene.camera);
+		CameraObject.buildMatrix(Scene.camera);
 		light.data.strength = _lightStrength;
 		probe.strength = _probeStrength;
 		Context.raw.envmapAngle = _envmapAngle;
@@ -87,20 +87,20 @@ class UtilRender {
 		}
 		Context.raw.decalPreview = true;
 
-		let plane: MeshObject = Scene.getChild(".Plane").ext;
-		plane.base.transform.scale.set(1, 1, 1);
-		plane.base.transform.rot.fromEuler(-Math.PI / 2, 0, 0);
-		plane.base.transform.buildMatrix();
+		let plane: TMeshObject = Scene.getChild(".Plane").ext;
+		Vec4.set(plane.base.transform.scale, 1, 1, 1);
+		Quat.fromEuler(plane.base.transform.rot, -Math.PI / 2, 0, 0);
+		Transform.buildMatrix(plane.base.transform);
 		plane.base.visible = true;
 		let meshes = Scene.meshes;
 		Scene.meshes = [plane];
 		let painto = Context.raw.paintObject;
 		Context.raw.paintObject = plane;
 
-		Context.raw.savedCamera.setFrom(Scene.camera.base.transform.local);
+		Mat4.setFrom(Context.raw.savedCamera, Scene.camera.base.transform.local);
 		let m = Mat4.identity();
-		m.translate(0, 0, 1);
-		Scene.camera.base.transform.setMatrix(m);
+		Mat4.translate(m, 0, 0, 1);
+		Transform.setMatrix(Scene.camera.base.transform, m);
 		let savedFov = Scene.camera.data.fov;
 		Scene.camera.data.fov = 0.92;
 		Viewport.updateCameraType(CameraType.CameraPerspective);
@@ -111,8 +111,8 @@ class UtilRender {
 		// No resize
 		RenderPath.lastW = UtilRender.decalPreviewSize;
 		RenderPath.lastH = UtilRender.decalPreviewSize;
-		Scene.camera.buildProjection();
-		Scene.camera.buildMatrix();
+		CameraObject.buildProjection(Scene.camera);
+		CameraObject.buildMatrix(Scene.camera);
 
 		MakeMaterial.parseMeshPreviewMaterial();
 		let _commands = RenderPath.commands;
@@ -129,11 +129,11 @@ class UtilRender {
 		Scene.meshes = meshes;
 		Context.raw.paintObject = painto;
 
-		Scene.camera.base.transform.setMatrix(Context.raw.savedCamera);
+		Transform.setMatrix(Scene.camera.base.transform, Context.raw.savedCamera);
 		Scene.camera.data.fov = savedFov;
 		Viewport.updateCameraType(Context.raw.cameraType);
-		Scene.camera.buildProjection();
-		Scene.camera.buildMatrix();
+		CameraObject.buildProjection(Scene.camera);
+		CameraObject.buildMatrix(Scene.camera);
 		light = Scene.lights[0];
 		light.base.visible = true;
 		Scene.world._envmap = Context.raw.showEnvmap ? Context.raw.savedEnvmap : Context.raw.emptyEnvmap;
@@ -254,27 +254,27 @@ class UtilRender {
 		}
 
 		let cam = Scene.camera;
-		Context.raw.savedCamera.setFrom(cam.base.transform.local);
+		Mat4.setFrom(Context.raw.savedCamera, cam.base.transform.local);
 		let savedFov = cam.data.fov;
 		Viewport.updateCameraType(CameraType.CameraPerspective);
 		let m = Mat4.identity();
-		m.translate(0, 0, 0.5);
-		cam.base.transform.setMatrix(m);
+		Mat4.translate(m, 0, 0, 0.5);
+		Transform.setMatrix(cam.base.transform, m);
 		cam.data.fov = 0.92;
-		cam.buildProjection();
-		cam.buildMatrix();
-		m.getInverse(Scene.camera.VP);
+		CameraObject.buildProjection(cam);
+		CameraObject.buildMatrix(cam);
+		Mat4.getInverse(m, Scene.camera.VP);
 
-		let planeo: MeshObject = Scene.getChild(".Plane").ext;
+		let planeo: TMeshObject = Scene.getChild(".Plane").ext;
 		planeo.base.visible = true;
 		Context.raw.paintObject = planeo;
 
-		let v = new Vec4();
-		let sx = v.set(m._00, m._01, m._02).length();
-		planeo.base.transform.rot.fromEuler(-Math.PI / 2, 0, 0);
-		planeo.base.transform.scale.set(sx, 1.0, sx);
-		planeo.base.transform.loc.set(m._30, -m._31, 0.0);
-		planeo.base.transform.buildMatrix();
+		let v = Vec4.create();
+		let sx = Vec4.vec4_length(Vec4.set(v, m._00, m._01, m._02));
+		Quat.fromEuler(planeo.base.transform.rot, -Math.PI / 2, 0, 0);
+		Vec4.set(planeo.base.transform.scale, sx, 1.0, sx);
+		Vec4.set(planeo.base.transform.loc, m._30, -m._31, 0.0);
+		Transform.buildMatrix(planeo.base.transform);
 
 		RenderPathPaint.liveLayerDrawn = 0;
 		RenderPathBase.drawGbuffer();
@@ -333,11 +333,11 @@ class UtilRender {
 			Context.raw.mergedObject.base.visible = mergedObjectVisible;
 		}
 		Context.raw.paintObject = painto;
-		Scene.camera.base.transform.setMatrix(Context.raw.savedCamera);
+		Transform.setMatrix(Scene.camera.base.transform, Context.raw.savedCamera);
 		Scene.camera.data.fov = savedFov;
 		Viewport.updateCameraType(Context.raw.cameraType);
-		Scene.camera.buildProjection();
-		Scene.camera.buildMatrix();
+		CameraObject.buildProjection(Scene.camera);
+		CameraObject.buildMatrix(Scene.camera);
 
 		// Scale layer down to to image preview
 		if (Base.pipeMerge == null) Base.makePipe();
@@ -373,7 +373,7 @@ class UtilRender {
 
 		let _scaleWorld = Context.raw.paintObject.base.transform.scaleWorld;
 		Context.raw.paintObject.base.transform.scaleWorld = 3.0;
-		Context.raw.paintObject.base.transform.buildMatrix();
+		Transform.buildMatrix(Context.raw.paintObject.base.transform);
 
 		g4.begin();
 		g4.setPipeline(res.scon._pipeState);
@@ -386,7 +386,7 @@ class UtilRender {
 		g4.end();
 
 		Context.raw.paintObject.base.transform.scaleWorld = _scaleWorld;
-		Context.raw.paintObject.base.transform.buildMatrix();
+		Transform.buildMatrix(Context.raw.paintObject.base.transform);
 	}
 
 	static pickPosNorTex = () => {
@@ -412,13 +412,13 @@ class UtilRender {
 		Context.raw.pdirty = 0;
 	}
 
-	static getDecalMat = (): Mat4 => {
+	static getDecalMat = (): TMat4 => {
 		UtilRender.pickPosNorTex();
 		let decalMat = Mat4.identity();
-		let loc = new Vec4(Context.raw.posXPicked, Context.raw.posYPicked, Context.raw.posZPicked);
-		let rot = new Quat().fromTo(new Vec4(0.0, 0.0, -1.0), new Vec4(Context.raw.norXPicked, Context.raw.norYPicked, Context.raw.norZPicked));
-		let scale = new Vec4(Context.raw.brushRadius * 0.5, Context.raw.brushRadius * 0.5, Context.raw.brushRadius * 0.5);
-		decalMat.compose(loc, rot, scale);
+		let loc = Vec4.create(Context.raw.posXPicked, Context.raw.posYPicked, Context.raw.posZPicked);
+		let rot = Quat.fromTo(Quat.create(), Vec4.create(0.0, 0.0, -1.0), Vec4.create(Context.raw.norXPicked, Context.raw.norYPicked, Context.raw.norZPicked));
+		let scale = Vec4.create(Context.raw.brushRadius * 0.5, Context.raw.brushRadius * 0.5, Context.raw.brushRadius * 0.5);
+		Mat4.compose(decalMat, loc, rot, scale);
 		return decalMat;
 	}
 

base/Sources/Viewport.ts

@@ -10,12 +10,12 @@ class Viewport {
 		po.base.transform.dim.x = aabb.x;
 		po.base.transform.dim.y = aabb.y;
 		po.base.transform.dim.z = aabb.z;
-		po.base.transform.scale.set(2 / r, 2 / r, 2 / r);
-		po.base.transform.loc.set(0, 0, 0);
-		po.base.transform.buildMatrix();
+		Vec4.set(po.base.transform.scale, 2 / r, 2 / r, 2 / r);
+		Vec4.set(po.base.transform.loc, 0, 0, 0);
+		Transform.buildMatrix(po.base.transform);
 		for (let c of po.base.children) {
-			c.transform.loc.set(0, 0, 0);
-			c.transform.buildMatrix();
+			Vec4.set(c.transform.loc, 0, 0, 0);
+			Transform.buildMatrix(c.transform);
 		}
 	}
 
@@ -23,29 +23,29 @@ class Viewport {
 		let cam = Scene.camera;
 		for (let o of Scene.raw.objects) {
 			if (o.type == "camera_object") {
-				cam.base.transform.local.setF32(o.transform.values);
-				cam.base.transform.decompose();
+				Mat4.setF32(cam.base.transform.local, o.transform.values);
+				Transform.decompose(cam.base.transform);
 				if (Context.raw.fovHandle != null) Context.raw.fovHandle.value = cam.data.fov = Base.defaultFov;
 				Context.raw.camHandle.position = 0;
 				cam.data.ortho = null;
-				cam.buildProjection();
+				CameraObject.buildProjection(cam);
 				Context.raw.ddirty = 2;
 				Camera.reset();
-				Context.mainObject().base.transform.reset();
+				Transform.reset(Context.mainObject().base.transform);
 				break;
 			}
 		}
 	}
 
 	static setView = (x: f32, y: f32, z: f32, rx: f32, ry: f32, rz: f32) => {
-		Context.raw.paintObject.base.transform.rot.set(0, 0, 0, 1);
+		Quat.set(Context.raw.paintObject.base.transform.rot, 0, 0, 0, 1);
 		Context.raw.paintObject.base.transform.dirty = true;
 		let cam = Scene.camera;
-		let dist = cam.base.transform.loc.length();
-		cam.base.transform.loc.set(x * dist, y * dist, z * dist);
-		cam.base.transform.rot.fromEuler(rx, ry, rz);
-		cam.base.transform.buildMatrix();
-		cam.buildProjection();
+		let dist = Vec4.vec4_length(cam.base.transform.loc);
+		Vec4.set(cam.base.transform.loc, x * dist, y * dist, z * dist);
+		Quat.fromEuler(cam.base.transform.rot, rx, ry, rz);
+		Transform.buildMatrix(cam.base.transform);
+		CameraObject.buildProjection(cam);
 		Context.raw.ddirty = 2;
 		Camera.reset(Context.raw.viewIndexLast);
 	}
@@ -53,22 +53,22 @@ class Viewport {
 	static orbit = (x: f32, y: f32) => {
 		let cam = Scene.camera;
 		let dist = Camera.distance();
-		cam.base.transform.move(cam.lookWorld(), dist);
-		cam.base.transform.rotate(new Vec4(0, 0, 1), x);
-		cam.base.transform.rotate(cam.rightWorld(), y);
-		cam.base.transform.move(cam.lookWorld(), -dist);
+		Transform.move(cam.base.transform, CameraObject.lookWorld(cam), dist);
+		Transform.rotate(cam.base.transform, Vec4.create(0, 0, 1), x);
+		Transform.rotate(cam.base.transform, CameraObject.rightWorld(cam), y);
+		Transform.move(cam.base.transform, CameraObject.lookWorld(cam), -dist);
 		Context.raw.ddirty = 2;
 	}
 
 	static orbitOpposite = () => {
 		let cam = Scene.camera;
-		let z = Math.abs(cam.look().z) - 1.0;
+		let z = Math.abs(CameraObject.look(cam).z) - 1.0;
 		(z < 0.0001 && z > -0.0001) ? Viewport.orbit(0, Math.PI) : Viewport.orbit(Math.PI, 0);
 	}
 
 	static zoom = (f: f32) => {
 		let cam = Scene.camera;
-		cam.base.transform.move(cam.look(), f);
+		Transform.move(cam.base.transform, CameraObject.look(cam), f);
 		Context.raw.ddirty = 2;
 	}
 
@@ -81,7 +81,7 @@ class Viewport {
 		}
 		else {
 			let f32a = new Float32Array(4);
-			let f = cam.data.fov * cam.base.transform.world.getLoc().length() / 2.5;
+			let f = cam.data.fov * Vec4.vec4_length(Mat4.getLoc(cam.base.transform.world)) / 2.5;
 			f32a[0] = -2 * f;
 			f32a[1] =  2 * f;
 			f32a[2] = -2 * f * (App.h() / App.w());
@@ -89,7 +89,7 @@ class Viewport {
 			cam.data.ortho = f32a;
 			light.base.visible = false;
 		}
-		cam.buildProjection();
+		CameraObject.buildProjection(cam);
 		Context.raw.ddirty = 2;
 	}
 }

base/Sources/main.ts

@@ -41,7 +41,7 @@ function main_start() {
 		if (Config.raw.layout == null) Base.initLayout();
 		Krom.setApplicationName(manifest_title);
 		App.init(function() {
-			Scene.setActive("Scene", function(o: BaseObject) {
+			Scene.setActive("Scene", function(o: TBaseObject) {
 				UniformsExt.init();
 				RenderPathBase.init();
 

base/Sources/nodes/ColorNode.ts

@@ -1,12 +1,12 @@
 
 class ColorNode extends LogicNode {
 
-	value = new Vec4();
+	value = Vec4.create();
 	image: Image = null;
 
 	constructor(r = 0.8, g = 0.8, b = 0.8, a = 1.0) {
 		super();
-		this.value.set(r, g, b, a);
+		Vec4.set(this.value, r, g, b, a);
 	}
 
 	override get = (from: i32, done: (a: any)=>void) => {

base/Sources/nodes/SeparateVectorNode.ts

@@ -6,7 +6,7 @@ class SeparateVectorNode extends LogicNode {
 	}
 
 	override get = (from: i32, done: (a: any)=>void) => {
-		this.inputs[0].get((vector: Vec4) => {
+		this.inputs[0].get((vector: TVec4) => {
 			if (from == 0) done(vector.x);
 			else if (from == 1) done(vector.y);
 			else done(vector.z);

base/Sources/nodes/VectorMathNode.ts

@@ -2,40 +2,40 @@
 class VectorMathNode extends LogicNode {
 
 	operation: string;
-	v = new Vec4();
+	v = Vec4.create();
 
 	constructor() {
 		super();
 	}
 
 	override get = (from: i32, done: (a: any)=>void) => {
-		this.inputs[0].get((v1: Vec4) => {
-			this.inputs[1].get((v2: Vec4) => {
-				this.v.setFrom(v1);
+		this.inputs[0].get((v1: TVec4) => {
+			this.inputs[1].get((v2: TVec4) => {
+				Vec4.setFrom(this.v, v1);
 				let f = 0.0;
 
 				switch (this.operation) {
 					case "Add":
-						this.v.add(v2);
+						Vec4.add(this.v, v2);
 						break;
 					case "Subtract":
-						this.v.sub(v2);
+						Vec4.sub(this.v, v2);
 						break;
 					case "Average":
-						this.v.add(v2);
+						Vec4.add(this.v, v2);
 						this.v.x *= 0.5;
 						this.v.y *= 0.5;
 						this.v.z *= 0.5;
 						break;
 					case "Dot Product":
-						f = this.v.dot(v2);
-						this.v.set(f, f, f);
+						f = Vec4.dot(this.v, v2);
+						Vec4.set(this.v, f, f, f);
 						break;
 					case "Cross Product":
-						this.v.cross(v2);
+						Vec4.cross(this.v, v2);
 						break;
 					case "Normalize":
-						this.v.normalize();
+						Vec4.normalize(this.v, );
 						break;
 					case "Multiply":
 						this.v.x *= v2.x;
@@ -48,22 +48,22 @@ class VectorMathNode extends LogicNode {
 						this.v.z /= v2.z == 0.0 ? 0.000001 : v2.z;
 						break;
 					case "Length":
-						f = this.v.length();
-						this.v.set(f, f, f);
+						f = Vec4.vec4_length(this.v);
+						Vec4.set(this.v, f, f, f);
 						break;
 					case "Distance":
-						f = this.v.distanceTo(v2);
-						this.v.set(f, f, f);
+						f = Vec4.distanceTo(this.v, v2);
+						Vec4.set(this.v, f, f, f);
 						break;
 					case "Project":
-						this.v.setFrom(v2);
-						this.v.mult(v1.dot(v2) / v2.dot(v2));
+						Vec4.setFrom(this.v, v2);
+						Vec4.mult(this.v, Vec4.dot(v1, v2) / Vec4.dot(v2, v2));
 						break;
 					case "Reflect":
-						let tmp = new Vec4();
-						tmp.setFrom(v2);
-						tmp.normalize();
-						this.v.reflect(tmp);
+						let tmp = Vec4.create();
+						Vec4.setFrom(tmp, v2);
+						Vec4.normalize(tmp);
+						Vec4.reflect(this.v, tmp);
 						break;
 					case "Scale":
 						this.v.x *= v2.x;

base/Sources/nodes/VectorNode.ts

@@ -1,7 +1,7 @@
 
 class VectorNode extends LogicNode {
 
-	value = new Vec4();
+	value = Vec4.create();
 	image: Image = null;
 
 	constructor(x: Null<f32> = null, y: Null<f32> = null, z: Null<f32> = null) {