vanta-engine 1.0.2 → 1.0.4

package/dist/shaders/default_3d.fs.js

@@ -1,327 +0,0 @@
-export default `#version 300 es
-precision lowp float;
-precision lowp sampler2DArrayShadow;
-
-uniform mediump int directional_lights_count;
-uniform mediump int point_lights_count;
-uniform mediump int spot_lights_count;
-
-#define N_DIRECTIONAL_LIGHTS 10
-#define N_POINT_LIGHTS 10
-#define N_SPOT_LIGHTS 10
-#define PI 3.14159265358979323846264338327950288419716939937510
-
-in vec3 v_normal;
-in vec2 v_uv;
-in vec4 v_frag_pos;
-
-out vec4 frag_color;
-
-
-struct Environment {
-    vec3 ambient_light;
-};
-
-// fallback values
-struct Material {
-    bool has_normal_texture;
-    bool has_albedo_texture;
-    vec3 albedo;
-
-    bool has_metalic_texture;
-    float metalic;
-    bool has_roughness_texture;
-    float roughness;
-    bool has_ao_texture;
-    float ao;
-};
-
-// PBR
-uniform sampler2D material_texture_albedo;
-uniform sampler2D material_texture_normal;
-uniform sampler2D material_texture_metalic;
-uniform sampler2D material_texture_roughness;
-uniform sampler2D material_texture_ao;
-
-struct PointLight {
-    vec3 position;
-    vec3 color;
-    float range;
-    float energy;
-
-    float ambient;
-    float diffuse;
-    float specular;
-};
-
-struct SpotLight {
-    vec3 position;
-    vec3 color;
-    mat4 rotation;
-    float energy;
-    float range;
-    float cookie_radius;
-
-    float ambient;
-    float diffuse;
-    float specular;
-};
-
-struct DirectionalLight {
-    mat4 rotation;
-    vec3 color;
-    float energy;
-
-    float ambient;
-    float diffuse;
-    float specular;
-};
-
-uniform PointLight point_lights[N_POINT_LIGHTS];
-
-uniform SpotLight spot_lights[N_SPOT_LIGHTS];
-
-uniform DirectionalLight directional_lights[N_DIRECTIONAL_LIGHTS];
-
-uniform Material material;
-
-uniform Environment environment;
-
-uniform vec3 camera_position;
-
-uniform sampler2DArrayShadow directional_light_shadow_maps;
-uniform sampler2DArrayShadow point_light_shadow_maps;
-
-uniform vec2 shadow_map_size;
-
-uniform mat4 u_directional_light_space_matrix[N_DIRECTIONAL_LIGHTS];
-uniform mat4 u_point_light_space_matrix[N_POINT_LIGHTS * 6];
-
-float L(PointLight light);
-float L(DirectionalLight light);
-
-float distribution_GGX(vec3 N, vec3 H, float a);
-float geometry_schlick_GGX(float NdotV, float k);
-float geometry_smith(vec3 N, vec3 V, vec3 L, float k);
-vec3 fresnel_schlick(float cosTheta, vec3 F0);
-
-vec3 Fr(vec3 light_dir, vec4 albedo_color, bool image_lighting);
-
-vec3 calculate_point_lighting(vec4 base_color);
-
-vec3 calculate_directional_lighting(vec4 base_color);
-
-vec3 calculate_lighting(vec4 base_color);
-
-float calculate_point_shadow(int index, PointLight light);
-
-float calculate_directional_shadow(int index, vec3 light_dir);
-
-void main() {
-    
-    vec4 base_color;
-    if (material.has_albedo_texture)
-        base_color = texture(material_texture_albedo, v_uv);
-    else
-        base_color = vec4(material.albedo, 1.0);
-
-    vec3 lighting = calculate_lighting(base_color);
-
-    base_color.rgb = environment.ambient_light * base_color.rgb + lighting;
-
-    frag_color = base_color;
-}
-
-int get_point_shadow_face_index(int origin, vec3 dir) {
-    vec3 abs_dir = abs(dir);
-    
-    int index = 0;
-    
-    // Directly compare the absolute values
-    if (abs_dir.x >= abs_dir.y && abs_dir.x >= abs_dir.z) {
-        // X is dominant
-        index = (dir.x > 0.0) ? 0 : 1;
-    } else if (abs_dir.y >= abs_dir.z) {
-        // Y is dominant
-        index = (dir.y > 0.0) ? 2 : 3;
-    } else {
-        // Z is dominant
-        index = (dir.z > 0.0) ? 4 : 5;
-    }
-    
-    return origin + index;
-}
-
-float calculate_point_shadow(int index, PointLight light) {
-    vec3 light_to_frag = v_frag_pos.xyz - light.position;
-    float light_distance = length(light_to_frag);
-    vec3 dir = normalize(light_to_frag);
-
-    float bias = max(0.015 * (1.0 - dot(v_normal, -dir)), 0.003);
-
-    int face_index = get_point_shadow_face_index(index * 6, dir);
-
-    vec4 frag_light = u_point_light_space_matrix[face_index] * v_frag_pos;
-    vec3 proj = frag_light.xyz / frag_light.w;
-    proj = proj * 0.5 + 0.5;
-
-    float current_depth = light_distance / light.range;
-
-    float shadow = 0.0;
-
-    shadow += texture(
-        point_light_shadow_maps,
-        vec4(
-            proj.xy,
-            float(face_index),
-            current_depth - bias
-        )
-    );
-
-    return shadow;
-}
-
-vec3 calculate_point_lighting(vec4 base_color) {
-    vec3 cumulative_radiance = vec3(0.0,0.0,0.0);
-
-    for (int i = 0; i < point_lights_count; i++) {
-        PointLight light = point_lights[i];
-        vec3 light_dir = normalize(light.position - v_frag_pos.xyz);
-        float n_dot_l = max(dot(v_normal, light_dir), 0.0);
-        vec3 product = Fr(light_dir, base_color, false) * L(light) * n_dot_l;
-        float shadow = calculate_point_shadow(i, light);
-        cumulative_radiance += product * light.color * shadow;
-    }
-
-    return cumulative_radiance;
-}
-
-float calculate_directional_shadow(int index, vec3 light_dir) {
-    vec4 frag_pos_light_space = u_directional_light_space_matrix[index] * v_frag_pos;
-    vec3 proj_coords = frag_pos_light_space.xyz / frag_pos_light_space.w;
-    proj_coords = proj_coords * 0.5 + 0.5;
-
-    float bias = max(0.05 * (1.0 - dot(v_normal, light_dir)), 0.005);
-
-    float current_depth = proj_coords.z - bias;
-
-    // apply blur to shadow edges
-    float shadow = 0.0;
-
-    shadow += texture(directional_light_shadow_maps, vec4(
-        proj_coords.xy, 
-        float(index), 
-        current_depth
-    ));
-
-    return shadow;
-}
-
-vec3 calculate_lighting(vec4 base_color) {
-    vec3 cumulative_radiance = vec3(0.0,0.0,0.0);
-
-    cumulative_radiance += calculate_point_lighting(base_color);
-
-    cumulative_radiance += calculate_directional_lighting(base_color);
-
-    return cumulative_radiance;
-}
-
-vec3 calculate_directional_lighting(vec4 base_color) {
-    vec3 cumulative_radiance = vec3(0.0,0.0,0.0);
-
-    for (int i = 0; i < directional_lights_count; i++) {
-        DirectionalLight light = directional_lights[i];
-        vec3 light_dir = (light.rotation * vec4(1.0,0.0,0.0, 0.0)).xyz;
-        float n_dot_l = max(dot(v_normal, light_dir), 0.0);
-        vec3 product = Fr(light_dir, base_color, false) * L(light) * n_dot_l;
-        float shadow = calculate_directional_shadow(i, light_dir);
-        cumulative_radiance += product * light.color * shadow;
-    }
-
-    return cumulative_radiance;
-}
-
-vec3 Fr(vec3 light_dir, vec4 albedo_color, bool image_lighting) {
-
-    // COOK TORRANCE
-    vec3 view_vector = normalize(camera_position - v_frag_pos.xyz);
-    vec3 halfway_vector = (light_dir + view_vector) / length(light_dir + view_vector);
-
-    float roughness = max(material.roughness, 0.04);
-
-    float k;
-    if (image_lighting)
-        k = pow(roughness, 2.0) / 2.0;
-    else
-        k = pow(roughness + 1.0, 2.0) / 8.0;
-
-    /// DGF
-    float D = distribution_GGX(v_normal, halfway_vector, roughness);
-    float G = geometry_smith(v_normal, view_vector, light_dir, k);
-    vec3 F0 = vec3(0.04); 
-    F0 = mix(F0, albedo_color.rgb, material.metalic);
-    vec3 F = fresnel_schlick(max(dot(halfway_vector, view_vector), 0.0), F0);
-    
-    vec3 numerator    = D * G * F;
-    float denominator = 4.0 * max(dot(v_normal, view_vector), 0.0) * max(dot(v_normal, light_dir), 0.0)  + 0.0001;
-    vec3 specular = numerator / denominator; 
-
-    vec3 ks = F;
-    vec3 kd = vec3(1.0) - ks;
-    kd *= 1.0 - material.metalic;
-
-    vec3 f_lambert = albedo_color.rgb / PI;
-
-
-    return kd * f_lambert + specular;
-}
-
-float L(PointLight light) {
-    float light_distance = distance(v_frag_pos.xyz, light.position);
-    // Standard ranged attenuation
-    float attenuation = clamp(1.0 - light_distance / light.range, 0.0, 1.0);
-    return light.energy * attenuation * attenuation;
-}
-
-float L(DirectionalLight light) {
-    return light.energy;
-}
-
-float distribution_GGX(vec3 N, vec3 H, float a)
-{
-    float a2     = a*a;
-    float NdotH  = max(dot(N, H), 0.0);
-    float NdotH2 = NdotH*NdotH;
-	
-    float nom    = a2;
-    float denom  = (NdotH2 * (a2 - 1.0) + 1.0);
-    denom        = PI * denom * denom;
-	
-    return nom / denom;
-}
-
-
-float geometry_schlick_GGX(float NdotV, float k)
-{
-    float nom   = NdotV;
-    float denom = NdotV * (1.0 - k) + k;
-	
-    return nom / denom;
-}
-  
-float geometry_smith(vec3 N, vec3 V, vec3 L, float k)
-{
-    float NdotV = max(dot(N, V), 0.0);
-    float NdotL = max(dot(N, L), 0.0);
-    float ggx1 = geometry_schlick_GGX(NdotV, k);
-    float ggx2 = geometry_schlick_GGX(NdotL, k);
-	
-    return ggx1 * ggx2;
-}
-
-vec3 fresnel_schlick(float cosTheta, vec3 F0)
-{
-    return F0 + (1.0 - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);
-}`;
-//# sourceMappingURL=default_3d.fs.js.map

