let scene_raw_gc: scene_t;

function import_arm_run_project(path: string) {
	let b: buffer_t = data_get_blob(path);
	let project: project_format_t;
	let import_as_mesh: bool = false;

	if (import_arm_is_legacy(b)) {
		project = import_arm_from_legacy(b);
	}
	else if (!import_arm_has_version(b)) {
		import_as_mesh = true;
		scene_raw_gc = armpack_decode(b);
		project = {
			mesh_datas: scene_raw_gc.mesh_datas
		};
	}
	else {
		project = armpack_decode(b);
	}

	///if (is_paint || is_sculpt)
	if (project.version != null && project.layer_datas == null) {
		// Import as material
		if (project.material_nodes != null) {
			import_arm_run_material_from_project(project, path);
		}
		// Import as brush
		else if (project.brush_nodes != null) {
			import_arm_run_brush_from_project(project, path);
		}
		// Import as swatches
		else if (project.swatches != null) {
			import_arm_run_swatches_from_project(project, path);
		}
		return;
	}
	context_raw.layers_preview_dirty = true;
	context_raw.layer_filter = 0;
	///end

	project_new(import_as_mesh);
	project_filepath = path;
	ui_files_filename = substring(path, string_last_index_of(path, path_sep) + 1, string_last_index_of(path, "."));
	///if (arm_android || arm_ios)
	sys_title_set(ui_files_filename);
	///else
	sys_title_set(ui_files_filename + " - " + manifest_title);
	///end

	///if (is_paint || is_sculpt)
	// Import as mesh instead
	if (import_as_mesh) {
		import_arm_run_mesh(project);
		return;
	}
	///end

	// Save to recent
	///if arm_ios
	let recent_path: string = substring(path, string_last_index_of(path, "/") + 1, path.length);
	///else
	let recent_path: string = path;
	///end
	///if arm_windows
	recent_path = string_replace_all(recent_path, "\\", "/");
	///end
	let recent: string[] = config_raw.recent_projects;
	array_remove(recent, recent_path);
	array_insert(recent, 0, recent_path);
	config_save();

	project_raw = project;

	///if (is_paint || is_sculpt)
	let l0: layer_data_t = project.layer_datas[0];
	base_res_handle.position = config_get_texture_res_pos(l0.res);
	let bits_pos: texture_bits_t = l0.bpp == 8 ? texture_bits_t.BITS8 : l0.bpp == 16 ? texture_bits_t.BITS16 : texture_bits_t.BITS32;
	base_bits_handle.position = bits_pos;
	let bytes_per_pixel: i32 = math_floor(l0.bpp / 8);
	let format: tex_format_t = l0.bpp == 8 ? tex_format_t.RGBA32 : l0.bpp == 16 ? tex_format_t.RGBA64 : tex_format_t.RGBA128;
	///end

	let base: string = path_base_dir(path);
	if (project_raw.envmap != null) {
		project_raw.envmap = data_is_abs(project_raw.envmap) ? project_raw.envmap : base + project_raw.envmap;
	}
	scene_world.strength = project_raw.envmap_strength;

	if (project_raw.camera_world != null) {
		scene_camera.base.transform.local = mat4_from_f32_array(project_raw.camera_world);
		transform_decompose(scene_camera.base.transform);
		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_create(origin[0], origin[1], origin[2]);
	}

	for (let i: i32 = 0; i < project.assets.length; ++i) {
		let file: string = project.assets[i];
		///if arm_windows
		file = string_replace_all(file, "/", "\\");
		///else
		file = string_replace_all(file, "\\", "/");
		///end
		// Convert image path from relative to absolute
		let abs: string = data_is_abs(file) ? file : base + file;
		if (project.packed_assets != null) {
			abs = path_normalize(abs);
			import_arm_unpack_asset(project, abs, file);
		}
		if (map_get(data_cached_images, abs) == null && !file_exists(abs)) {
			import_arm_make_pink(abs);
		}
		let hdr_as_envmap: bool = ends_with(abs, ".hdr") && project_raw.envmap == abs;
		import_texture_run(abs, hdr_as_envmap);
	}

	///if (is_paint || is_sculpt)
	if (project.font_assets != null) {
		for (let i: i32 = 0; i < project.font_assets.length; ++i) {
			let file: string = project.font_assets[i];
			///if arm_windows
			file = string_replace_all(file, "/", "\\");
			///else
			file = string_replace_all(file, "\\", "/");
			///end
			// Convert font path from relative to absolute
			let abs: string = data_is_abs(file) ? file : base + file;
			if (file_exists(abs)) {
				import_font_run(abs);
			}
		}
	}
	///end

	///if (is_paint || is_sculpt)
	let md: mesh_data_t = mesh_data_create(project.mesh_datas[0]);
	///end

	///if is_lab
	let md: mesh_data_t = mesh_data_create(project.mesh_data);
	///end

	mesh_object_set_data(context_raw.paint_object, md);
	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];

	///if (is_paint || is_sculpt)
	for (let i: i32 = 1; i < project.mesh_datas.length; ++i) {
		let raw: mesh_data_t = project.mesh_datas[i];
		let md: mesh_data_t = mesh_data_create(raw);
		let object: mesh_object_t = scene_add_mesh_object(md, context_raw.paint_object.materials, context_raw.paint_object.base);
		object.base.name = md.name;
		object.skip_context = "paint";
		array_push(project_paint_objects, object);
	}

	if (project.mesh_assets != null && project.mesh_assets.length > 0) {
		let file: string = project.mesh_assets[0];
		let abs: string = data_is_abs(file) ? file : base + file;
		project_mesh_assets = [abs];
	}

	///if is_paint
	if (project.atlas_objects != null) {
		project_atlas_objects = project.atlas_objects;
	}
	if (project.atlas_names != null) {
		project_atlas_names = project.atlas_names;
	}
	///end

	// No mask by default
	if (context_raw.merged_object == null) {
		util_mesh_merge();
	}
	///end

	context_select_paint_object(context_main_object());
	viewport_scale_to_bounds();
	context_raw.paint_object.skip_context = "paint";
	context_raw.merged_object.base.visible = true;

	///if (is_paint || is_sculpt)
	let tex: image_t = project_layers[0].texpaint;
	if (tex.width != config_get_texture_res_x() || tex.height != config_get_texture_res_y()) {
		if (history_undo_layers != null) {
			for (let i: i32 = 0; i < history_undo_layers.length; ++i) {
				let l: slot_layer_t = history_undo_layers[i];
				slot_layer_resize_and_set_bits(l);
			}
		}
		let rts: map_t<string, render_target_t> = render_path_render_targets;
		let blend0: render_target_t = map_get(rts, "texpaint_blend0");
		let _texpaint_blend0: image_t = blend0._image;
		app_notify_on_next_frame(function (_texpaint_blend0: image_t) {
			image_unload(_texpaint_blend0);
		}, _texpaint_blend0);
		blend0.width = config_get_texture_res_x();
		blend0.height = config_get_texture_res_y();
		blend0._image = image_create_render_target(config_get_texture_res_x(), config_get_texture_res_y(), tex_format_t.R8, 0);
		let blend1: render_target_t = map_get(rts, "texpaint_blend1");
		let _texpaint_blend1: image_t = blend1._image;
		app_notify_on_next_frame(function (_texpaint_blend1: image_t) {
			image_unload(_texpaint_blend1);
		}, _texpaint_blend1);
		blend1.width = config_get_texture_res_x();
		blend1.height = config_get_texture_res_y();
		blend1._image = image_create_render_target(config_get_texture_res_x(), config_get_texture_res_y(), tex_format_t.R8, 0);
		context_raw.brush_blend_dirty = true;
	}

	for (let i: i32 = 0; i < project_layers.length; ++i) {
		let l: slot_layer_t = project_layers[i];
		slot_layer_unload(l);
	}
	project_layers = [];
	for (let i: i32 = 0; i < project.layer_datas.length; ++i) {
		let ld: layer_data_t = project.layer_datas[i];
		let is_group: bool = ld.texpaint == null;

		///if is_paint
		let is_mask: bool = ld.texpaint != null && ld.texpaint_nor == null;
		///end
		///if is_sculpt
		let is_mask: bool = false;
		///end

		let l: slot_layer_t = slot_layer_create("", is_group ? layer_slot_type_t.GROUP : is_mask ? layer_slot_type_t.MASK : layer_slot_type_t.LAYER);
		if (ld.name != null) {
			l.name = ld.name;
		}
		l.visible = ld.visible;
		array_push(project_layers, l);

		if (!is_group) {
			let _texpaint: image_t = null;
			let _texpaint_nor: image_t = null;
			let _texpaint_pack: image_t = null;

			if (is_mask) {
				_texpaint = image_from_bytes(lz4_decode(ld.texpaint, ld.res * ld.res * 4), ld.res, ld.res, tex_format_t.RGBA32);
				g2_begin(l.texpaint);
				// draw_set_pipeline(pipes_copy8);
				draw_set_pipeline(project.is_bgra ? pipes_copy_bgra : pipes_copy); // Full bits for undo support, R8 is used
				draw_image(_texpaint, 0, 0);
				draw_set_pipeline(null);
				g2_end();
			}
			else { // Layer
				// TODO: create render target from bytes
				_texpaint = image_from_bytes(lz4_decode(ld.texpaint, ld.res * ld.res * 4 * bytes_per_pixel), ld.res, ld.res, format);
				g2_begin(l.texpaint);
				draw_set_pipeline(project.is_bgra ? pipes_copy_bgra : pipes_copy);
				draw_image(_texpaint, 0, 0);
				draw_set_pipeline(null);
				g2_end();

				///if is_paint
				_texpaint_nor = image_from_bytes(lz4_decode(ld.texpaint_nor, ld.res * ld.res * 4 * bytes_per_pixel), ld.res, ld.res, format);
				g2_begin(l.texpaint_nor);
				draw_set_pipeline(project.is_bgra ? pipes_copy_bgra : pipes_copy);
				draw_image(_texpaint_nor, 0, 0);
				draw_set_pipeline(null);
				g2_end();

				_texpaint_pack = image_from_bytes(lz4_decode(ld.texpaint_pack, ld.res * ld.res * 4 * bytes_per_pixel), ld.res, ld.res, format);
				g2_begin(l.texpaint_pack);
				draw_set_pipeline(project.is_bgra ? pipes_copy_bgra : pipes_copy);
				draw_image(_texpaint_pack, 0, 0);
				draw_set_pipeline(null);
				g2_end();
				///end
			}

			l.scale = ld.uv_scale;
			l.angle = ld.uv_rot;
			l.uv_type = ld.uv_type;
			if (ld.decal_mat != null) {
				l.decal_mat = mat4_from_f32_array(ld.decal_mat);
			}
			l.mask_opacity = ld.opacity_mask;
			l.object_mask = ld.object_mask;
			l.blending = ld.blending;

			///if is_paint
			l.paint_base = ld.paint_base;
			l.paint_opac = ld.paint_opac;
			l.paint_occ = ld.paint_occ;
			l.paint_rough = ld.paint_rough;
			l.paint_met = ld.paint_met;
			l.paint_nor = ld.paint_nor;
			l.paint_nor_blend = ld.paint_nor_blend;
			l.paint_height = ld.paint_height;
			l.paint_height_blend = ld.paint_height_blend;
			l.paint_emis = ld.paint_emis;
			l.paint_subs = ld.paint_subs;
			///end

			app_notify_on_next_frame(function (_texpaint: image_t) {
				image_unload(_texpaint);
			}, _texpaint);

			///if is_paint
			if (_texpaint_nor != null) {
				app_notify_on_next_frame(function (_texpaint_nor: image_t) {
					image_unload(_texpaint_nor);
				}, _texpaint_nor);
			}
			if (_texpaint_pack != null) {
				app_notify_on_next_frame(function (_texpaint_pack: image_t) {
					image_unload(_texpaint_pack);
				}, _texpaint_pack);
			}
			///end
		}
	}

	// Assign parents to groups and masks
	for (let i: i32 = 0; i < project.layer_datas.length; ++i) {
		let ld: layer_data_t = project.layer_datas[i];
		if (ld.parent >= 0) {
			project_layers[i].parent = project_layers[ld.parent];
		}
	}

	context_set_layer(project_layers[0]);

	// Materials
	let m0: material_data_t = data_get_material("Scene", "Material");

	project_materials = [];
	for (let i: i32 = 0; i < project.material_nodes.length; ++i) {
		let n: ui_node_canvas_t = project.material_nodes[i];
		import_arm_init_nodes(n.nodes);
		context_raw.material = slot_material_create(m0, n);
		array_push(project_materials, context_raw.material);
	}
	///end

	ui_nodes_hwnd.redraws = 2;
	ui_nodes_group_stack = [];
	project_material_groups = [];
	if (project.material_groups != null) {
		for (let i: i32 = 0; i < project.material_groups.length; ++i) {
			let g: ui_node_canvas_t = project.material_groups[i];
			let ng: node_group_t = {
				canvas: g,
				nodes: ui_nodes_create()
			};
			array_push(project_material_groups, ng);
		}
	}

	///if (is_paint || is_sculpt)
	for (let i: i32 = 0; i < project_materials.length; ++i) {
		let m: slot_material_t = project_materials[i];
		context_raw.material = m;
		make_material_parse_paint_material();
		util_render_make_material_preview();
	}

	project_brushes = [];
	for (let i: i32 = 0; i < project.brush_nodes.length; ++i) {
		let n: ui_node_canvas_t = project.brush_nodes[i];
		import_arm_init_nodes(n.nodes);
		context_raw.brush = slot_brush_create(n);
		array_push(project_brushes, context_raw.brush);
		make_material_parse_brush();
		util_render_make_brush_preview();
	}

	// Fill layers
	for (let i: i32 = 0; i < project.layer_datas.length; ++i) {
		let ld: layer_data_t = project.layer_datas[i];
		let l: slot_layer_t = project_layers[i];
		let is_group: bool = ld.texpaint == null;
		if (!is_group) {
			l.fill_layer = ld.fill_layer > -1 ? project_materials[ld.fill_layer] : null;
		}
	}

	ui_base_hwnds[tab_area_t.SIDEBAR0].redraws = 2;
	ui_base_hwnds[tab_area_t.SIDEBAR1].redraws = 2;
	///end

	///if is_lab
	import_arm_init_nodes(project.material.nodes);
	project_canvas = project.material;
	parser_logic_parse(project_canvas);
	///end

	context_raw.ddirty = 4;
	data_delete_blob(path);
}

