vanta-engine 1.0.1 → 1.0.3

package/dist/graphics/assets/asset_loaders/obj.js

@@ -1,762 +0,0 @@
-import { Vec3 } from "@vicimpa/glm";
-import { Texture, TextureType } from "../texture.js";
-import { Model } from "../model.js";
-import { Material } from "../material.js";
-import { Mesh } from "../mesh.js";
-import { Node3D } from "../../../node.js";
-import { Object3D } from "../../../node/object3d.js";
-import { parse_path, join_path, basename_path, dirname_path } from "../../utility.js";
-export var AssetFile;
-(function (AssetFile) {
-    let OBJ;
-    (function (OBJ) {
-        let BumpChannel;
-        (function (BumpChannel) {
-            BumpChannel["RED"] = "r";
-            BumpChannel["GREEN"] = "g";
-            BumpChannel["BLUE"] = "b";
-            BumpChannel["MATTE"] = "m";
-            BumpChannel["LUMINANCE"] = "l";
-            BumpChannel["Z_DEPTH"] = "z";
-        })(BumpChannel = OBJ.BumpChannel || (OBJ.BumpChannel = {}));
-        let ReflectionMapType;
-        (function (ReflectionMapType) {
-            ReflectionMapType["SPHERE"] = "sphere";
-            ReflectionMapType["CUBE_TOP"] = "cube_top";
-            ReflectionMapType["CUBE_BOTTOM"] = "cube_bottom";
-            ReflectionMapType["CUBE_FRONT"] = "cube_front";
-            ReflectionMapType["CUBE_BACK"] = "cube_back";
-            ReflectionMapType["CUBE_LEFT"] = "cube_left";
-            ReflectionMapType["CUBE_RIGHT"] = "cube_right";
-        })(ReflectionMapType = OBJ.ReflectionMapType || (OBJ.ReflectionMapType = {}));
-        let IlluminationModel;
-        (function (IlluminationModel) {
-            IlluminationModel[IlluminationModel["COLOR_ON_AMBIENT_OFF"] = 0] = "COLOR_ON_AMBIENT_OFF";
-            IlluminationModel[IlluminationModel["COLOR_ON_AMBIENT_ON"] = 1] = "COLOR_ON_AMBIENT_ON";
-            IlluminationModel[IlluminationModel["HIGHLIGHT_ON"] = 2] = "HIGHLIGHT_ON";
-            IlluminationModel[IlluminationModel["REFLECTION_ON_RAY_TRACE_ON"] = 3] = "REFLECTION_ON_RAY_TRACE_ON";
-            IlluminationModel[IlluminationModel["TRANSPARENCY_GLASS_ON__REFLECTION_RAY_TRACE_ON"] = 4] = "TRANSPARENCY_GLASS_ON__REFLECTION_RAY_TRACE_ON";
-            IlluminationModel[IlluminationModel["REFLECTION_FRESNEL_ON_RAY_TRACE_ON"] = 5] = "REFLECTION_FRESNEL_ON_RAY_TRACE_ON";
-            IlluminationModel[IlluminationModel["TRANSPARENCY_REFRACTION_ON__REFLECTION_FRESNEL_OFF_RAY_TRACE_ON"] = 6] = "TRANSPARENCY_REFRACTION_ON__REFLECTION_FRESNEL_OFF_RAY_TRACE_ON";
-            IlluminationModel[IlluminationModel["TRANSPARENCY_REFRACTION_ON__REFLECTION_FRESNEL_ON_RAY_TRACE_ON"] = 7] = "TRANSPARENCY_REFRACTION_ON__REFLECTION_FRESNEL_ON_RAY_TRACE_ON";
-            IlluminationModel[IlluminationModel["REFLECTION_ON_RAY_TRACE_OFF"] = 8] = "REFLECTION_ON_RAY_TRACE_OFF";
-            IlluminationModel[IlluminationModel["TRANSPARENCY_GLASS_ON__REFLECTION_RAY_TRACE_OFF"] = 9] = "TRANSPARENCY_GLASS_ON__REFLECTION_RAY_TRACE_OFF";
-            IlluminationModel[IlluminationModel["CAST_SHADOWS_ON_INVISIBLE_SURFACES"] = 10] = "CAST_SHADOWS_ON_INVISIBLE_SURFACES";
-        })(IlluminationModel = OBJ.IlluminationModel || (OBJ.IlluminationModel = {}));
-        let CollectionType;
-        (function (CollectionType) {
-            CollectionType[CollectionType["OBJECT"] = 0] = "OBJECT";
-            CollectionType[CollectionType["GROUP"] = 1] = "GROUP";
-        })(CollectionType || (CollectionType = {}));
-        function create_material(engine, material_data, image_assets_path, image_assets) {
-            const get_fallback = (...fallbacks) => {
-                for (const fallback of fallbacks) {
-                    if (fallback !== undefined)
-                        return fallback;
-                }
-                throw new Error("A valid defined fallback was not supplied.");
-            };
-            return new Material(engine.graphics_manager, material_data.name, get_fallback(material_data.diffuse_texture?.name ?
-                image_assets.get(material_data.diffuse_texture?.name)
-                : undefined, material_data.diffuse_color, new Vec3(1.0)), get_fallback(material_data.metalic_texture?.name ?
-                image_assets.get(material_data.metalic_texture?.name)
-                : undefined, material_data.metalic, 0.0), get_fallback(material_data.roughness_texture?.name ?
-                image_assets.get(material_data.roughness_texture?.name)
-                : undefined, material_data.roughness, 0.0), get_fallback(material_data.ambient_texture?.name ?
-                image_assets.get(material_data.ambient_texture?.name)
-                : undefined, 0.0), get_fallback(material_data.normal_texture?.name ?
-                image_assets.get(material_data.normal_texture?.name)
-                : undefined, null), engine.graphics_manager.default_3d_shader_program);
-        }
-        async function load_obj(engine, obj_path, image_assets_path) {
-            const obj_name = parse_path(obj_path).name;
-            var image_assets = new Map();
-            var material_assets = new Map();
-            var obj_root_node = new Node3D(engine, obj_name + "_root");
-            // Load File
-            const res = await fetch(obj_path);
-            if (res.ok) {
-                const raw_text = await res.text();
-                const [objects, materials] = await Parser.parse_obj(engine, obj_path, raw_text, image_assets_path, image_assets);
-                // parse materials
-                for (const material_data of materials) {
-                    const material = create_material(engine, material_data, image_assets_path, image_assets);
-                    material_assets.set(material.name, material);
-                }
-                for (const object_data of objects) {
-                    var object;
-                    if (object_data.data) {
-                        const data = object_data.data;
-                        const mesh = new Mesh(engine.graphics_manager, data.vertices, data.normals, data.uvs, data.indices, data.dimensions, data.center);
-                        var material;
-                        if (object_data.material) {
-                            material = material_assets.get(object_data.material);
-                            if (material === undefined) {
-                                throw new Error(`Failed to find the material named "${object_data.material}" associated with the object named "${object_data.name}" in the .obj file at "${obj_path}" when attempting to load the obj model.`);
-                            }
-                        }
-                        else {
-                            material = new Material(engine.graphics_manager, "default", new Vec3(0.0), 0.0, 0.0, 0.0, null, engine.graphics_manager.default_3d_shader_program);
-                        }
-                        var model = new Model(engine.graphics_manager, "default", mesh, material);
-                        object = new Object3D(engine, object_data.name, model);
-                    }
-                    else {
-                        object = new Node3D(engine, object_data.name);
-                    }
-                    // add groups as children of object
-                    for (const group_data of object_data.groups) {
-                        const data = group_data.data;
-                        const mesh = new Mesh(engine.graphics_manager, data.vertices, data.normals, data.uvs, data.indices, data.dimensions, data.center);
-                        var material;
-                        if (group_data.material) {
-                            material = material_assets.get(group_data.material);
-                            if (material === undefined) {
-                                throw new Error(`Failed to find the material named "${group_data.material}" associated with the group named "${group_data.name}" object named "${object_data.name}" in the .obj file at "${obj_path}" when attempting to load the obj model.`);
-                            }
-                        }
-                        else {
-                            material = new Material(engine.graphics_manager, "default", new Vec3(0.0), 0.0, 0.0, 0.0, null, engine.graphics_manager.default_3d_shader_program);
-                        }
-                        var model = new Model(engine.graphics_manager, "default", mesh, material);
-                        object.push_child(new Object3D(engine, group_data.name, model));
-                    }
-                    // add object to root
-                    obj_root_node.push_child(object);
-                }
-            }
-            else {
-                throw new Error(`The .obj file at "${obj_path}" does not exist.`);
-            }
-            return obj_root_node;
-        }
-        OBJ.load_obj = load_obj;
-        class Parser {
-            static create_group(name) {
-                return {
-                    name,
-                    data: Parser.create_data()
-                };
-            }
-            static create_object(name) {
-                return {
-                    name,
-                    groups: []
-                };
-            }
-            static create_data() {
-                return {
-                    temp: {
-                        min_x: Number.MAX_VALUE,
-                        min_y: Number.MAX_VALUE,
-                        min_z: Number.MAX_VALUE,
-                        max_x: Number.MIN_VALUE,
-                        max_y: Number.MIN_VALUE,
-                        max_z: Number.MIN_VALUE,
-                        vertices: [],
-                        normals: [],
-                        uvs: [],
-                        vertex_map: new Map(),
-                        vertices_final: [],
-                        normals_final: [],
-                        uvs_final: [],
-                        indices_final: []
-                    },
-                    vertices: new Float32Array([]),
-                    normals: new Float32Array([]),
-                    uvs: new Float32Array([]),
-                    indices: new Uint16Array([]),
-                    dimensions: new Vec3(0.0),
-                    center: new Vec3(0.0)
-                };
-            }
-            static create_material(name) {
-                return { name };
-            }
-            static async load_mtl(engine, file_url, image_assets_path, image_assets) {
-                const res = await fetch(file_url);
-                if (res.ok) {
-                    const raw_text = await res.text();
-                    const mtls = await Parser.parse_mtl(engine, file_url, raw_text, image_assets_path, image_assets);
-                    return mtls;
-                }
-                else {
-                    throw new Error(`The .mtl file at "${file_url}" does not exist.`);
-                }
-            }
-            static async parse_mtl(engine, file_url, text, image_assets_path, image_assets) {
-                var material_list = [];
-                var current_material = null;
-                const lines = text.split("\n");
-                for (const line of lines) {
-                    const parts = line.trim().split(/\s+/);
-                    switch (parts[0].toLowerCase()) {
-                        case "newmtl":
-                            current_material = Parser.create_material(parts[1]);
-                            material_list.push(current_material);
-                            break;
-                        case "illum":
-                            if (current_material) {
-                                current_material.illumination_model = Number(parts[1]);
-                            }
-                            break;
-                        case "kd":
-                            if (current_material) {
-                                const [r, g, b] = parts.slice(1).map(Number);
-                                current_material.diffuse_color = new Vec3(r, g, b);
-                            }
-                            break;
-                        case "ka":
-                            if (current_material) {
-                                const [r, g, b] = parts.slice(1).map(Number);
-                                current_material.ambient_color = new Vec3(r, g, b);
-                            }
-                            break;
-                        case "ks":
-                            if (current_material) {
-                                const [r, g, b] = parts.slice(1).map(Number);
-                                current_material.specular_color = new Vec3(r, g, b);
-                            }
-                            break;
-                        case "ns":
-                            if (current_material) {
-                                current_material.specular_exponent = Number(parts[1]);
-                            }
-                            break;
-                        case "d":
-                            if (current_material) {
-                                current_material.transparency = Number(parts[1]);
-                            }
-                            break;
-                        case "tr":
-                            if (current_material) {
-                                current_material.transparency = 1.0 - Number(parts[1]);
-                            }
-                            break;
-                        case "ni":
-                            if (current_material) {
-                                current_material.optical_density = Number(parts[1]);
-                            }
-                            break;
-                        case "pr":
-                            if (current_material) {
-                                current_material.roughness = Number(parts[1]);
-                            }
-                            break;
-                        case "pm":
-                            if (current_material) {
-                                current_material.metalic = Number(parts[1]);
-                            }
-                            break;
-                        case "ps":
-                            if (current_material) {
-                                current_material.sheen = Number(parts[1]);
-                            }
-                            break;
-                        case "pc":
-                            if (current_material) {
-                                current_material.clearcoat_thickness = Number(parts[1]);
-                            }
-                            break;
-                        case "pcr":
-                            if (current_material) {
-                                current_material.clearcoat_roughness = Number(parts[1]);
-                            }
-                            break;
-                        case "ke":
-                            if (current_material) {
-                                current_material.emissive = Number(parts[1]);
-                            }
-                            break;
-                        case "aniso":
-                            if (current_material) {
-                                current_material.anisotropy = Number(parts[1]);
-                            }
-                            break;
-                        case "anisor":
-                            if (current_material) {
-                                current_material.anisotropy_rotation = Number(parts[1]);
-                            }
-                            break;
-                        case "tf":
-                            if (current_material) {
-                                if (parts[1].includes("x", 0)) {
-                                    const x = Number(parts[2]);
-                                    var y = null;
-                                    var z = null;
-                                    if (parts.length >= 4)
-                                        y = Number(parts[3]);
-                                    if (parts.length >= 5)
-                                        z = Number(parts[4]);
-                                    current_material.transmission_filter_color = new Vec3(x, y !== null ? y : x, z !== null ? z : x);
-                                    current_material.transmission_filter_xyz;
-                                }
-                                else {
-                                    const [r, g, b] = parts.slice(1).map(Number);
-                                    current_material.transmission_filter_color = new Vec3(r, g, b);
-                                }
-                            }
-                            break;
-                        // TEXTURE MAPS
-                        case "map_ka":
-                            if (current_material)
-                                current_material.ambient_texture = await Parser.parse_mtl_map(engine, current_material, [...parts], image_assets_path, image_assets);
-                            break;
-                        case "map_kd":
-                            if (current_material)
-                                current_material.diffuse_texture = await Parser.parse_mtl_map(engine, current_material, [...parts], image_assets_path, image_assets);
-                            break;
-                        case "map_ks":
-                            if (current_material)
-                                current_material.specular_color_texture = await Parser.parse_mtl_map(engine, current_material, [...parts], image_assets_path, image_assets);
-                            break;
-                        case "map_ns":
-                            if (current_material)
-                                current_material.specular_highlight_texture = await Parser.parse_mtl_map(engine, current_material, [...parts], image_assets_path, image_assets);
-                            break;
-                        case "map_d":
-                            if (current_material)
-                                current_material.alpha_texture = await Parser.parse_mtl_map(engine, current_material, [...parts], image_assets_path, image_assets);
-                            break;
-                        case "refl":
-                            if (current_material)
-                                if (current_material.reflection_textures === undefined)
-                                    current_material.reflection_textures = [await Parser.parse_mtl_map(engine, current_material, [...parts], image_assets_path, image_assets)];
-                                else
-                                    current_material.reflection_textures.push(await Parser.parse_mtl_map(engine, current_material, [...parts], image_assets_path, image_assets));
-                            break;
-                        case "map_bump":
-                            if (current_material)
-                                current_material.bump_texture = await Parser.parse_mtl_map(engine, current_material, [...parts], image_assets_path, image_assets);
-                            break;
-                        case "bump":
-                            if (current_material)
-                                current_material.bump_texture = await Parser.parse_mtl_map(engine, current_material, [...parts], image_assets_path, image_assets);
-                            break;
-                        case "disp":
-                            if (current_material)
-                                current_material.displacement_texture = await Parser.parse_mtl_map(engine, current_material, [...parts], image_assets_path, image_assets);
-                            break;
-                        case "decal":
-                            if (current_material)
-                                current_material.decal_texture = await Parser.parse_mtl_map(engine, current_material, [...parts], image_assets_path, image_assets);
-                            break;
-                        case "map_pr":
-                            if (current_material)
-                                current_material.roughness_texture = await Parser.parse_mtl_map(engine, current_material, [...parts], image_assets_path, image_assets);
-                            break;
-                        case "map_pm":
-                            if (current_material)
-                                current_material.metalic_texture = await Parser.parse_mtl_map(engine, current_material, [...parts], image_assets_path, image_assets);
-                            break;
-                        case "map_ps":
-                            if (current_material)
-                                current_material.sheen_texture = await Parser.parse_mtl_map(engine, current_material, [...parts], image_assets_path, image_assets);
-                            break;
-                        case "map_ke":
-                            if (current_material)
-                                current_material.emissive_texture = await Parser.parse_mtl_map(engine, current_material, [...parts], image_assets_path, image_assets);
-                            break;
-                        case "norm":
-                            if (current_material)
-                                current_material.normal_texture = await Parser.parse_mtl_map(engine, current_material, [...parts], image_assets_path, image_assets);
-                            break;
-                    }
-                }
-                return material_list;
-            }
-            static async parse_mtl_map(engine, current_material, parts, image_assets_path, image_assets) {
-                var texture_name;
-                var current_flag = null;
-                const texture_file = parts.pop();
-                const map_type_string = parts.shift();
-                var current_flag_arguments = [];
-                if (texture_file) {
-                    const texture_file_url = join_path(image_assets_path, texture_file);
-                    const res = await fetch(texture_file_url.trim());
-                    if (res.ok) {
-                        const blob = await res.blob();
-                        if (map_type_string) {
-                            texture_name = current_material.name + "_" + map_type_string;
-                            image_assets.set(texture_name, new Texture(engine.graphics_manager, texture_name, await createImageBitmap(blob, { imageOrientation: 'flipY' }), TextureType.COLOR, {}));
-                        }
-                        else {
-                            throw Error(`A parsing error has occured that should not be possible while parsing a .mtl file map.`);
-                        }
-                    }
-                    else {
-                        throw new Error(`The .obj image asset file at "${texture_file_url}" does not exist.`);
-                    }
-                }
-                else {
-                    throw new Error(`Failed to get get texture map file name for material named "${current_material.name}" when parsign .mtl file associated with .obj file.`);
-                }
-                const texture_data = { name: texture_name };
-                const set_flag = () => {
-                    switch (current_flag) {
-                        case "-blendu":
-                            texture_data.horizontal_blend =
-                                current_flag_arguments[0] === "off" ?
-                                    false : true;
-                            break;
-                        case "-blendv":
-                            texture_data.vertical_blend =
-                                current_flag_arguments[0] === "off" ?
-                                    false : true;
-                            break;
-                        case "-boost":
-                            texture_data.mip_map_sharpness_boost = Number(current_flag_arguments[0]);
-                            break;
-                        case "-mm":
-                            texture_data.additive_color_offset = Number(current_flag_arguments[0]);
-                            texture_data.contrast_multiplier = Number(current_flag_arguments[1]);
-                            break;
-                        case "-o":
-                            var u = Number(current_flag_arguments[0]);
-                            var v = 0;
-                            var w = 0;
-                            if (current_flag_arguments.length >= 2)
-                                v = Number(current_flag_arguments[1]);
-                            if (current_flag_arguments.length >= 3)
-                                w = Number(current_flag_arguments[2]);
-                            texture_data.offset = new Vec3(u, v, w);
-                            break;
-                        case "-s":
-                            var u = Number(current_flag_arguments[0]);
-                            var v = 1;
-                            var w = 1;
-                            if (current_flag_arguments.length >= 2)
-                                v = Number(current_flag_arguments[1]);
-                            if (current_flag_arguments.length >= 3)
-                                w = Number(current_flag_arguments[2]);
-                            texture_data.scale = new Vec3(u, v, w);
-                            break;
-                        case "-t":
-                            var u = Number(current_flag_arguments[0]);
-                            var v = 0;
-                            var w = 0;
-                            if (current_flag_arguments.length >= 2)
-                                v = Number(current_flag_arguments[1]);
-                            if (current_flag_arguments.length >= 3)
-                                w = Number(current_flag_arguments[2]);
-                            texture_data.turbulence = new Vec3(u, v, w);
-                            break;
-                        case "-texres":
-                            texture_data.generated_texture_resolution = Number(current_flag_arguments[0]);
-                            break;
-                        case "-clamp":
-                            texture_data.clamp =
-                                current_flag_arguments[0] === "on" ?
-                                    true : false;
-                            break;
-                        case "-bm":
-                            texture_data.bump_multiplier = Number(current_flag_arguments[0]);
-                            break;
-                        case "-imfchan":
-                            texture_data.bump_channel = current_flag_arguments[0];
-                            break;
-                        case "-type":
-                            texture_data.reflection_map_type = current_flag_arguments[0];
-                            break;
-                    }
-                    current_flag_arguments = [];
-                };
-                for (const part of parts) {
-                    switch (part) {
-                        case "-blendu":
-                        case "-blendv":
-                        case "-boost":
-                        case "-mm":
-                        case "-o":
-                        case "-s":
-                        case "-t":
-                        case "-texres":
-                        case "-clamp":
-                        case "-bm":
-                        case "-imfchan":
-                        case "-type":
-                            set_flag();
-                            current_flag = part;
-                            break;
-                        default:
-                            current_flag_arguments.push(part);
-                            break;
-                    }
-                }
-                set_flag();
-                return texture_data;
-            }
-            static async parse_obj(engine, file_url, text, image_assets_path, image_assets) {
-                const file_name = basename_path(file_url);
-                const file_directory = dirname_path(file_url);
-                const obj_name = file_name.split(".")[0];
-                var object_list = [];
-                var material_list = [];
-                var current_group = null;
-                var current_object = Parser.create_object(obj_name);
-                var current_data = Parser.create_data();
-                const temp_vertices = [];
-                const temp_normals = [];
-                const temp_uvs = [];
-                object_list.push(current_object);
-                var collection_type = CollectionType.OBJECT;
-                const insert_data = () => {
-                    // Bake the data lists into arrays and delete temp
-                    current_data.indices = new Uint16Array(current_data.temp.indices_final);
-                    current_data.vertices = new Float32Array(current_data.temp.vertices_final);
-                    current_data.uvs = new Float32Array(current_data.temp.uvs_final);
-                    current_data.normals = new Float32Array(current_data.temp.normals_final);
-                    current_data.dimensions = new Vec3(current_data.temp.max_x - current_data.temp.min_x, current_data.temp.max_y - current_data.temp.min_y, current_data.temp.max_z - current_data.temp.min_z);
-                    current_data.center = new Vec3((current_data.temp.max_x + current_data.temp.min_x) / 2.0, (current_data.temp.max_y + current_data.temp.min_y) / 2.0, (current_data.temp.max_z + current_data.temp.min_z) / 2.0);
-                    // set the data for the object
-                    if (collection_type === CollectionType.OBJECT) {
-                        current_object.data = current_data;
-                    }
-                    else if (current_group) {
-                        current_group.data = current_data;
-                    }
-                    current_data = Parser.create_data();
-                };
-                const get_object = (name) => {
-                    for (const object of object_list)
-                        if (object.name === name)
-                            return object;
-                    return null;
-                };
-                const get_group = (name) => {
-                    for (const group of current_object.groups)
-                        if (group.name === name)
-                            return group;
-                    return null;
-                };
-                const lines = text.split("\n");
-                for (const line of lines) {
-                    const parts = line.trim().split(/\s+/);
-                    switch (parts[0].toLowerCase()) {
-                        case "mtllib":
-                            material_list = material_list.concat(await Parser.load_mtl(engine, join_path(file_directory, parts[1]), image_assets_path, image_assets));
-                            break;
-                        case "usemtl":
-                            if (collection_type === CollectionType.OBJECT) {
-                                if (current_object.material !== undefined && current_object.material !== parts[1]) {
-                                    insert_data();
-                                    // Creates an adjacent subobject with the name objectName_materialName
-                                    current_object = Parser.create_object(current_object.name.replace("_" + current_object.material, "") + "_" + parts[1]);
-                                    current_object.material = parts[1];
-                                    object_list.push(current_object);
-                                    collection_type = CollectionType.OBJECT;
-                                }
-                                else {
-                                    current_object.material = parts[1];
-                                }
-                            }
-                            else if (current_group) {
-                                if (current_group.material !== undefined && current_group.material !== parts[1]) {
-                                    insert_data();
-                                    // Creates an adjacent subobject with the name objectName_materialName
-                                    current_group = Parser.create_group(current_group.name.replace("_" + current_group.material, "") + "_" + parts[1]);
-                                    current_group.material = parts[1];
-                                    current_object.groups.push(current_group);
-                                    collection_type = CollectionType.GROUP;
-                                }
-                                else {
-                                    current_group.material = parts[1];
-                                }
-                            }
-                            break;
-                        case "o":
-                            // Object
-                            insert_data();
-                            const existing_object = get_object(parts[1]);
-                            if (existing_object) {
-                                current_object = existing_object;
-                            }
-                            else {
-                                // add current_object to groups and create a new object
-                                current_object = Parser.create_object(parts[1]);
-                                object_list.push(current_object);
-                                collection_type = CollectionType.OBJECT;
-                            }
-                            break;
-                        case "g":
-                            insert_data();
-                            const existing_group = get_group(parts[1]);
-                            if (existing_group) {
-                                current_group = existing_group;
-                            }
-                            else {
-                                // add current_object to groups and create a new object
-                                current_group = Parser.create_group(parts[1]);
-                                current_object.groups.push(current_group);
-                                collection_type = CollectionType.GROUP;
-                            }
-                            break;
-                        case "v":
-                            var [x, y, z] = parts.slice(1).map(Number);
-                            temp_vertices.push([x, y, z]);
-                            break;
-                        case "vn":
-                            var [x, y, z] = parts.slice(1).map(Number);
-                            temp_normals.push([x, y, z]);
-                            break;
-                        case "vt":
-                            var [u, v] = parts.slice(1).map(Number);
-                            temp_uvs.push([u, v]);
-                            break;
-                        case "f":
-                            // Each face can be triangles or quads
-                            const face_verts = parts.slice(1);
-                            const face_indices = [];
-                            for (const fv of face_verts) {
-                                if (!current_data.temp.vertex_map.has(fv)) {
-                                    const [vIdx, vtIdx, vnIdx] = fv.split("/").map(s => parseInt(s));
-                                    const [x, y, z] = temp_vertices[vIdx - 1];
-                                    // FIND MINS AND MAXES
-                                    current_data.temp.min_x = x < current_data.temp.min_x ? x : current_data.temp.min_x;
-                                    current_data.temp.min_y = y < current_data.temp.min_y ? y : current_data.temp.min_y;
-                                    current_data.temp.min_z = z < current_data.temp.min_z ? z : current_data.temp.min_z;
-                                    current_data.temp.max_x = x > current_data.temp.max_x ? x : current_data.temp.max_x;
-                                    current_data.temp.max_y = y > current_data.temp.max_y ? y : current_data.temp.max_y;
-                                    current_data.temp.max_z = z > current_data.temp.max_z ? z : current_data.temp.max_z;
-                                    // FIND VERTEX
-                                    current_data.temp.vertices_final.push(x, y, z);
-                                    if (vtIdx && temp_uvs[vtIdx - 1])
-                                        current_data.temp.uvs_final.push(...temp_uvs[vtIdx - 1]);
-                                    else
-                                        current_data.temp.uvs_final.push(0, 0);
-                                    if (vnIdx && temp_normals[vnIdx - 1])
-                                        current_data.temp.normals_final.push(...temp_normals[vnIdx - 1]);
-                                    else
-                                        current_data.temp.normals_final.push(0, 0, 0);
-                                    const index = (current_data.temp.vertices_final.length / 3) - 1;
-                                    current_data.temp.vertex_map.set(fv, index);
-                                    face_indices.push(index);
-                                }
-                                else {
-                                    face_indices.push(current_data.temp.vertex_map.get(fv));
-                                }
-                            }
-                            // Triangulate quads if necessary
-                            if (face_indices.length === 3) {
-                                current_data.temp.indices_final.push(...face_indices);
-                            }
-                            else if (face_indices.length === 4) {
-                                current_data.temp.indices_final.push(face_indices[0], face_indices[1], face_indices[2]);
-                                current_data.temp.indices_final.push(face_indices[0], face_indices[2], face_indices[3]);
-                            }
-                            break;
-                    }
-                }
-                insert_data();
-                return [object_list, material_list];
-            }
-        }
-    })(OBJ = AssetFile.OBJ || (AssetFile.OBJ = {}));
-})(AssetFile || (AssetFile = {}));
-async function parse_obj(text) {
-    const positions = [];
-    const normals = [];
-    const uvs = [];
-    const indices = [];
-    const temp_vertices = [];
-    const temp_normals = [];
-    const temp_uvs = [];
-    const vertex_map = new Map(); // maps "v/vt/vn" to index
-    var [min_x, min_y, min_z] = [Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE];
-    var [max_x, max_y, max_z] = [Number.MIN_VALUE, Number.MIN_VALUE, Number.MIN_VALUE];
-    const lines = text.split("\n");
-    for (const line of lines) {
-        const parts = line.trim().split(/\s+/);
-        if (parts.length === 0)
-            continue;
-        switch (parts[0]) {
-            case "v":
-                const [x, y, z] = parts.slice(1).map(Number);
-                min_x = x < min_x ? x : min_x;
-                min_y = y < min_y ? y : min_y;
-                min_z = z < min_z ? z : min_z;
-                max_x = x > max_x ? x : max_x;
-                max_y = y > max_y ? y : max_y;
-                max_z = z > max_z ? z : max_z;
-                temp_vertices.push([x, y, z]);
-                break;
-            case "vn":
-                temp_normals.push(parts.slice(1).map(Number));
-                break;
-            case "vt":
-                temp_uvs.push(parts.slice(1).map(Number));
-                break;
-            case "f":
-                // Each face can be triangles or quads
-                const face_verts = parts.slice(1);
-                const face_indices = [];
-                for (const fv of face_verts) {
-                    if (!vertex_map.has(fv)) {
-                        const [vIdx, vtIdx, vnIdx] = fv.split("/").map(s => parseInt(s));
-                        const pos = temp_vertices[vIdx - 1];
-                        positions.push(...pos);
-                        if (vtIdx && temp_uvs[vtIdx - 1])
-                            uvs.push(...temp_uvs[vtIdx - 1]);
-                        else
-                            uvs.push(0, 0);
-                        if (vnIdx && temp_normals[vnIdx - 1])
-                            normals.push(...temp_normals[vnIdx - 1]);
-                        else
-                            normals.push(0, 0, 0);
-                        const index = (positions.length / 3) - 1;
-                        vertex_map.set(fv, index);
-                        face_indices.push(index);
-                    }
-                    else {
-                        face_indices.push(vertex_map.get(fv));
-                    }
-                }
-                // Triangulate quads if necessary
-                if (face_indices.length === 3) {
-                    indices.push(...face_indices);
-                }
-                else if (face_indices.length === 4) {
-                    indices.push(face_indices[0], face_indices[1], face_indices[2]);
-                    indices.push(face_indices[0], face_indices[2], face_indices[3]);
-                }
-                break;
-        }
-    }
-    return {
-        vertices: new Float32Array(positions),
-        normals: new Float32Array(normals),
-        uvs: new Float32Array(uvs),
-        indices: new Uint16Array(indices),
-        dimensions: new Vec3(max_x - min_x, max_y - min_y, max_z - min_z),
-        center: new Vec3((max_x + min_x) / 2.0, (max_y + min_y) / 2.0, (max_z + min_z) / 2.0),
-    };
-}
-export async function load_obj(gm, model_path, image_asset_paths) {
-    var image_assets = [];
-    const vertexMap = new Map();
-    for (const image_asset_path of image_asset_paths) {
-        const res = await fetch(image_asset_path);
-        if (res.ok) {
-            const blob = await res.blob();
-            image_assets.push(new Texture(gm, image_asset_path, await createImageBitmap(blob, { imageOrientation: 'flipY' }), TextureType.COLOR, {}));
-        }
-        else {
-            throw new Error(`The .obj image asset file at "${image_asset_path}" does not exist.`);
-        }
-    }
-    // Parse the mesh file
-    const res = await fetch(model_path);
-    if (res.ok) {
-        const raw_text = await res.text();
-        var obj = await parse_obj(raw_text);
-    }
-    else {
-        throw new Error(`The .obj file at "${model_path}" does not exist.`);
-    }
-    // Build the model
-    var mesh = new Mesh(gm, obj.vertices, obj.normals, obj.uvs, obj.indices, obj.dimensions, obj.center);
-    var material = new Material(gm, "default", image_assets[0], 0.0, 0.0, 0.0, null, gm.default_3d_shader_program);
-    var model = new Model(gm, "default", mesh, material);
-    return model;
-}
-//# sourceMappingURL=obj.js.map