package/dist/shaders/default_3d.fs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"default_3d.fs.js","sourceRoot":"","sources":["../../src/shaders/default_3d.fs.ts"],"names":[],"mappings":"AAAA,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqUb,CAAC"}

package/dist/shaders/default_3d.vs.d.ts

@@ -1,3 +0,0 @@
-declare const _default: "#version 300 es\nprecision lowp float;\nprecision lowp sampler2DArrayShadow;\n\nuniform mediump int directional_lights_count;\nuniform mediump int point_lights_count;\nuniform mediump int spot_lights_count;\n\n#define N_DIRECTIONAL_LIGHTS 10\n#define N_POINT_LIGHTS 10\n#define N_SPOT_LIGHTS 10\n\n// Vertex position attribute\nlayout(location = 0) in vec3 a_position;\nlayout(location = 1) in vec3 a_normal;\nlayout(location = 2) in vec2 a_uv;\n\nout vec3 v_normal;\nout vec2 v_uv;\nout vec4 v_frag_pos;\n\n\n// Uniform MVP matrix\nuniform mat4 u_model;\nuniform mat4 u_view;\nuniform mat4 u_projection;\n\nvoid main() {\n\n    v_frag_pos = u_model * vec4(a_position, 1.0);\n    v_normal = normalize(mat3(transpose(inverse(u_model))) * a_normal);\n    v_uv = a_uv;\n\n    gl_Position = u_projection * u_view * v_frag_pos;\n}";
-export default _default;
-//# sourceMappingURL=default_3d.vs.d.ts.map

