Math fixes

armorlab/sources/render_path_paint.ts

@@ -200,7 +200,7 @@ function render_path_paint_draw_cursor(mx: f32, my: f32, radius: f32, tint_r: f3
 	g4_set_float3(base_cursor_tint, tint_r, tint_g, tint_b);
 	g4_set_mat(base_cursor_vp, scene_camera.vp);
 	let help_mat: mat4_t = mat4_identity();
-	help_mat = mat4_get_inv(scene_camera.vp);
+	help_mat = mat4_inv(scene_camera.vp);
 	g4_set_mat(base_cursor_inv_vp, help_mat);
 	///if (arm_metal || arm_vulkan)
 	let vs: vertex_structure_t[] = [{name: "tex", data: "short2norm"}];

armorpaint/sources/render_path_paint.ts

@@ -537,7 +537,7 @@ function render_path_paint_draw_cursor(mx: f32, my: f32, radius: f32, tint_r: f3
 	g4_set_float3(base_cursor_tint, tint_r, tint_g, tint_b);
 	g4_set_mat(base_cursor_vp, scene_camera.vp);
 	let help_mat: mat4_t = mat4_identity();
-	help_mat = mat4_get_inv(scene_camera.vp);
+	help_mat = mat4_inv(scene_camera.vp);
 	g4_set_mat(base_cursor_inv_vp, help_mat);
 	///if (arm_metal || arm_vulkan)
 	let vs: vertex_element_t[] = [
@@ -565,41 +565,41 @@ function render_path_paint_commands_symmetry() {
 		let sy: f32 = t.scale.y;
 		let sz: f32 = t.scale.z;
 		if (context_raw.sym_x) {
-			t.scale = vec4_new(-sx, sy, sz);
+			t.scale = vec4_create(-sx, sy, sz);
 			transform_build_matrix(t);
 			render_path_paint_commands_paint(false);
 		}
 		if (context_raw.sym_y) {
-			t.scale = vec4_new(sx, -sy, sz);
+			t.scale = vec4_create(sx, -sy, sz);
 			transform_build_matrix(t);
 			render_path_paint_commands_paint(false);
 		}
 		if (context_raw.sym_z) {
-			t.scale = vec4_new(sx, sy, -sz);
+			t.scale = vec4_create(sx, sy, -sz);
 			transform_build_matrix(t);
 			render_path_paint_commands_paint(false);
 		}
 		if (context_raw.sym_x && context_raw.sym_y) {
-			t.scale = vec4_new(-sx, -sy, sz);
+			t.scale = vec4_create(-sx, -sy, sz);
 			transform_build_matrix(t);
 			render_path_paint_commands_paint(false);
 		}
 		if (context_raw.sym_x && context_raw.sym_z) {
-			t.scale = vec4_new(-sx, sy, -sz);
+			t.scale = vec4_create(-sx, sy, -sz);
 			transform_build_matrix(t);
 			render_path_paint_commands_paint(false);
 		}
 		if (context_raw.sym_y && context_raw.sym_z) {
-			t.scale = vec4_new(sx, -sy, -sz);
+			t.scale = vec4_create(sx, -sy, -sz);
 			transform_build_matrix(t);
 			render_path_paint_commands_paint(false);
 		}
 		if (context_raw.sym_x && context_raw.sym_y && context_raw.sym_z) {
-			t.scale = vec4_new(-sx, -sy, -sz);
+			t.scale = vec4_create(-sx, -sy, -sz);
 			transform_build_matrix(t);
 			render_path_paint_commands_paint(false);
 		}
-		t.scale = vec4_new(sx, sy, sz);
+		t.scale = vec4_create(sx, sy, sz);
 		transform_build_matrix(t);
 	}
 }
@@ -856,7 +856,7 @@ function render_path_paint_set_plane_mesh() {
 	m = mat4_scale(m, vec4_create(tw, tw, 1));
 	m = mat4_set_loc(m, vec4_create(tx, ty, 0));
 	let m2: mat4_t = mat4_identity();
-	m2 = mat4_get_inv(scene_camera.vp);
+	m2 = mat4_inv(scene_camera.vp);
 	m = mat4_mult_mat(m, m2);
 
 	let tiled: bool = ui_view2d_tiled_show;
@@ -891,19 +891,19 @@ function render_path_paint_set_plane_mesh() {
 	context_raw.paint_object = render_path_paint_planeo;
 
 	let v: vec4_t = vec4_create();
-	v = vec4_new(m.m00, m.m01, m.m02);
+	v = vec4_create(m.m00, m.m01, m.m02);
 	let sx: f32 = vec4_len(v);
 	render_path_paint_planeo.base.transform.rot = quat_from_euler(-math_pi() / 2, 0, 0);
-	render_path_paint_planeo.base.transform.scale = vec4_new(sx, 1.0, sx);
+	render_path_paint_planeo.base.transform.scale = vec4_create(sx, 1.0, sx);
 	render_path_paint_planeo.base.transform.scale.z *= config_get_texture_res_y() / config_get_texture_res_x();
-	render_path_paint_planeo.base.transform.loc = vec4_new(m.m30, -m.m31, 0.0);
+	render_path_paint_planeo.base.transform.loc = vec4_create(m.m30, -m.m31, 0.0);
 	transform_build_matrix(render_path_paint_planeo.base.transform);
 }
 
 function render_path_paint_restore_plane_mesh() {
 	context_raw.paint2d_view = false;
 	render_path_paint_planeo.base.visible = false;
-	render_path_paint_planeo.base.transform.loc = vec4_new(0.0, 0.0, 0.0);
+	render_path_paint_planeo.base.transform.loc = vec4_create(0.0, 0.0, 0.0);
 	for (let i: i32 = 0; i < project_paint_objects.length; ++i) {
 		project_paint_objects[i].base.visible = render_path_paint_visibles[i];
 	}

base/sources/camera.ts

@@ -76,7 +76,7 @@ function camera_update() {
 		let dist: f32 = camera_distance();
 		transform_move(camera.base.transform, camera_object_look_world(camera), dist);
 		transform_rotate(camera.base.transform, vec4_z_axis(), -mouse_movement_x / 100 * config_raw.camera_rotation_speed);
-		transform_rotate(camera.base.transform, camera_object_right_world(camera), -mouse_movement_y / 100 * config_raw.camera_rotation_speed);
+		transform_rotate(camera.base.transform,  camera_object_right_world(camera), -mouse_movement_y / 100 * config_raw.camera_rotation_speed);
 		let up_world: vec4_t = camera_object_up_world(camera);
 		if (up_world.z < 0) {
 			transform_rotate(camera.base.transform, camera_object_right_world(camera), mouse_movement_y / 100 * config_raw.camera_rotation_speed);
@@ -86,9 +86,9 @@ function camera_update() {
 	else if (controls == camera_controls_t.ROTATE && (operator_shortcut(map_get(config_keymap, "action_rotate"), shortcut_type_t.DOWN) || (mouse_down("right") && !modif && default_keymap))) {
 		camera_redraws = 2;
 		let t: transform_t = context_main_object().base.transform;
-		let up: vec4_t = vec4_norm(transform_up(t));
+		let up: vec4_t = transform_up(t);
 		transform_rotate(t, up, mouse_movement_x / 100 * config_raw.camera_rotation_speed);
-		let right: vec4_t = vec4_norm(camera_object_right_world(camera));
+		let right: vec4_t = camera_object_right_world(camera);
 		transform_rotate(t, right, mouse_movement_y / 100 * config_raw.camera_rotation_speed);
 		transform_build_matrix(t);
 		let tup: vec4_t = transform_up(t);
@@ -131,7 +131,7 @@ function camera_update() {
 			if (camera_ease > 1.0) {
 				camera_ease = 1.0;
 			}
-			camera_dir = vec4_new(0, 0, 0);
+			camera_dir = vec4_create(0, 0, 0);
 			let look: vec4_t = camera_object_look(camera);
 			let right: vec4_t = camera_object_right(camera);
 			if (move_forward) {
@@ -237,8 +237,8 @@ function camera_pan_action(modif: bool, default_keymap: bool) {
 	let camera: camera_object_t = scene_camera;
 	if (operator_shortcut(map_get(config_keymap, "action_pan"), shortcut_type_t.DOWN) || (mouse_down("middle") && !modif && default_keymap)) {
 		camera_redraws = 2;
-		let look: vec4_t = vec4_mult(vec4_norm(transform_look(camera.base.transform)), mouse_movement_y / 150 * config_raw.camera_pan_speed);
-		let right: vec4_t = vec4_mult(vec4_norm(transform_right(camera.base.transform)), -mouse_movement_x / 150 * config_raw.camera_pan_speed);
+		let look: vec4_t = vec4_mult(transform_look(camera.base.transform), mouse_movement_y / 150 * config_raw.camera_pan_speed);
+		let right: vec4_t = vec4_mult(transform_right(camera.base.transform), -mouse_movement_x / 150 * config_raw.camera_pan_speed);
 		camera.base.transform.loc = vec4_add(camera.base.transform.loc, look);
 		camera.base.transform.loc = vec4_add(camera.base.transform.loc, right);
 		camera_origins[camera_index()].v = vec4_add(camera_origins[camera_index()].v, look);

base/sources/geom.ts

@@ -92,7 +92,7 @@ function geom_make_uv_sphere(radius: f32 = 1.0, width_segments: i32 = 32, height
 			mesh.posa[i4    ] = math_floor(vx * inv);
 			mesh.posa[i4 + 1] = math_floor(vy * inv);
 			mesh.posa[i4 + 2] = math_floor(vz * inv);
-			nor = vec4_new(vx, vy, vz);
+			nor = vec4_create(vx, vy, vz);
 			nor = vec4_norm(nor);
 			mesh.posa[i4 + 3] = math_floor(nor.z * 32767);
 			mesh.nora[i2    ] = math_floor(nor.x * 32767);

base/sources/gizmo.ts

@@ -28,21 +28,21 @@ function gizmo_update() {
 		gizmo.transform.loc = vec4_clone(paint_object.transform.loc);
 	}
 	else if (is_decal) {
-		gizmo.transform.loc = vec4_new(context_raw.layer.decal_mat.m30, context_raw.layer.decal_mat.m31, context_raw.layer.decal_mat.m32);
+		gizmo.transform.loc = vec4_create(context_raw.layer.decal_mat.m30, context_raw.layer.decal_mat.m31, context_raw.layer.decal_mat.m32);
 	}
 	let cam: camera_object_t = scene_camera;
 	let fov: f32 = cam.data.fov;
 	let dist: f32 = vec4_dist(cam.base.transform.loc, gizmo.transform.loc) / 8 * fov;
-	gizmo.transform.scale = vec4_new(dist, dist, dist);
-	context_raw.gizmo_translate_x.transform.scale = vec4_new(dist, dist, dist);
-	context_raw.gizmo_translate_y.transform.scale = vec4_new(dist, dist, dist);
-	context_raw.gizmo_translate_z.transform.scale = vec4_new(dist, dist, dist);
-	context_raw.gizmo_scale_x.transform.scale = vec4_new(dist, dist, dist);
-	context_raw.gizmo_scale_y.transform.scale = vec4_new(dist, dist, dist);
-	context_raw.gizmo_scale_z.transform.scale = vec4_new(dist, dist, dist);
-	context_raw.gizmo_rotate_x.transform.scale = vec4_new(dist, dist, dist);
-	context_raw.gizmo_rotate_y.transform.scale = vec4_new(dist, dist, dist);
-	context_raw.gizmo_rotate_z.transform.scale = vec4_new(dist, dist, dist);
+	gizmo.transform.scale = vec4_create(dist, dist, dist);
+	context_raw.gizmo_translate_x.transform.scale = vec4_create(dist, dist, dist);
+	context_raw.gizmo_translate_y.transform.scale = vec4_create(dist, dist, dist);
+	context_raw.gizmo_translate_z.transform.scale = vec4_create(dist, dist, dist);
+	context_raw.gizmo_scale_x.transform.scale = vec4_create(dist, dist, dist);
+	context_raw.gizmo_scale_y.transform.scale = vec4_create(dist, dist, dist);
+	context_raw.gizmo_scale_z.transform.scale = vec4_create(dist, dist, dist);
+	context_raw.gizmo_rotate_x.transform.scale = vec4_create(dist, dist, dist);
+	context_raw.gizmo_rotate_y.transform.scale = vec4_create(dist, dist, dist);
+	context_raw.gizmo_rotate_z.transform.scale = vec4_create(dist, dist, dist);
 	transform_build_matrix(gizmo.transform);
 
 	// Scene control
@@ -233,10 +233,10 @@ function gizmo_update() {
 
 		if (is_object) {
 			let t: transform_t = paint_object.transform;
-			gizmo_v = vec4_new(transform_world_x(t), transform_world_y(t), transform_world_z(t));
+			gizmo_v = vec4_create(transform_world_x(t), transform_world_y(t), transform_world_z(t));
 		}
 		else if (is_decal) {
-			gizmo_v = vec4_new(context_raw.layer.decal_mat.m30, context_raw.layer.decal_mat.m31, context_raw.layer.decal_mat.m32);
+			gizmo_v = vec4_create(context_raw.layer.decal_mat.m30, context_raw.layer.decal_mat.m31, context_raw.layer.decal_mat.m32);
 		}
 
 		if (context_raw.translate_x || context_raw.scale_x) {

base/sources/import_arm.ts

@@ -84,7 +84,7 @@ function import_arm_run_project(path: string) {
 		scene_camera.data.fov = project_raw.camera_fov;
 		camera_object_build_proj(scene_camera);
 		let origin: f32_array_t = project_raw.camera_origin;
-		camera_origins[0].v = vec4_new(origin[0], origin[1], origin[2]);
+		camera_origins[0].v = vec4_create(origin[0], origin[1], origin[2]);
 	}
 
 	for (let i: i32 = 0; i < project.assets.length; ++i) {
@@ -134,7 +134,7 @@ function import_arm_run_project(path: string) {
 	///end
 
 	mesh_object_set_data(context_raw.paint_object, md);
-	context_raw.paint_object.base.transform.scale = vec4_new(1, 1, 1);
+	context_raw.paint_object.base.transform.scale = vec4_create(1, 1, 1);
 	transform_build_matrix(context_raw.paint_object.base.transform);
 	context_raw.paint_object.base.name = md.name;
 	project_paint_objects = [context_raw.paint_object];
@@ -412,7 +412,7 @@ function import_arm_run_mesh(raw: scene_t) {
 			md._.handle = md.name;
 			map_set(data_cached_meshes, md._.handle, md);
 		}
-		object.base.transform.scale = vec4_new(1, 1, 1);
+		object.base.transform.scale = vec4_create(1, 1, 1);
 		transform_build_matrix(object.base.transform);
 		object.base.name = md.name;
 		array_push(project_paint_objects, object);
@@ -671,64 +671,44 @@ function import_arm_unpack_asset(project: project_format_t, abs: string, file: s
 	}
 }
 
-function _import_arm_get_f32(map: map_t<string, any>, key: string): f32 {
-	let i: i32 = armpack_map_get_i64(map, key);
-	if (i < 2048) { // Otherwise it's likely encoded as a float
-		return i;
-	}
-	return armpack_map_get_f64(map, key);
-}
-
-function _import_arm_get_f32_array_element(map: map_t<string, any>, key: string): f32 {
-	return armpack_map_get_f64(map, key);
-}
-
-function _import_arm_get_i32(map: map_t<string, any>, key: string): i32 {
-	let i: i32 = armpack_map_get_i64(map, key);
-	if (i < 2048) {
-		return i;
-	}
-	return armpack_map_get_f64(map, key);
-}
-
 function _import_arm_get_node_socket_array(old: map_t<string, any>, key: string): ui_node_socket_t[] {
 	let sockets: ui_node_socket_t[] = [];
 	let ias: any[] = map_get(old, key);
 	for (let i: i32 = 0; i < ias.length; ++i) {
 		let old: map_t<string, any> = ias[i];
 		let s: ui_node_socket_t = {};
-		s.id = _import_arm_get_i32(old, "id");
-		s.node_id = _import_arm_get_i32(old, "node_id");
+		s.id = armpack_map_get_i32(old, "id");
+		s.node_id = armpack_map_get_i32(old, "node_id");
 		s.name = map_get(old, "name");
 		s.type = map_get(old, "type");
-		s.color = _import_arm_get_i32(old, "color");
+		s.color = armpack_map_get_i32(old, "color");
 		if (s.type == "VALUE") {
-			let x: f32 = _import_arm_get_f32(old, "default_value");
+			let x: f32 = armpack_map_get_f32(old, "default_value");
 			s.default_value = f32_array_create_x(x);
 		}
 		else { // VECTOR, RGBA
 			let dv: map_t<string, any> = map_get(old, "default_value");
-			let x: f32 = _import_arm_get_f32_array_element(dv, "0");
-			let y: f32 = _import_arm_get_f32_array_element(dv, "1");
-			let z: f32 = _import_arm_get_f32_array_element(dv, "2");
+			let x: f32 = armpack_map_get_f32(dv, "0");
+			let y: f32 = armpack_map_get_f32(dv, "1");
+			let z: f32 = armpack_map_get_f32(dv, "2");
 			if (s.type == "VECTOR") {
 				s.default_value = f32_array_create_xyz(x, y, z);
 			}
 			else { // RGBA
-				let w: f32 = _import_arm_get_f32_array_element(dv, "3");
+				let w: f32 = armpack_map_get_f32(dv, "3");
 				s.default_value = f32_array_create_xyzw(x, y, z, w);
 			}
 		}
-		s.min = _import_arm_get_f32(old, "min");
-		s.max = _import_arm_get_f32(old, "max");
+		s.min = armpack_map_get_f32(old, "min");
+		s.max = armpack_map_get_f32(old, "max");
 		if (s.max == 0.0) {
 			s.max = 1.0;
 		}
-		s.precision = _import_arm_get_f32(old, "precision");
+		s.precision = armpack_map_get_f32(old, "precision");
 		if (s.precision == 0.0) {
 			s.precision = 100.0;
 		}
-		s.display = _import_arm_get_i32(old, "display");
+		s.display = armpack_map_get_i32(old, "display");
 		array_push(sockets, s);
 	}
 	return sockets;
@@ -751,12 +731,12 @@ function _import_arm_get_node_canvas_array(map: map_t<string, any>, key: string)
 			let old: map_t<string, any> = nas[i];
 			let n: ui_node_t = {};
 
-			n.id = _import_arm_get_i32(old, "id");
+			n.id = armpack_map_get_i32(old, "id");
 			n.name = map_get(old, "name");
 			n.type = map_get(old, "type");
-			n.x = _import_arm_get_f32(old, "x");
-			n.y = _import_arm_get_f32(old, "y");
-			n.color = _import_arm_get_i32(old, "color");
+			n.x = armpack_map_get_f32(old, "x");
+			n.y = armpack_map_get_f32(old, "y");
+			n.color = armpack_map_get_i32(old, "color");
 			n.inputs = _import_arm_get_node_socket_array(old, "inputs");
 			n.outputs = _import_arm_get_node_socket_array(old, "outputs");
 
@@ -767,10 +747,10 @@ function _import_arm_get_node_canvas_array(map: map_t<string, any>, key: string)
 				let b: ui_node_button_t = {};
 				b.name = map_get(old, "name");
 				b.type = map_get(old, "type");
-				b.output = _import_arm_get_i32(old, "output");
+				b.output = armpack_map_get_i32(old, "output");
 
 				if (b.type == "ENUM") {
-					let x: f32 = _import_arm_get_i32(old, "default_value");
+					let x: f32 = armpack_map_get_i32(old, "default_value");
 					b.default_value = f32_array_create_x(x);
 
 					if (b.name == "File") {
@@ -784,7 +764,7 @@ function _import_arm_get_node_canvas_array(map: map_t<string, any>, key: string)
 					}
 				}
 				else if (b.type == "BOOL") {
-					let x: f32 = _import_arm_get_i32(old, "default_value");
+					let x: f32 = armpack_map_get_i32(old, "default_value");
 					b.default_value = f32_array_create_x(x);
 				}
 				else if (b.type == "CUSTOM") {
@@ -805,14 +785,14 @@ function _import_arm_get_node_canvas_array(map: map_t<string, any>, key: string)
 					}
 				}
 
-				b.min = _import_arm_get_f32(old, "min");
-				b.max = _import_arm_get_f32(old, "max");
-				b.precision = _import_arm_get_f32(old, "precision");
-				b.height = _import_arm_get_f32(old, "height");
+				b.min = armpack_map_get_f32(old, "min");
+				b.max = armpack_map_get_f32(old, "max");
+				b.precision = armpack_map_get_f32(old, "precision");
+				b.height = armpack_map_get_f32(old, "height");
 				array_push(n.buttons, b);
 			}
 
-			n.width = _import_arm_get_f32(old, "width");
+			n.width = armpack_map_get_f32(old, "width");
 
 			array_push(c.nodes, n);
 		}
@@ -822,11 +802,11 @@ function _import_arm_get_node_canvas_array(map: map_t<string, any>, key: string)
 		for (let i: i32 = 0; i < las.length; ++i) {
 			let old: map_t<string, any> = las[i];
 			let l: ui_node_link_t = {};
-			l.id = _import_arm_get_i32(old, "id");
-			l.from_id = _import_arm_get_i32(old, "from_id");
-			l.from_socket = _import_arm_get_i32(old, "from_socket");
-			l.to_id = _import_arm_get_i32(old, "to_id");
-			l.to_socket = _import_arm_get_i32(old, "to_socket");
+			l.id = armpack_map_get_i32(old, "id");
+			l.from_id = armpack_map_get_i32(old, "from_id");
+			l.from_socket = armpack_map_get_i32(old, "from_socket");
+			l.to_id = armpack_map_get_i32(old, "to_id");
+			l.to_socket = armpack_map_get_i32(old, "to_socket");
 			array_push(c.links, l);
 		}
 
@@ -845,7 +825,7 @@ function import_arm_upgrade_from_08(b: buffer_t): project_format_t {
 	if (project.assets == null) {
 		project.assets = [];
 	}
-	project.is_bgra = _import_arm_get_i32(old, "is_bgra") > 0;
+	project.is_bgra = armpack_map_get_i32(old, "is_bgra") > 0;
 	let pas: any[] = map_get(old, "packed_assets");
 	if (pas != null) {
 		project.packed_assets = [];

base/sources/import_blend_mesh.ts

@@ -112,10 +112,10 @@ function import_blend_mesh_run(path: string, replace_existing: bool = true) {
 				let no0: i16_ptr = bl_handle_get(v0, "no");
 				let no1: i16_ptr = bl_handle_get(v1, "no");
 				if (smooth) {
-					vec0 = vec4_new(ARRAY_ACCESS(no0, 0) / 32767, ARRAY_ACCESS(no0, 1) / 32767, ARRAY_ACCESS(no0, 2) / 32767);
+					vec0 = vec4_create(ARRAY_ACCESS(no0, 0) / 32767, ARRAY_ACCESS(no0, 1) / 32767, ARRAY_ACCESS(no0, 2) / 32767);
 					vec0 = vec4_norm(vec0); // shortmax
 
-					vec1 = vec4_new(ARRAY_ACCESS(no1, 0) / 32767, ARRAY_ACCESS(no1, 1) / 32767, ARRAY_ACCESS(no1, 2) / 32767);
+					vec1 = vec4_create(ARRAY_ACCESS(no1, 0) / 32767, ARRAY_ACCESS(no1, 1) / 32767, ARRAY_ACCESS(no1, 2) / 32767);
 					vec1 = vec4_norm(vec1);
 				}
 				let uv0: f32_array_t = null;
@@ -163,14 +163,14 @@ function import_blend_mesh_run(path: string, replace_existing: bool = true) {
 					let co2: f32_ptr = bl_handle_get(v2, "co");
 					let no2: i16_ptr = bl_handle_get(v2, "no");
 					if (smooth) {
-						vec2 = vec4_new(ARRAY_ACCESS(no2, 0) / 32767, ARRAY_ACCESS(no2, 1) / 32767, ARRAY_ACCESS(no2, 2) / 32767);
+						vec2 = vec4_create(ARRAY_ACCESS(no2, 0) / 32767, ARRAY_ACCESS(no2, 1) / 32767, ARRAY_ACCESS(no2, 2) / 32767);
 						vec2 = vec4_norm(vec2);
 					}
 					else {
-						vec2 = vec4_new(ARRAY_ACCESS(co2, 0), ARRAY_ACCESS(co2, 1), ARRAY_ACCESS(co2, 2));
-						vec1 = vec4_new(ARRAY_ACCESS(co1, 0), ARRAY_ACCESS(co1, 1), ARRAY_ACCESS(co1, 2));
+						vec2 = vec4_create(ARRAY_ACCESS(co2, 0), ARRAY_ACCESS(co2, 1), ARRAY_ACCESS(co2, 2));
+						vec1 = vec4_create(ARRAY_ACCESS(co1, 0), ARRAY_ACCESS(co1, 1), ARRAY_ACCESS(co1, 2));
 						vec0 = vec4_sub(vec2, vec1);
-						vec2 = vec4_new(ARRAY_ACCESS(co0, 0), ARRAY_ACCESS(co0, 1), ARRAY_ACCESS(co0, 2));
+						vec2 = vec4_create(ARRAY_ACCESS(co0, 0), ARRAY_ACCESS(co0, 1), ARRAY_ACCESS(co0, 2));
 						vec1 = vec4_sub(vec2, vec1);
 						vec0 = vec4_cross(vec0, vec1);
 						vec0 = vec4_norm(vec0);
@@ -245,10 +245,10 @@ function import_blend_mesh_run(path: string, replace_existing: bool = true) {
 				let co0: f32_ptr = bl_handle_get(v0, "co");
 				let co1: f32_ptr = bl_handle_get(v1, "co");
 				let co2: f32_ptr = bl_handle_get(v2, "co");
-				vec2 = vec4_new(ARRAY_ACCESS(co2, 0), ARRAY_ACCESS(co2, 1), ARRAY_ACCESS(co2, 2));
-				vec1 = vec4_new(ARRAY_ACCESS(co1, 0), ARRAY_ACCESS(co1, 1), ARRAY_ACCESS(co1, 2));
+				vec2 = vec4_create(ARRAY_ACCESS(co2, 0), ARRAY_ACCESS(co2, 1), ARRAY_ACCESS(co2, 2));
+				vec1 = vec4_create(ARRAY_ACCESS(co1, 0), ARRAY_ACCESS(co1, 1), ARRAY_ACCESS(co1, 2));
 				vec0 = vec4_sub(vec2, vec1);
-				vec2 = vec4_new(ARRAY_ACCESS(co0, 0), ARRAY_ACCESS(co0, 1), ARRAY_ACCESS(co0, 2));
+				vec2 = vec4_create(ARRAY_ACCESS(co0, 0), ARRAY_ACCESS(co0, 1), ARRAY_ACCESS(co0, 2));
 				vec1 = vec4_sub(vec2, vec1);
 				vec4_cross(vec0, vec1);
 				vec0 = vec4_norm(vec0);
@@ -328,20 +328,20 @@ function import_blend_mesh_run(path: string, replace_existing: bool = true) {
 						let no1: i16_ptr = bl_handle_get(v1, "no");
 						let no2: i16_ptr = bl_handle_get(v2, "no");
 						if (smooth) {
-							vec0 = vec4_new(ARRAY_ACCESS(no0, 0) / 32767, ARRAY_ACCESS(no0, 1) / 32767, ARRAY_ACCESS(no0, 2) / 32767);
+							vec0 = vec4_create(ARRAY_ACCESS(no0, 0) / 32767, ARRAY_ACCESS(no0, 1) / 32767, ARRAY_ACCESS(no0, 2) / 32767);
 							vec0 = vec4_norm(vec0); // shortmax
 
-							vec1 = vec4_new(ARRAY_ACCESS(no1, 0) / 32767, ARRAY_ACCESS(no1, 1) / 32767, ARRAY_ACCESS(no1, 2) / 32767);
+							vec1 = vec4_create(ARRAY_ACCESS(no1, 0) / 32767, ARRAY_ACCESS(no1, 1) / 32767, ARRAY_ACCESS(no1, 2) / 32767);
 							vec1 = vec4_norm(vec1);
 
-							vec2 = vec4_new(ARRAY_ACCESS(no2, 0) / 32767, ARRAY_ACCESS(no2, 1) / 32767, ARRAY_ACCESS(no2, 2) / 32767);
+							vec2 = vec4_create(ARRAY_ACCESS(no2, 0) / 32767, ARRAY_ACCESS(no2, 1) / 32767, ARRAY_ACCESS(no2, 2) / 32767);
 							vec2 = vec4_norm(vec2);
 						}
 						else {
-							vec2 = vec4_new(ARRAY_ACCESS(co2, 0), ARRAY_ACCESS(co2, 1), ARRAY_ACCESS(co2, 2));
-							vec1 = vec4_new(ARRAY_ACCESS(co1, 0), ARRAY_ACCESS(co1, 1), ARRAY_ACCESS(co1, 2));
+							vec2 = vec4_create(ARRAY_ACCESS(co2, 0), ARRAY_ACCESS(co2, 1), ARRAY_ACCESS(co2, 2));
+							vec1 = vec4_create(ARRAY_ACCESS(co1, 0), ARRAY_ACCESS(co1, 1), ARRAY_ACCESS(co1, 2));
 							vec0 = vec4_sub(vec2, vec1);
-							vec2 = vec4_new(ARRAY_ACCESS(co0, 0), ARRAY_ACCESS(co0, 1), ARRAY_ACCESS(co0, 2));
+							vec2 = vec4_create(ARRAY_ACCESS(co0, 0), ARRAY_ACCESS(co0, 1), ARRAY_ACCESS(co0, 2));
 							vec1 = vec4_sub(vec2, vec1);
 							vec4_cross(vec0, vec1);
 							vec0 = vec4_norm(vec0);
@@ -463,18 +463,18 @@ function import_blend_mesh_run(path: string, replace_existing: bool = true) {
 
 		let v: vec4_t = vec4_create();
 		for (let i: i32 = 0; i < math_floor(posa32.length / 3); ++i) {
-			v = vec4_new(posa32[i * 3], posa32[i * 3 + 1], posa32[i * 3 + 2]);
+			v = vec4_create(posa32[i * 3], posa32[i * 3 + 1], posa32[i * 3 + 2]);
 			v = vec4_apply_mat4(v, mat);
 			posa32[i * 3    ] = v.x;
 			posa32[i * 3 + 1] = v.y;
 			posa32[i * 3 + 2] = v.z;
 		}
 
-		mat = mat4_get_inv(mat);
+		mat = mat4_inv(mat);
 		mat = mat4_transpose3x3(mat);
 		mat.m30 = mat.m31 = mat.m32 = mat.m33 = 0;
 		for (let i: i32 = 0; i < math_floor(nora.length / 2); ++i) {
-			v = vec4_new(nora[i * 2] / 32767, nora[i * 2 + 1] / 32767, posa[i * 4 + 3] / 32767);
+			v = vec4_create(nora[i * 2] / 32767, nora[i * 2 + 1] / 32767, posa[i * 4 + 3] / 32767);
 			v = vec4_apply_mat(v, mat);
 			v = vec4_norm(v);
 			nora[i * 2    ] = math_floor(v.x * 32767);

base/sources/import_envmap.ts

@@ -106,7 +106,7 @@ function import_envmap_reverse_equirect(x: f32, y: f32): vec4_t {
 	let theta: f32 = x * math_pi() * 2 - math_pi();
 	let phi: f32 = y * math_pi();
 	// return n.set(math_sin(phi) * math_cos(theta), -(math_sin(phi) * math_sin(theta)), math_cos(phi));
-	import_envmap_n = vec4_new(-math_cos(phi), math_sin(phi) * math_cos(theta), -(math_sin(phi) * math_sin(theta)));
+	import_envmap_n = vec4_create(-math_cos(phi), math_sin(phi) * math_cos(theta), -(math_sin(phi) * math_sin(theta)));
 	return import_envmap_n;
 }
 

base/sources/line_draw.ts

@@ -142,10 +142,10 @@ function line_draw_line(x1: f32, y1: f32, z1: f32, x2: f32, y2: f32, z2: f32) {
 		line_draw_begin();
 	}
 
-	line_draw_mid_point = vec4_new(x1 + x2, y1 + y2, z1 + z2);
+	line_draw_mid_point = vec4_create(x1 + x2, y1 + y2, z1 + z2);
 	line_draw_mid_point = vec4_mult(line_draw_mid_point, 0.5);
 
-	line_draw_mid_line = vec4_new(x1, y1, z1);
+	line_draw_mid_line = vec4_create(x1, y1, z1);
 	line_draw_mid_line = vec4_sub(line_draw_mid_line, line_draw_mid_point);
 
 	let camera: camera_object_t = scene_camera;
@@ -156,16 +156,16 @@ function line_draw_line(x1: f32, y1: f32, z1: f32, x2: f32, y2: f32, z2: f32) {
 	line_width = vec4_norm(line_width);
 	line_width = vec4_mult(line_width, line_draw_strength);
 
-	line_draw_corner1 = vec4_new(x1, y1, z1);
+	line_draw_corner1 = vec4_create(x1, y1, z1);
 	line_draw_corner1 = vec4_add(line_draw_corner1, line_width);
 
-	line_draw_corner2 = vec4_new(x1, y1, z1);
+	line_draw_corner2 = vec4_create(x1, y1, z1);
 	line_draw_corner2 = vec4_sub(line_draw_corner2, line_width);
 
-	line_draw_corner3 = vec4_new(x2, y2, z2);
+	line_draw_corner3 = vec4_create(x2, y2, z2);
 	line_draw_corner3 = vec4_sub(line_draw_corner3, line_width);
 
-	line_draw_corner4 = vec4_new(x2, y2, z2);
+	line_draw_corner4 = vec4_create(x2, y2, z2);
 	line_draw_corner4 = vec4_add(line_draw_corner4, line_width);
 
 	let i: i32 = line_draw_lines * 24; // 4 * 6 (structure len)

base/sources/nodes/vector_math_node.ts

@@ -33,7 +33,7 @@ function vector_math_node_get(self: vector_math_node_t, from: i32): logic_node_v
 	}
 	else if (op == "Dot Product") {
 		f = vec4_dot(self.v, v2);
-		self.v = vec4_new(f, f, f);
+		self.v = vec4_create(f, f, f);
 	}
 	else if (op == "Cross Product") {
 		self.v = vec4_cross(self.v, v2);
@@ -53,11 +53,11 @@ function vector_math_node_get(self: vector_math_node_t, from: i32): logic_node_v
 	}
 	else if (op == "Length") {
 		f = vec4_len(self.v);
-		self.v = vec4_new(f, f, f);
+		self.v = vec4_create(f, f, f);
 	}
 	else if (op == "Distance") {
 		f = vec4_dist(self.v, v2);
-		self.v = vec4_new(f, f, f);
+		self.v = vec4_create(f, f, f);
 	}
 	else if (op == "Project") {
 		self.v = vec4_clone(v2);

base/sources/project.ts

@@ -239,7 +239,7 @@ function project_new(reset_layers: bool = true) {
 	///end
 
 	mesh_object_set_data(context_raw.paint_object, md);
-	context_raw.paint_object.base.transform.scale = vec4_new(1, 1, 1);
+	context_raw.paint_object.base.transform.scale = vec4_create(1, 1, 1);
 	transform_build_matrix(context_raw.paint_object.base.transform);
 	context_raw.paint_object.base.name = n;
 	project_paint_objects = [context_raw.paint_object];

base/sources/render_path_base.ts

@@ -77,7 +77,7 @@ function render_path_base_draw_compass() {
 		compass.base.parent = cam.base;
 		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);
-		compass.base.transform.scale = vec4_new(0.4, 0.4, 0.4);
+		compass.base.transform.scale = vec4_create(0.4, 0.4, 0.4);
 		transform_build_matrix(compass.base.transform);
 		compass.frustum_culling = false;
 		let empty: string[] = [];

base/sources/render_path_raytrace.ts

@@ -79,7 +79,7 @@ function render_path_raytrace_commands(use_live_layer: bool) {
 	let ct: transform_t = cam.base.transform;
 	render_path_raytrace_help_mat = mat4_clone(cam.v);
 	render_path_raytrace_help_mat = mat4_mult_mat(render_path_raytrace_help_mat, cam.p);
-	render_path_raytrace_help_mat = mat4_get_inv(render_path_raytrace_help_mat);
+	render_path_raytrace_help_mat = mat4_inv(render_path_raytrace_help_mat);
 	render_path_raytrace_f32a[0] = transform_world_x(ct);
 	render_path_raytrace_f32a[1] = transform_world_y(ct);
 	render_path_raytrace_f32a[2] = transform_world_z(ct);

base/sources/ui_base.ts

@@ -857,8 +857,8 @@ function ui_base_update() {
 
 			let camera: camera_object_t = scene_camera;
 			let ct: transform_t = camera.base.transform;
-			mo.base.transform.loc = vec4_new(transform_world_x(ct), transform_world_y(ct), transform_world_z(ct));
-			mo.base.transform.scale = vec4_new(context_raw.brush_radius * 0.2, context_raw.brush_radius * 0.2, context_raw.brush_radius * 0.2);
+			mo.base.transform.loc = vec4_create(transform_world_x(ct), transform_world_y(ct), transform_world_z(ct));
+			mo.base.transform.scale = vec4_create(context_raw.brush_radius * 0.2, context_raw.brush_radius * 0.2, context_raw.brush_radius * 0.2);
 			transform_build_matrix(mo.base.transform);
 
 			let body: physics_body_t = physics_body_create();

base/sources/uniforms_ext.ts

@@ -151,13 +151,13 @@ function uniforms_ext_f32_link(object: object_t, mat: material_data_t, link: str
 function uniforms_ext_vec2_link(object: object_t, mat: material_data_t, link: string): vec2_t {
 	if (link == "_gbuffer_size") {
 		let gbuffer2: render_target_t = map_get(render_path_render_targets, "gbuffer2");
-		return vec2_new(gbuffer2._image.width, gbuffer2._image.height);
+		return vec2_create(gbuffer2._image.width, gbuffer2._image.height);
 	}
 	else if (link == "_clone_delta") {
-		return vec2_new(context_raw.clone_delta_x, context_raw.clone_delta_y);
+		return vec2_create(context_raw.clone_delta_x, context_raw.clone_delta_y);
 	}
 	else if (link == "_texpaint_size") {
-		return vec2_new(config_get_texture_res_x(), config_get_texture_res_y());
+		return vec2_create(config_get_texture_res_x(), config_get_texture_res_y());
 	}
 	///if (is_paint || is_sculpt)
 	else if (link == "_brush_angle") {
@@ -167,7 +167,7 @@ function uniforms_ext_vec2_link(object: object_t, mat: material_data_t, link: st
 		if (config_raw.pressure_angle && pen_down()) {
 			angle *= pen_pressure * config_raw.pressure_sensitivity;
 		}
-		return vec2_new(math_cos(-angle), math_sin(-angle));
+		return vec2_create(math_cos(-angle), math_sin(-angle));
 	}
 	///end
 
@@ -194,25 +194,25 @@ function uniforms_ext_vec3_link(object: object_t, mat: material_data_t, link: st
 			lastx = vec2d(lastx);
 		}
 		let angle: f32 = math_atan2(-y + lasty, x - lastx) - math_pi() / 2;
-		v = vec4_new(math_cos(angle), math_sin(angle), allow_paint ? 1 : 0);
+		v = vec4_create(math_cos(angle), math_sin(angle), allow_paint ? 1 : 0);
 		context_raw.prev_paint_vec_x = context_raw.last_paint_vec_x;
 		context_raw.prev_paint_vec_y = context_raw.last_paint_vec_y;
 		return v;
 	}
 	else if (link == "_decal_layer_loc") {
 		v = _uniforms_vec;
-		v = vec4_new(context_raw.layer.decal_mat.m30, context_raw.layer.decal_mat.m31, context_raw.layer.decal_mat.m32);
+		v = vec4_create(context_raw.layer.decal_mat.m30, context_raw.layer.decal_mat.m31, context_raw.layer.decal_mat.m32);
 		return v;
 	}
 	else if (link == "_decal_layer_nor") {
 		v = _uniforms_vec;
-		v = vec4_new(context_raw.layer.decal_mat.m20, context_raw.layer.decal_mat.m21, context_raw.layer.decal_mat.m22);
+		v = vec4_create(context_raw.layer.decal_mat.m20, context_raw.layer.decal_mat.m21, context_raw.layer.decal_mat.m22);
 		v = vec4_norm(v);
 		return v;
 	}
 	else if (link == "_picker_base") {
 		v = _uniforms_vec;
-		v = vec4_new(
+		v = vec4_create(
 			color_get_rb(context_raw.picked_color.base) / 255,
 			color_get_gb(context_raw.picked_color.base) / 255,
 			color_get_bb(context_raw.picked_color.base) / 255
@@ -221,7 +221,7 @@ function uniforms_ext_vec3_link(object: object_t, mat: material_data_t, link: st
 	}
 	else if (link == "_picker_normal") {
 		v = _uniforms_vec;
-		v = vec4_new(
+		v = vec4_create(
 			color_get_rb(context_raw.picked_color.normal) / 255,
 			color_get_gb(context_raw.picked_color.normal) / 255,
 			color_get_bb(context_raw.picked_color.normal) / 255
@@ -231,12 +231,12 @@ function uniforms_ext_vec3_link(object: object_t, mat: material_data_t, link: st
 	///if arm_physics
 	else if (link == "_particle_hit") {
 		v = _uniforms_vec;
-		v = vec4_new(context_raw.particle_hit_x, context_raw.particle_hit_y, context_raw.particle_hit_z);
+		v = vec4_create(context_raw.particle_hit_x, context_raw.particle_hit_y, context_raw.particle_hit_z);
 		return v;
 	}
 	else if (link == "_particle_hit_last") {
 		v = _uniforms_vec;
-		v = vec4_new(context_raw.last_particle_hit_x, context_raw.last_particle_hit_y, context_raw.last_particle_hit_z);
+		v = vec4_create(context_raw.last_particle_hit_x, context_raw.last_particle_hit_y, context_raw.last_particle_hit_z);
 		return v;
 	}
 	///end
@@ -258,7 +258,7 @@ function vec2d(x: f32): f32 {
 function uniforms_ext_vec4_link(object: object_t, mat: material_data_t, link: string): vec4_t {
 	if (link == "_input_brush") {
 		let down: bool = mouse_down() || pen_down();
-		let v: vec4_t = vec4_new(context_raw.paint_vec.x, context_raw.paint_vec.y, down ? 1.0 : 0.0, 0.0);
+		let v: vec4_t = vec4_create(context_raw.paint_vec.x, context_raw.paint_vec.y, down ? 1.0 : 0.0, 0.0);
 
 		///if (is_paint || is_sculpt)
 		if (context_raw.paint2d) {
@@ -270,7 +270,7 @@ function uniforms_ext_vec4_link(object: object_t, mat: material_data_t, link: st
 	}
 	else if (link == "_input_brush_last") {
 		let down: bool = mouse_down() || pen_down();
-		let v: vec4_t = vec4_new(context_raw.last_paint_vec_x, context_raw.last_paint_vec_y, down ? 1.0 : 0.0, 0.0);
+		let v: vec4_t = vec4_create(context_raw.last_paint_vec_x, context_raw.last_paint_vec_y, down ? 1.0 : 0.0, 0.0);
 
 		///if (is_paint || is_sculpt)
 		if (context_raw.paint2d) {
@@ -281,14 +281,14 @@ function uniforms_ext_vec4_link(object: object_t, mat: material_data_t, link: st
 		return v;
 	}
 	else if (link == "_envmap_data") {
-		return vec4_new(context_raw.envmap_angle, math_sin(-context_raw.envmap_angle), math_cos(-context_raw.envmap_angle), scene_world.strength);
+		return vec4_create(context_raw.envmap_angle, math_sin(-context_raw.envmap_angle), math_cos(-context_raw.envmap_angle), scene_world.strength);
 	}
 	else if (link == "_envmap_data_world") {
-		return vec4_new(context_raw.envmap_angle, math_sin(-context_raw.envmap_angle), math_cos(-context_raw.envmap_angle), context_raw.show_envmap ? scene_world.strength : 1.0);
+		return vec4_create(context_raw.envmap_angle, math_sin(-context_raw.envmap_angle), math_cos(-context_raw.envmap_angle), context_raw.show_envmap ? scene_world.strength : 1.0);
 	}
 	///if (is_paint || is_sculpt)
 	else if (link == "_stencil_transform") {
-		let v: vec4_t = vec4_new(context_raw.brush_stencil_x, context_raw.brush_stencil_y, context_raw.brush_stencil_scale, context_raw.brush_stencil_angle);
+		let v: vec4_t = vec4_create(context_raw.brush_stencil_x, context_raw.brush_stencil_y, context_raw.brush_stencil_scale, context_raw.brush_stencil_angle);
 		if (context_raw.paint2d) {
 			v.x = vec2d(v.x);
 		}
@@ -299,7 +299,7 @@ function uniforms_ext_vec4_link(object: object_t, mat: material_data_t, link: st
 		let val: f32 = (context_raw.brush_radius * context_raw.brush_nodes_radius) / 15.0;
 		let scale2d: f32 = (900 / base_h()) * config_raw.window_scale;
 		val *= scale2d; // Projection ratio
-		let v: vec4_t = vec4_new(context_raw.decal_x, context_raw.decal_y, decal_mask ? 1 : 0, val);
+		let v: vec4_t = vec4_create(context_raw.decal_x, context_raw.decal_y, decal_mask ? 1 : 0, val);
 		if (context_raw.paint2d) {
 			v.x = vec2d(v.x);
 		}
@@ -313,7 +313,7 @@ function uniforms_ext_vec4_link(object: object_t, mat: material_data_t, link: st
 function uniforms_ext_mat4_link(object: object_t, mat: material_data_t, link: string): mat4_t {
 	///if (is_paint || is_sculpt)
 	if (link == "_decal_layer_matrix") { // Decal layer
-		let m: mat4_t = mat4_get_inv(context_raw.layer.decal_mat);
+		let m: mat4_t = mat4_inv(context_raw.layer.decal_mat);
 		m = mat4_mult_mat(m, uniforms_ext_ortho_p);
 		return m;
 	}

base/sources/util_mesh.ts

@@ -219,9 +219,9 @@ function util_mesh_calc_normals(smooth: bool = false) {
 			let i1: i32 = inda[i * 3    ];
 			let i2: i32 = inda[i * 3 + 1];
 			let i3: i32 = inda[i * 3 + 2];
-			va = vec4_new(buffer_get_i16(vertices, (i1 * l) * 2), buffer_get_i16(vertices, (i1 * l + 1) * 2), buffer_get_i16(vertices, (i1 * l + 2) * 2));
-			vb = vec4_new(buffer_get_i16(vertices, (i2 * l) * 2), buffer_get_i16(vertices, (i2 * l + 1) * 2), buffer_get_i16(vertices, (i2 * l + 2) * 2));
-			vc = vec4_new(buffer_get_i16(vertices, (i3 * l) * 2), buffer_get_i16(vertices, (i3 * l + 1) * 2), buffer_get_i16(vertices, (i3 * l + 2) * 2));
+			va = vec4_create(buffer_get_i16(vertices, (i1 * l) * 2), buffer_get_i16(vertices, (i1 * l + 1) * 2), buffer_get_i16(vertices, (i1 * l + 2) * 2));
+			vb = vec4_create(buffer_get_i16(vertices, (i2 * l) * 2), buffer_get_i16(vertices, (i2 * l + 1) * 2), buffer_get_i16(vertices, (i2 * l + 2) * 2));
+			vc = vec4_create(buffer_get_i16(vertices, (i3 * l) * 2), buffer_get_i16(vertices, (i3 * l + 1) * 2), buffer_get_i16(vertices, (i3 * l + 2) * 2));
 			cb = vec4_sub(vc, vb);
 			ab = vec4_sub(va, vb);
 			cb = vec4_cross(cb, ab);
@@ -264,7 +264,7 @@ function util_mesh_calc_normals(smooth: bool = false) {
 					}
 				}
 				if (shared_len > 1) {
-					va = vec4_new(0, 0, 0);
+					va = vec4_create(0, 0, 0);
 					for (let j: i32 = 0; j < shared_len; ++j) {
 						let i1: i32 = shared[j];
 						let i1l: i32 = i1 * l;
@@ -421,7 +421,7 @@ function util_mesh_equirect_unwrap(mesh: raw_mesh_t) {
 	mesh.texa = i16_array_create(verts * 2);
 	let n: vec4_t = vec4_create();
 	for (let i: i32 = 0; i < verts; ++i) {
-		n = vec4_new(mesh.posa[i * 4] / 32767, mesh.posa[i * 4 + 1] / 32767, mesh.posa[i * 4 + 2] / 32767);
+		n = vec4_create(mesh.posa[i * 4] / 32767, mesh.posa[i * 4 + 1] / 32767, mesh.posa[i * 4 + 2] / 32767);
 		n = vec4_norm(n);
 		// Sphere projection
 		// mesh.texa[i * 2    ] = math_atan2(n.x, n.y) / (math_pi() * 2) + 0.5;

base/sources/util_render.ts

@@ -87,7 +87,7 @@ function util_render_make_decal_preview() {
 	context_raw.decal_preview = true;
 
 	let plane: mesh_object_t = scene_get_child(".Plane").ext;
-	plane.base.transform.scale = vec4_new(1, 1, 1);
+	plane.base.transform.scale = vec4_create(1, 1, 1);
 	plane.base.transform.rot = quat_from_euler(-math_pi() / 2, 0, 0);
 	transform_build_matrix(plane.base.transform);
 	plane.base.visible = true;
@@ -270,18 +270,18 @@ function util_render_make_brush_preview() {
 	cam.data.fov = 0.92;
 	camera_object_build_proj(cam);
 	camera_object_build_mat(cam);
-	m = mat4_get_inv(scene_camera.vp);
+	m = mat4_inv(scene_camera.vp);
 
 	let planeo: mesh_object_t = scene_get_child(".Plane").ext;
 	planeo.base.visible = true;
 	context_raw.paint_object = planeo;
 
 	let v: vec4_t = vec4_create();
-	v = vec4_new(m.m00, m.m01, m.m02);
+	v = vec4_create(m.m00, m.m01, m.m02);
 	let sx: f32 = vec4_len(v);
 	planeo.base.transform.rot = quat_from_euler(-math_pi() / 2, 0, 0);
-	planeo.base.transform.scale = vec4_new(sx, 1.0, sx);
-	planeo.base.transform.loc = vec4_new(m.m30, -m.m31, 0.0);
+	planeo.base.transform.scale = vec4_create(sx, 1.0, sx);
+	planeo.base.transform.loc = vec4_create(m.m30, -m.m31, 0.0);
 	transform_build_matrix(planeo.base.transform);
 
 	render_path_paint_live_layer_drawn = 0;

base/sources/viewport.ts

@@ -8,12 +8,12 @@ function viewport_scale_to_bounds() {
 	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 = vec4_new(2 / r, 2 / r, 2 / r);
-	po.base.transform.loc = vec4_new(0, 0, 0);
+	po.base.transform.scale = vec4_create(2 / r, 2 / r, 2 / r);
+	po.base.transform.loc = vec4_create(0, 0, 0);
 	transform_build_matrix(po.base.transform);
 	for (let i: i32 = 0; i < po.base.children.length; ++i) {
 		let c: object_t = po.base.children[i];
-		c.transform.loc = vec4_new(0, 0, 0);
+		c.transform.loc = vec4_create(0, 0, 0);
 		transform_build_matrix(c.transform);
 	}
 }
@@ -40,11 +40,11 @@ function viewport_reset() {
 }
 
 function viewport_set_view(x: f32, y: f32, z: f32, rx: f32, ry: f32, rz: f32) {
-	context_raw.paint_object.base.transform.rot = quat_new(0, 0, 0, 1);
+	context_raw.paint_object.base.transform.rot = quat_create(0, 0, 0, 1);
 	context_raw.paint_object.base.transform.dirty = true;
 	let cam: camera_object_t = scene_camera;
 	let dist: f32 = vec4_len(cam.base.transform.loc);
-	cam.base.transform.loc = vec4_new(x * dist, y * dist, z * dist);
+	cam.base.transform.loc = vec4_create(x * dist, y * dist, z * dist);
 	cam.base.transform.rot = quat_from_euler(rx, ry, rz);
 	transform_build_matrix(cam.base.transform);
 	camera_object_build_proj(cam);