function import_arm_run_mesh(raw: project_format_t) {
	project_paint_objects = [];
	for (let i: i32 = 0; i < raw.mesh_datas.length; ++i) {
		let md: mesh_data_t = mesh_data_create(raw.mesh_datas[i]);
		let object: mesh_object_t = null;
		if (i == 0) {
			mesh_object_set_data(context_raw.paint_object, md);
			object = context_raw.paint_object;
		}
		else {
			object = scene_add_mesh_object(md, context_raw.paint_object.materials, context_raw.paint_object.base);
			object.base.name = md.name;
			object.skip_context = "paint";
			md._.handle = md.name;
			map_set(data_cached_meshes, md._.handle, md);
		}
		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);
		util_mesh_merge();
		viewport_scale_to_bounds();
	}
	app_notify_on_init(layers_init);
	history_reset();
}

function import_arm_run_material(path: string) {
	let b: buffer_t = data_get_blob(path);
	let project: project_format_t;
	if (import_arm_is_legacy(b)) {
		project = import_arm_from_legacy(b);
	}
	else {
		project = armpack_decode(b);
	}

	if (project.version == null) {
		data_delete_blob(path);
		return;
	}
	import_arm_run_material_from_project(project, path);
}

function import_arm_run_material_from_project(project: project_format_t, path: string) {
	let base: string = path_base_dir(path);
	for (let i: i32 = 0; i < project.assets.length; ++i) {
		let file: string = project.assets[i];
		///if arm_windows
		file = string_replace_all(file, "/", "\\");
		///else
		file = string_replace_all(file, "\\", "/");
		///end
		// Convert image path from relative to absolute
		let abs: string = data_is_abs(file) ? file : base + file;
		if (project.packed_assets != null) {
			abs = path_normalize(abs);
			import_arm_unpack_asset(project, abs, file);
		}
		if (map_get(data_cached_images, abs) == null && !file_exists(abs)) {
			import_arm_make_pink(abs);
		}
		import_texture_run(abs);
	}

	let m0: material_data_t = data_get_material("Scene", "Material");

	let imported: slot_material_t[] = [];

	for (let i: i32 = 0; i < project.material_nodes.length; ++i) {
		let c: ui_node_canvas_t = util_clone_canvas(project.material_nodes[i]); // project will get GCed
		import_arm_init_nodes(c.nodes);
		context_raw.material = slot_material_create(m0, c);
		array_push(project_materials, context_raw.material);
		array_push(imported, context_raw.material);
		history_new_material();
	}

	if (project.material_groups != null) {
		for (let i: i32 = 0; i < project.material_groups.length; ++i) {
			project.material_groups[i] = util_clone_canvas(project.material_groups[i]);
		}
		for (let i: i32 = 0; i < project.material_groups.length; ++i) {
			let c: ui_node_canvas_t = project.material_groups[i];
			while (import_arm_group_exists(c)) {
				import_arm_rename_group(c.name, imported, project.material_groups); // Ensure unique group name
			}
			import_arm_init_nodes(c.nodes);
			let ng: node_group_t = {
				canvas: c,
				nodes: ui_nodes_create()
			};
			array_push(project_material_groups, ng);
		}
	}

	app_notify_on_init(function (imported: slot_material_t[]) {
		for (let i: i32 = 0; i < imported.length; ++i) {
			let m: slot_material_t = imported[i];
			context_set_material(m);
			make_material_parse_paint_material();
			util_render_make_material_preview();
		}
	}, imported);

	ui_nodes_group_stack = [];
	ui_base_hwnds[tab_area_t.SIDEBAR1].redraws = 2;
	data_delete_blob(path);
}