package/dist/shaders/default_3d.vs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"default_3d.vs.d.ts","sourceRoot":"","sources":["../../src/shaders/default_3d.vs.ts"],"names":[],"mappings":";AAAA,wBAkCG"}

package/dist/shaders/default_3d.vs.js

@@ -1,36 +0,0 @@
-export default `#version 300 es
-precision lowp float;
-precision lowp sampler2DArrayShadow;
-
-uniform mediump int directional_lights_count;
-uniform mediump int point_lights_count;
-uniform mediump int spot_lights_count;
-
-#define N_DIRECTIONAL_LIGHTS 10
-#define N_POINT_LIGHTS 10
-#define N_SPOT_LIGHTS 10
-
-// Vertex position attribute
-layout(location = 0) in vec3 a_position;
-layout(location = 1) in vec3 a_normal;
-layout(location = 2) in vec2 a_uv;
-
-out vec3 v_normal;
-out vec2 v_uv;
-out vec4 v_frag_pos;
-
-
-// Uniform MVP matrix
-uniform mat4 u_model;
-uniform mat4 u_view;
-uniform mat4 u_projection;
-
-void main() {
-
-    v_frag_pos = u_model * vec4(a_position, 1.0);
-    v_normal = normalize(mat3(transpose(inverse(u_model))) * a_normal);
-    v_uv = a_uv;
-
-    gl_Position = u_projection * u_view * v_frag_pos;
-}`;
-//# sourceMappingURL=default_3d.vs.js.map