function import_arm_group_exists(c: ui_node_canvas_t): bool {
	for (let i: i32 = 0; i < project_material_groups.length; ++i) {
		let g: node_group_t = project_material_groups[i];
		let cname: string = g.canvas.name;
		if (cname == c.name) {
			return true;
		}
	}
	return false;
}

function import_arm_rename_group(name: string, materials: slot_material_t[], groups: ui_node_canvas_t[]) {
	for (let i: i32 = 0; i < materials.length; ++i) {
		let m: slot_material_t = materials[i];
		for (let i: i32 = 0; i < m.canvas.nodes.length; ++i) {
			let n: ui_node_t = m.canvas.nodes[i];
			if (n.type == "GROUP" && n.name == name) {
				n.name += ".1";
			}
		}
	}
	for (let i: i32 = 0; i < groups.length; ++i) {
		let c: ui_node_canvas_t = groups[i];
		if (c.name == name) {
			c.name += ".1";
		}
		for (let i: i32 = 0; i < c.nodes.length; ++i) {
			let n: ui_node_t = c.nodes[i];
			if (n.type == "GROUP" && n.name == name) {
				n.name += ".1";
			}
		}
	}
}

function import_arm_run_brush(path: string) {
	let b: buffer_t = data_get_blob(path);
	let project: project_format_t = armpack_decode(b);
	if (project.version == null) {
		data_delete_blob(path);
		return;
	}
	import_arm_run_brush_from_project(project, path);
}

function import_arm_run_brush_from_project(project: project_format_t, path: string) {
	let base: string = path_base_dir(path);
	for (let i: i32 = 0; i < project.assets.length; ++i) {
		let file: string = project.assets[i];
		///if arm_windows
		file = string_replace_all(file, "/", "\\");
		///else
		file = string_replace_all(file, "\\", "/");
		///end
		// Convert image path from relative to absolute
		let abs: string = data_is_abs(file) ? file : base + file;
		if (project.packed_assets != null) {
			abs = path_normalize(abs);
			import_arm_unpack_asset(project, abs, file);
		}
		if (map_get(data_cached_images, abs) == null && !file_exists(abs)) {
			import_arm_make_pink(abs);
		}
		import_texture_run(abs);
	}

	let imported: slot_brush_t[] = [];

	for (let i: i32 = 0; i < project.brush_nodes.length; ++i) {
		let c: ui_node_canvas_t = util_clone_canvas(project.brush_nodes[i]);
		import_arm_init_nodes(c.nodes);
		context_raw.brush = slot_brush_create(c);
		array_push(project_brushes, context_raw.brush);
		array_push(imported, context_raw.brush);
	}

	app_notify_on_init(function (imported: slot_brush_t[]) {
		for (let i: i32 = 0; i < imported.length; ++i) {
			let b: slot_brush_t = imported[i];
			context_set_brush(b);
			make_material_parse_brush();
			util_render_make_brush_preview();
		}
	}, imported);

	ui_base_hwnds[tab_area_t.SIDEBAR1].redraws = 2;
	data_delete_blob(path);
}