package/dist/shaders/default_3d.vs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"default_3d.vs.js","sourceRoot":"","sources":["../../src/shaders/default_3d.vs.ts"],"names":[],"mappings":"AAAA,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCb,CAAC"}

package/dist/shaders/default_directional_shadow.fs.d.ts

@@ -1,3 +0,0 @@
-declare const _default: "#version 300 es\n\n\nvoid main() {\n}";
-export default _default;
-//# sourceMappingURL=default_directional_shadow.fs.d.ts.map

package/dist/shaders/default_directional_shadow.fs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"default_directional_shadow.fs.d.ts","sourceRoot":"","sources":["../../src/shaders/default_directional_shadow.fs.ts"],"names":[],"mappings":";AAAA,wBAIG"}

package/dist/shaders/default_directional_shadow.fs.js

@@ -1,6 +0,0 @@
-export default `#version 300 es
-
-
-void main() {
-}`;
-//# sourceMappingURL=default_directional_shadow.fs.js.map

package/dist/shaders/default_directional_shadow.fs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"default_directional_shadow.fs.js","sourceRoot":"","sources":["../../src/shaders/default_directional_shadow.fs.ts"],"names":[],"mappings":"AAAA,eAAe;;;;EAIb,CAAC"}

package/dist/shaders/default_directional_shadow.vs.d.ts

@@ -1,3 +0,0 @@
-declare const _default: "#version 300 es\nlayout (location = 0) in vec3 aPos;\n\nuniform mat4 u_light_space_matrix;\nuniform mat4 u_model;\n\nvoid main()\n{\n    gl_Position = u_light_space_matrix * u_model * vec4(aPos, 1.0);\n}";
-export default _default;
-//# sourceMappingURL=default_directional_shadow.vs.d.ts.map

package/dist/shaders/default_directional_shadow.vs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"default_directional_shadow.vs.d.ts","sourceRoot":"","sources":["../../src/shaders/default_directional_shadow.vs.ts"],"names":[],"mappings":";AAAA,wBASG"}

package/dist/shaders/default_directional_shadow.vs.js

@@ -1,11 +0,0 @@
-export default `#version 300 es
-layout (location = 0) in vec3 aPos;
-
-uniform mat4 u_light_space_matrix;
-uniform mat4 u_model;
-
-void main()
-{
-    gl_Position = u_light_space_matrix * u_model * vec4(aPos, 1.0);
-}`;
-//# sourceMappingURL=default_directional_shadow.vs.js.map

package/dist/shaders/default_directional_shadow.vs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"default_directional_shadow.vs.js","sourceRoot":"","sources":["../../src/shaders/default_directional_shadow.vs.ts"],"names":[],"mappings":"AAAA,eAAe;;;;;;;;;EASb,CAAC"}

package/dist/shaders/default_point_shadow.fs.d.ts