function import_arm_run_swatches(path: string, replace_existing: bool = false) {
	let b: buffer_t = data_get_blob(path);
	let project: project_format_t = armpack_decode(b);
	if (project.version == null) {
		data_delete_blob(path);
		return;
	}
	import_arm_run_swatches_from_project(project, path, replace_existing);
}

function import_arm_run_swatches_from_project(project: project_format_t, path: string, replace_existing: bool = false) {
	if (replace_existing) {
		project_raw.swatches = [];

		if (project.swatches == null) { // No swatches contained
			array_push(project_raw.swatches, make_swatch());
		}
	}

	if (project.swatches != null) {
		for (let i: i32 = 0; i < project.swatches.length; ++i) {
			let s: swatch_color_t = util_clone_swatch_color(project.swatches[i]);
			array_push(project_raw.swatches, s);
		}
	}
	ui_base_hwnds[tab_area_t.STATUS].redraws = 2;
	data_delete_blob(path);
}

function import_arm_make_pink(abs: string) {
	console_error(strings_could_not_locate_texture() + " " + abs);
	let b: u8_array_t = u8_array_create(4);
	b[0] = 255;
	b[1] = 0;
	b[2] = 255;
	b[3] = 255;
	let pink: image_t = image_from_bytes(b, 1, 1);
	map_set(data_cached_images, abs, pink);
}

function import_arm_texture_node_name(): string {
	///if (is_paint || is_sculpt)
	return "TEX_IMAGE";
	///else
	return "image_texture_node";
	///end
}

function import_arm_init_nodes(nodes: ui_node_t[]) {
	for (let i: i32 = 0; i < nodes.length; ++i) {
		let node: ui_node_t = nodes[i];
		if (node.type == import_arm_texture_node_name()) {
			node.buttons[0].default_value = f32_array_create_x(base_get_asset_index(u8_array_to_string(node.buttons[0].data)));
			node.buttons[0].data = u8_array_create_from_string("");
		}
	}
}

function import_arm_unpack_asset(project: project_format_t, abs: string, file: string) {
	if (project_raw.packed_assets == null) {
		project_raw.packed_assets = [];
	}
	for (let i: i32 = 0; i < project.packed_assets.length; ++i) {
		let pa: packed_asset_t = project.packed_assets[i];
		///if arm_windows
		pa.name = string_replace_all(pa.name, "/", "\\");
		///else
		pa.name = string_replace_all(pa.name, "\\", "/");
		///end
		pa.name = path_normalize(pa.name);
		if (pa.name == file) {
			pa.name = abs; // From relative to absolute
		}
		if (pa.name == abs) {
			if (!project_packed_asset_exists(project_raw.packed_assets, pa.name)) {
				array_push(project_raw.packed_assets, pa);
			}
			let image: image_t = image_from_encoded_bytes(pa.bytes, ends_with(pa.name, ".jpg") ? ".jpg" : ".png");
			map_set(data_cached_images, abs, image);
			break;
		}
	}
}

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 = 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 = armpack_map_get_i32(old, "color");
		if (s.type == "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 = 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 = armpack_map_get_f32(dv, "3");
				s.default_value = f32_array_create_xyzw(x, y, z, w);
			}
		}
		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 = armpack_map_get_f32(old, "precision");
		if (s.precision == 0.0) {
			s.precision = 100.0;
		}
		s.display = armpack_map_get_i32(old, "display");
		array_push(sockets, s);
	}
	return sockets;
}