@@ -1,3 +0,0 @@
-declare const _default: "#version 300 es\nprecision lowp float;\n\nin vec4 v_frag_pos;\nout vec4 frag_color;\n\n\nuniform vec3 origin;\nuniform float range;\n\n\nvoid main()\n{\n    float dist = length(v_frag_pos.xyz - origin);\n    gl_FragDepth = dist / range;\n}\n";
-export default _default;
-//# sourceMappingURL=default_point_shadow.fs.d.ts.map

package/dist/shaders/default_point_shadow.fs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"default_point_shadow.fs.d.ts","sourceRoot":"","sources":["../../src/shaders/default_point_shadow.fs.ts"],"names":[],"mappings":";AAAA,wBAgBE"}

package/dist/shaders/default_point_shadow.fs.js

@@ -1,18 +0,0 @@
-export default `#version 300 es
-precision lowp float;
-
-in vec4 v_frag_pos;
-out vec4 frag_color;
-
-
-uniform vec3 origin;
-uniform float range;
-
-
-void main()
-{
-    float dist = length(v_frag_pos.xyz - origin);
-    gl_FragDepth = dist / range;
-}
-`;
-//# sourceMappingURL=default_point_shadow.fs.js.map

package/dist/shaders/default_point_shadow.fs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"default_point_shadow.fs.js","sourceRoot":"","sources":["../../src/shaders/default_point_shadow.fs.ts"],"names":[],"mappings":"AAAA,eAAe;;;;;;;;;;;;;;;;CAgBd,CAAC"}

package/dist/shaders/default_point_shadow.vs.d.ts

@@ -1,3 +0,0 @@
-declare const _default: "#version 300 es\nlayout (location = 0) in vec3 a_position;\n\nout vec4 v_frag_pos;\n\nuniform mat4 u_model;\nuniform mat4 u_light_space_matrix;\n\nvoid main()\n{\n    v_frag_pos = u_model * vec4(a_position, 1.0);\n    gl_Position = u_light_space_matrix * v_frag_pos;\n}";
-export default _default;
-//# sourceMappingURL=default_point_shadow.vs.d.ts.map

package/dist/shaders/default_point_shadow.vs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"default_point_shadow.vs.d.ts","sourceRoot":"","sources":["../../src/shaders/default_point_shadow.vs.ts"],"names":[],"mappings":";AAAA,wBAYG"}

package/dist/shaders/default_point_shadow.vs.js

@@ -1,14 +0,0 @@
-export default `#version 300 es
-layout (location = 0) in vec3 a_position;
-
-out vec4 v_frag_pos;
-
-uniform mat4 u_model;
-uniform mat4 u_light_space_matrix;
-
-void main()
-{
-    v_frag_pos = u_model * vec4(a_position, 1.0);
-    gl_Position = u_light_space_matrix * v_frag_pos;
-}`;
-//# sourceMappingURL=default_point_shadow.vs.js.map

package/dist/shaders/default_point_shadow.vs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"default_point_shadow.vs.js","sourceRoot":"","sources":["../../src/shaders/default_point_shadow.vs.ts"],"names":[],"mappings":"AAAA,eAAe;;;;;;;;;;;;EAYb,CAAC"}

package/dist/shaders/default_skybox.fs.d.ts

@@ -1,3 +0,0 @@
-declare const _default: "#version 300 es\nprecision lowp float;\n\nin vec3 v_texCoord;\n\nout vec4 fragColor;\n\nuniform samplerCube skybox_texture;\n\nvoid main() {\n    fragColor = texture(skybox_texture, v_texCoord);\n}\n";
-export default _default;
-//# sourceMappingURL=default_skybox.fs.d.ts.map

package/dist/shaders/default_skybox.fs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"default_skybox.fs.d.ts","sourceRoot":"","sources":["../../src/shaders/default_skybox.fs.ts"],"names":[],"mappings":";AAAA,wBAYE"}

package/dist/shaders/default_skybox.fs.js

@@ -1,14 +0,0 @@
-export default `#version 300 es
-precision lowp float;
-
-in vec3 v_texCoord;
-
-out vec4 fragColor;
-
-uniform samplerCube skybox_texture;
-
-void main() {
-    fragColor = texture(skybox_texture, v_texCoord);
-}
-`;
-//# sourceMappingURL=default_skybox.fs.js.map