function _import_arm_get_node_canvas_array(map: map_t<string, any>, key: string): ui_node_canvas_t[] {
	let cas: any[] = map_get(map, key);
	if (cas == null) {
		return null;
	}
	let ar: ui_node_canvas_t[] = [];
	for (let i: i32 = 0; i < cas.length; ++i) {
		let old: map_t<string, any> = cas[i];
		let c: ui_node_canvas_t = {};
		c.name = map_get(old, "name");

		c.nodes = [];
		let nas: any[] = map_get(old, "nodes");
		for (let i: i32 = 0; i < nas.length; ++i) {
			let old: map_t<string, any> = nas[i];
			let n: ui_node_t = {};

			n.id = armpack_map_get_i32(old, "id");
			n.name = map_get(old, "name");
			n.type = map_get(old, "type");
			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");

			n.buttons = [];
			let bas: any[] = map_get(old, "buttons");
			for (let i: i32 = 0; i < bas.length; ++i) {
				let old: map_t<string, any> = bas[i];
				let b: ui_node_button_t = {};
				b.name = map_get(old, "name");
				b.type = map_get(old, "type");
				b.output = armpack_map_get_i32(old, "output");

				if (b.type == "ENUM") {
					let x: f32 = armpack_map_get_i32(old, "default_value");
					b.default_value = f32_array_create_x(x);

					if (b.name == "File") {
						let data_string: string = map_get(old, "data");
						b.data = sys_string_to_buffer(data_string);
					}
					else {
						let data_strings: string[] = map_get(old, "data");
						let joined: string = string_array_join(data_strings, "\n");
						b.data = sys_string_to_buffer(joined);
					}
				}
				else if (b.type == "BOOL") {
					let x: f32 = armpack_map_get_i32(old, "default_value");
					b.default_value = f32_array_create_x(x);
				}
				else if (b.type == "CUSTOM") {
					if (b.name == "arm.shader.NodesMaterial.newGroupButton") {
						b.name = "nodes_material_new_group_button";
					}
					else if (b.name == "arm.shader.NodesMaterial.groupOutputButton") {
						b.name = "nodes_material_group_output_button";
					}
					else if (b.name == "arm.shader.NodesMaterial.groupInputButton") {
						b.name = "nodes_material_group_input_button";
					}
					else if (b.name == "arm.shader.NodesMaterial.vectorCurvesButton") {
						b.name = "nodes_material_vector_curves_button";
					}
					else if (b.name == "arm.shader.NodesMaterial.colorRampButton") {
						b.name = "nodes_material_color_ramp_button";
					}
				}

				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 = armpack_map_get_f32(old, "width");

			array_push(c.nodes, n);
		}

		c.links = [];
		let las: any[] = map_get(old, "links");
		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 = 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);
		}

		array_push(ar, c);
	}
	return ar;
}

function import_arm_has_version(b: buffer_t): bool {
	let has_version: bool = b[10] == 118; // 'v';
	return has_version;
}

function import_arm_is_legacy(b: buffer_t): bool {
	// Cloud materials are at version 0.8 / 0.9
	let has_version: bool = b[10] == 118; // 'v'
	let has_zero: bool = b[22] == 48; // '0'
	let has_dot: bool = b[23] == 46; // '.'
	let has_eight: bool = b[24] == 56; // '8'
	let has_nine: bool = b[24] == 57; // '9'
	if (has_version && has_zero && has_dot && (has_eight || has_nine)) {
		return true;
	}
	return false;
}

function import_arm_from_legacy(b: buffer_t): project_format_t {
	// Deprecated
	let old: map_t<string, any> = armpack_decode_to_map(b);
	let project: project_format_t = {};
	project.version = "1.0 alpha";
	project.assets = map_get(old, "assets");
	if (project.assets == null) {
		project.assets = [];
	}
	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 = [];
		for (let i: i32 = 0; i < pas.length; ++i) {
			let old: map_t<string, any> = pas[i];
			let pa: packed_asset_t = {};
			pa.name = map_get(old, "name");
			pa.bytes = map_get(old, "bytes");
			array_push(project.packed_assets, pa);
		}
	}
	project.brush_nodes = _import_arm_get_node_canvas_array(old, "brush_nodes");
	project.brush_icons = map_get(old, "brush_icons");
	project.material_nodes = _import_arm_get_node_canvas_array(old, "material_nodes");
	project.material_groups = _import_arm_get_node_canvas_array(old, "material_groups");
	project.material_icons = map_get(old, "material_icons");
	return project;
}