package/dist/shaders/default_skybox.fs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"default_skybox.fs.js","sourceRoot":"","sources":["../../src/shaders/default_skybox.fs.ts"],"names":[],"mappings":"AAAA,eAAe;;;;;;;;;;;;CAYd,CAAC"}

package/dist/shaders/default_skybox.vs.d.ts

@@ -1,3 +0,0 @@
-declare const _default: "#version 300 es\nprecision lowp float;\n\nlayout(location = 0) in vec3 a_position;\n\nout vec3 v_texCoord;\n\nuniform mat4 u_view;\nuniform mat4 u_projection;\n\nvoid main() {\n    // Remove translation from view matrix\n    mat4 rotView = mat4(mat3(u_view));\n\n    v_texCoord = a_position;\n\n    gl_Position = u_projection * rotView * vec4(a_position, 1.0);\n\n    // Make sure depth is at far plane\n    gl_Position = gl_Position.xyww;\n}\n";
-export default _default;
-//# sourceMappingURL=default_skybox.vs.d.ts.map

package/dist/shaders/default_skybox.vs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"default_skybox.vs.d.ts","sourceRoot":"","sources":["../../src/shaders/default_skybox.vs.ts"],"names":[],"mappings":";AAAA,wBAqBE"}

package/dist/shaders/default_skybox.vs.js

@@ -1,23 +0,0 @@
-export default `#version 300 es
-precision lowp float;
-
-layout(location = 0) in vec3 a_position;
-
-out vec3 v_texCoord;
-
-uniform mat4 u_view;
-uniform mat4 u_projection;
-
-void main() {
-    // Remove translation from view matrix
-    mat4 rotView = mat4(mat3(u_view));
-
-    v_texCoord = a_position;
-
-    gl_Position = u_projection * rotView * vec4(a_position, 1.0);
-
-    // Make sure depth is at far plane
-    gl_Position = gl_Position.xyww;
-}
-`;
-//# sourceMappingURL=default_skybox.vs.js.map

package/dist/shaders/default_skybox.vs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"default_skybox.vs.js","sourceRoot":"","sources":["../../src/shaders/default_skybox.vs.ts"],"names":[],"mappings":"AAAA,eAAe;;;;;;;;;;;;;;;;;;;;;CAqBd,CAAC"}

package/dist/utility.d.ts

@@ -1,5 +0,0 @@
-export default class Utility {
-    static load_text_file(url: string): Promise<string>;
-    static load_image(image_asset_path: string, options?: ImageBitmapOptions): Promise<ImageBitmap>;
-}
-//# sourceMappingURL=utility.d.ts.map

package/dist/utility.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utility.d.ts","sourceRoot":"","sources":["../src/utility.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,OAAO,OAAO;WACX,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;WAM5C,UAAU,CAAC,gBAAgB,EAAC,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAE,OAAO,CAAC,WAAW,CAAC;CAStG"}

package/dist/utility.js

@@ -1,19 +0,0 @@
-export default class Utility {
-    static async load_text_file(url) {
-        const response = await fetch(url);
-        if (!response.ok)
-            throw new Error(`Failed to load ${url}`);
-        return await response.text();
-    }
-    static async load_image(image_asset_path, options) {
-        const res = await fetch(image_asset_path);
-        if (res.ok) {
-            const blob = await res.blob();
-            return await createImageBitmap(blob, options);
-        }
-        else {
-            throw new Error(`The .obj image asset file at "${image_asset_path}" does not exist.`);
-        }
-    }
-}
-//# sourceMappingURL=utility.js.map

package/dist/utility.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utility.js","sourceRoot":"","sources":["../src/utility.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,OAAO,OAAO;IACxB,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC,GAAW;QACnC,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;QAClC,IAAI,CAAC,QAAQ,CAAC,EAAE;YAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,GAAG,EAAE,CAAC,CAAC;QAC3D,OAAO,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;IACjC,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,gBAAuB,EAAE,OAA4B;QACzE,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,gBAAgB,CAAC,CAAC;QAC1C,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC;YACT,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC;YAC9B,OAAO,MAAM,iBAAiB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAClD,CAAC;aAAM,CAAC;YACJ,MAAM,IAAI,KAAK,CAAC,iCAAiC,gBAAgB,mBAAmB,CAAC,CAAC;QAC1F,CAAC;IACL,CAAC;CACJ"}