bg2e-js 2.0.1 → 2.0.2

package/shaders/webgl_shader_lib.js

@@ -1,187 +0,0 @@
-
-import ShaderFunction from "./ShaderFunction";
-
-export const fresnelSchlick = new ShaderFunction('vec3', 'fresnelSchlick', 'float cosTheta, vec3 F0', `{
-    return F0 + (1.0 - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);
-}`);
-
-export const fresnelSchlickRoughness = new ShaderFunction('vec3', 'fresnelSchlickRoughness', 'float cosTheta, vec3 F0, float roughness', `{
-    return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);
-}`);
-
-export const distributionGGX = new ShaderFunction('float', 'distributionGGX', 'vec3 N, vec3 H, float roughness', `{
-    float a = roughness * roughness;
-    float a2 = a * a;
-    float NdotH = max(dot(N, H), 0.0);
-    float NdotH2 = NdotH * NdotH;
-
-    float num = a2;
-    float denom = NdotH2 * (a2 - 1.0) + 1.0;
-    denom = ${Math.PI} * denom * denom;
-
-    return num / denom;
-}`);
-
-export const geometrySchlickGGX = new ShaderFunction('float', 'geometrySchlickGGX', 'float NdotV, float roughness', `{
-    float r = (roughness + 1.0);
-    float k = (r * r) / 8.0;
-
-    float num = NdotV;
-    float denom = NdotV * (1.0 - k) + k;
-
-    return num / denom;
-}`)
-
-export const geometrySmith = new ShaderFunction('float', 'geometrySmith', 'vec3 N, vec3 V, vec3 L, float roughness', `{
-    float NdotV = max(dot(N,V), 0.0);
-    float NdotL = max(dot(N,L), 0.0);
-    float ggx2 = geometrySchlickGGX(NdotV, roughness);
-    float ggx1 = geometrySchlickGGX(NdotL, roughness);
-
-    return ggx1 * ggx2;
-}`, [geometrySchlickGGX]);
-
-export const pbrPointLight = new ShaderFunction('vec3', 'pbrPointLight',
-    'vec3 lightPos, vec3 lightColor, vec3 fragPos, vec3 fragNorm, vec3 viewPos, vec3 albedo, float roughness, float metallic, vec3 fresnel',
-    `{
-    vec3 F0 = vec3(0.04);
-    F0 = mix(F0, albedo, metallic);
-
-    vec3 L = normalize(lightPos - fragPos);
-    vec3 H = normalize(viewPos + L);
-
-    float distance = length(lightPos - fragPos);
-    float attenuation = 1.0 / (distance * distance);
-    vec3 radiance = lightColor * attenuation;
-
-    vec3 F = fresnelSchlick(max(dot(H, viewPos), 0.0), F0) * fresnel;
-
-    float NDF = distributionGGX(fragNorm, H, roughness);
-    float G = geometrySmith(fragNorm, viewPos, L, roughness);
-
-    vec3 numerator = NDF * G * F;
-    float denom = 4.0 * max(dot(fragNorm,viewPos), 0.0) * max(dot(fragNorm,L), 0.0) + 0.0001;
-    vec3 specular = numerator / denom;
-
-    vec3 kS = F;
-    vec3 kD = vec3(1.0) - kS;
-
-    kD *= 1.0 - metallic;
-
-    float NdotL = max(dot(fragNorm,L), 0.0);
-    return (kD * albedo / ${Math.PI} + specular) * radiance * NdotL;
-}`, [fresnelSchlick, distributionGGX, geometrySmith]);
-
-export const pbrDirectionalLight = new ShaderFunction('vec3', 'pbrDirectionalLight',
-    'vec3 lightDir, vec3 lightColor, vec3 fragPos, vec3 fragNorm, vec3 viewPos, vec3 albedo, float roughness, float metallic, vec3 fresnel, vec3 shadowColor',
-    `{
-    vec3 F0 = vec3(0.04);
-    F0 = mix(F0, albedo, metallic);
-
-    vec3 L = normalize(lightDir);
-    vec3 H = normalize(viewPos + L);
-
-    vec3 F = fresnelSchlickRoughness(max(dot(H, viewPos), 0.0), F0, roughness);
-
-    float NDF = distributionGGX(fragNorm, H, roughness);
-    float G = geometrySmith(fragNorm, viewPos, L, roughness);
-
-    vec3 numerator = NDF * G * F;
-    float denom = 4.0 * max(dot(fragNorm,viewPos), 0.4) * max(dot(fragNorm,L), 0.4);
-    vec3 specular = numerator / max(denom, 0.0001);
-
-    vec3 kS = F;
-    vec3 kD = vec3(1.0) - kS;
-
-    kD *= 1.0 - metallic;
-
-    float NdotL = max(dot(fragNorm,L), 0.0);
-    return (kD * albedo / ${Math.PI} + specular * fresnel * shadowColor) * lightColor * shadowColor * NdotL;
-}`, [fresnelSchlick, distributionGGX, geometrySmith, fresnelSchlickRoughness]);
-
-export const getPrefilteredColor = new ShaderFunction('vec3', 'getPrefilteredColor', 'float roughness, vec3 refVec, samplerCube irrMap, samplerCube specMap, samplerCube envMap',
-    `{
-    vec3 specMap0 = textureCube(envMap, refVec).rgb;
-    vec3 specMap1 = textureCube(specMap, refVec).rgb;
-    vec3 specMap2 = textureCube(irrMap, refVec).rgb;
-
-    if (roughness<0.7) {
-        return mix(specMap0, specMap1, (log(roughness) + 5.0) / 5.0);
-    }
-    else {
-        return mix(specMap1, specMap2, roughness);
-    }
-}`);
-
-export const pbrAmbientLight = new ShaderFunction('vec3', 'pbrAmbientLight', 'vec3 fragPos, vec3 N, vec3 V, vec3 albedo, float metallic, float roughness, samplerCube irradianceMap, samplerCube specularMap, samplerCube envMap, sampler2D brdfMap, vec3 fresnel, vec3 shadowColor',
-    `{
-    vec3 F0 = vec3(0.04);
-    F0 = mix(F0, albedo, metallic);
-    vec3 kS = fresnelSchlickRoughness(max(dot(N,V), 0.0), F0, roughness) * fresnel;
-    vec3 kD = 1.0 - kS;
-    vec3 irradiance = textureCube(irradianceMap, N).rgb;
-    vec3 diffuse = irradiance * albedo;
-
-    vec3 R = reflect(-V, N);
-    vec3 prefilteredColor = getPrefilteredColor(roughness, R, irradianceMap, specularMap, envMap);
-    float NdotV = min(max(dot(N,V), 0.0),  0.95);
-    vec2 envBRDF = texture2D(brdfMap, vec2(NdotV,roughness)).xy;
-    vec3 indirectSpecular = prefilteredColor * (kS * envBRDF.x + envBRDF.y);
-
-    return kD * diffuse + indirectSpecular * max(shadowColor, vec3(0.5, 0.5, 0.5));
-}`, [fresnelSchlickRoughness, getPrefilteredColor]);
-
-export const applyConvolution = new ShaderFunction('vec4', 'applyConvolution', 'sampler2D texture, vec2 texCoord, vec2 texSize, float[9] convMatrix, float radius',
-    `
-{
-    vec2 onePixel = vec2(1.0,1.0) / texSize * radius;
-    vec4 colorSum = 
-        texture2D(texture, texCoord + onePixel * vec2(-1, -1)) * convMatrix[0] +
-        texture2D(texture, texCoord + onePixel * vec2( 0, -1)) * convMatrix[1] +
-        texture2D(texture, texCoord + onePixel * vec2( 1, -1)) * convMatrix[2] +
-        texture2D(texture, texCoord + onePixel * vec2(-1,  0)) * convMatrix[3] +
-        texture2D(texture, texCoord + onePixel * vec2( 0,  0)) * convMatrix[4] +
-        texture2D(texture, texCoord + onePixel * vec2( 1,  0)) * convMatrix[5] +
-        texture2D(texture, texCoord + onePixel * vec2(-1,  1)) * convMatrix[6] +
-        texture2D(texture, texCoord + onePixel * vec2( 0,  1)) * convMatrix[7] +
-        texture2D(texture, texCoord + onePixel * vec2( 1,  1)) * convMatrix[8];
-    float kernelWeight =
-        convMatrix[0] +
-        convMatrix[1] +
-        convMatrix[2] +
-        convMatrix[3] +
-        convMatrix[4] +
-        convMatrix[5] +
-        convMatrix[6] +
-        convMatrix[7] +
-        convMatrix[8];
-    if (kernelWeight <= 0.0) {
-        kernelWeight = 1.0;
-    }
-    return vec4((colorSum / kernelWeight).rgb, 1.0);
-}
-`, []);
-
-export const getShadowColor = new ShaderFunction('vec3', 'getShadowColor', 'vec4 positionFromLightPov, sampler2D shadowMap, float shadowBias, float shadowStrength',
-`
-{
-    // The vertex location rendered from the light source is almost in
-    // normalized device coordinates (NDC), but the perspective division
-    // has not been performed yet. We need to divide by w to get the
-    // vertex location in range [-1, +1]
-    vec3 shadowCoord = positionFromLightPov.xyz / positionFromLightPov.w;
-
-    // Convert from NDC to texture coordinates
-    shadowCoord = shadowCoord * 0.5 + 0.5;
-    
-    if (shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 &&
-        shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0)
-    {
-        float shadowDepth = texture2D(shadowMap, shadowCoord.xy).r;
-        if (shadowCoord.z > shadowDepth + shadowBias) {
-            return vec3(1.0 - shadowStrength);
-        }
-    }
-    return vec3(1.0);
-}
-`, []);

package/tools/BinaryResourceProvider.js

@@ -1,15 +0,0 @@
-
-import ResourceProvider from "./ResourceProvider.js";
-
-export default class BinaryResourceProvider extends ResourceProvider {
-    async load(url) {
-        const response = await fetch(url);
-        if (response.ok) {
-            const binaryData = await response.arrayBuffer();
-            return binaryData;
-        }
-        else {
-            throw new Error(`Resource not found at '${ url }'`);
-        }
-    }
-}

package/tools/ImageResourceProvider.js

@@ -1,65 +0,0 @@
-
-import ResourceProvider from "./ResourceProvider.js";
-import { generateUUID } from "./crypto.js";
-
-// In this array we keep a reference to the images being loaded to
-// prevent them from being deleted from memory
-const g_preventImageDump = [];
-
-const beginLoadImage = (img) => {
-    if (g_preventImageDump.indexOf(img) === -1) {
-        g_preventImageDump.push(img);
-    }
-};
-
-const endLoadImage = (img) => {
-    const i = g_preventImageDump.indexOf(img);
-    if (i !== -1) {
-        g_preventImageDump.splice(i, 1);
-    }
-}
-
-const loadImage = (url,preventCache = false) => {
-    return new Promise((resolve,reject) => {
-        const img = new Image();
-        beginLoadImage(img);
-        img.crossOrigin = "";
-        img.addEventListener("load", evt => {
-            endLoadImage(evt.target);
-            resolve(evt.target);
-        });
-        img.addEventListener("error", evt => {
-            endLoadImage(evt.target);
-            reject(new Error(`Error loading image '${ url }'.`));
-        });
-        img.addEventListener("abort", evt => {
-            endLoadImage(evt.target);
-            reject(new Error(`Image load aborted '${ url }'.`));
-        });
-        img.src = url + (preventCache ? `?${generateUUID()}` : "");
-    })
-}
-
-export default class ImageResourceProvider extends ResourceProvider {
-    async load(url) {
-        const img = await loadImage(url, false);
-        return img;
-    }
-
-    async write(url,img) {
-        let data = null;
-        if (img instanceof Image) {
-            // TODO: convert to Uint8Array data
-        }
-        else if (typeof(img) === "string" && /base64/i.test(img)) {
-            // Convert base64 image into Uint8Array data
-        }
-        else if (typeof(img) === "string") {
-            // Path: copy image
-        }
-        else {
-            throw new Error("Unsupported image type specified for write");
-        }
-        return await this.writeStrategy.writeData(url,data);
-    }
-}

package/tools/MaterialModifier.js

@@ -1,228 +0,0 @@
-import {
-    deserializeColorTexture,
-    deserializeVector,
-    deserializeValueTexture
-} from "../base/Material";
-import Texture from "../base/Texture";
-
-const checkImageData = (texture) => {
-    return texture instanceof Texture ? texture.loadImageData() : Promise.resolve();
-}
-
-export default class MaterialModifier {
-    constructor(jsonData = null) {
-        if (jsonData) {
-            if (jsonData['class'] && jsonData['class'] !== "PBRMaterial") {
-                console.warn(`Could not apply material modifier because of class "${jsonData['class']}". Check the valid material types in bg2 engine v2`);
-                return;
-            }
-            if (jsonData.alphaCutoff !== undefined) {
-                this.alphaCutoff = jsonData.alphaCutoff;
-            }
-
-            if (jsonData.castShadows !== undefined) {
-                this.castShadows = jsonData.castShadows;
-            }
-
-            if (jsonData.diffuse !== undefined) {
-                this.diffuse = jsonData.diffuse;
-            }
-
-            if (jsonData.diffuseScale !== undefined) {
-                this.diffuseScale = jsonData.diffuseScale;
-            }
-
-            if (jsonData.fresnel !== undefined) {
-                this.fresnel = jsonData.fresnel;
-            }
-
-            if (jsonData.isTransparent !== undefined) {
-                this.isTransparent = jsonData.isTransparent;
-            }
-
-            if (jsonData.lightEmission !== undefined) {
-                this.lightEmission = jsonData.lightEmission;
-            }
-
-            if (jsonData.lightEmissionChannel !== undefined) {
-                this.lightEmissionChannel = jsonData.lightEmissionChannel;
-            }
-
-            if (jsonData.lightEmissionScale !== undefined) {
-                this.lightEmissionScale = jsonData.lightEmissionScale;
-            }
-
-            if (jsonData.metallic !== undefined) {
-                this.metallic = jsonData.metallic;
-            }
-
-            if (jsonData.metallicChannel !== undefined) {
-                this.metallicChannel = jsonData.metallicChannel;
-            }
-
-            if (jsonData.metallicScale !== undefined) {
-                this.metallicScale = jsonData.metallicScale;
-            }
-
-            if (jsonData.normal !== undefined) {
-                this.normal = jsonData.normal;
-            }
-
-            if (jsonData.normalScale !== undefined) {
-                this.normalScale = jsonData.normalScale;
-            }
-
-            if (jsonData.roughness !== undefined) {
-                this.roughness = jsonData.roughness;
-            }
-
-            if (jsonData.roughnessChannel !== undefined) {
-                this.roughnessChannel = jsonData.roughnessChannel;
-            }
-
-            if (jsonData.roughnessScale !== undefined) {
-                this.roughnessScale = jsonData.roughnessScale;
-            }
-
-            if (jsonData.unlit !== undefined) {
-                this.unlit = jsonData.unlit;
-            }
-
-        }
-    }
-
-    get alphaCutoff() { return this._alphaCutoff; }
-    set alphaCutoff(v) { this._alphaCutoff = v; }
-
-    get castShadows() { return this._castShadows; }
-    set castShadows(v) { this._castShadows = v; }
-
-    get diffuse() { return this._diffuse; }
-    set diffuse(v) { this._diffuse = v; }
-
-    get diffuseScale() { return this._diffuseScale; }
-    set diffuseScale(v) { this._diffuseScale = v; }
-
-    get fresnel() { return this._fresnel; }
-    set fresnel(v) { this._fresnel = v; }
-
-    get isTransparent() { return this._isTransparent; }
-    set isTransparent(v) { this._isTransparent = v; }
-
-    get lightEmission() { return this._lightEmission; }
-    set lightEmission(v) { this._lightEmission = v; }
-
-    get lightEmissionChannel() { return this._lightEmissionChannel; }
-    set lightEmissionChannel(v) { this._lightEmissionChannel = v; }
-
-    get lightEmissionScale() { return this._lightEmissionScale; }
-    set lightEmissionScale(v) { this._lightEmissionScale = v; }
-
-    get metallic() { return this._metallic; }
-    set metallic(v) { this._metallic = v; }
-
-    get metallicChannel() { return this._metallicChannel; }
-    set metallicChannel(v) { this._metallicChannel = v; }
-
-    get metallicScale() { return this._metallicScale; }
-    set metallicScale(v) { this._metallicScale = v; }
-
-    get normal() { return this._normal; }
-    set normal(v) { this._normal = v; }
-
-    get normalScale() { return this._normalScale; }
-    set normalScale(v) { this._normalScale = v; }
-
-    get roughness() { return this._roughness; }
-    set roughness(v) { this._roughness = v; }
-
-    get roughnessChannel() { return this._roughnessChannel; }
-    set roughnessChannel(v) { this._roughnessChannel = v; }
-
-    get roughnessScale() { return this._roughnessScale; }
-    set roughnessScale(v) { this._roughnessScale = v; }
-
-    get unlit() { return this._unlit; }
-    set unlit(v) { this._unlit = v; }
-
-    async applyModifier(material, relativePath = "") {
-        const promises = [];
-        if (this.alphaCutoff !== undefined) {
-            material.alphaCutoff = this.alphaCutoff;
-        }
-
-        if (this.castShadows !== undefined) {
-            material.castShadows = this.castShadows;
-        }
-
-        if (this.diffuse !== undefined) {
-            material.diffuse = deserializeColorTexture(this.diffuse, relativePath);
-            promises.push(checkImageData(material.diffuse));
-        }
-
-        if (this.diffuseScale !== undefined) {
-            material.diffuseScale = deserializeVector(this.diffuseScale);
-        }
-
-        if (this.fresnel !== undefined) {
-            material.fresnel = deserializeVector(this.fresnel);
-        }
-
-        if (this.isTransparent !== undefined) {
-            material.isTransparent = this.isTransparent;
-        }
-
-        if (this.lightEmission !== undefined) {
-
-        }
-
-        if (this.lightEmissionChannel !== undefined) {
-
-        }
-
-        if (this.lightEmissionScale !== undefined) {
-
-        }
-
-        if (this.metallic !== undefined) {
-            material.metallic = deserializeValueTexture(this.metallic, relativePath);
-            promises.push(checkImageData(material.metallic));
-        }
-
-        if (this.metallicChannel !== undefined) {
-            material.metallicChannel = this.metallicChannel;
-        }
-
-        if (this.metallicScale !== undefined) {
-            material.metallicScale = deserializeVector(this.metallicScale);
-        }
-
-        if (this.normal !== undefined) {
-            material.normal = deserializeColorTexture(this.normal, relativePath);
-            promises.push(checkImageData(material.normal));
-        }
-
-        if (this.normalScale !== undefined) {
-            material.normalScale = deserializeVector(this.normalScale);
-        }
-
-        if (this.roughness !== undefined) {
-            material.roughness = deserializeValueTexture(this.roughness, relativePath);
-            promises.push(checkImageData(material.roughness));
-        }
-
-        if (this.roughnessChannel !== undefined) {
-            material.roughnessChannel = this.roughnessChannel;
-        }
-
-        if (this.roughnessScale !== undefined) {
-            material.roughnessScale = deserializeVector(this.roughnessScale);
-        }
-
-        if (this.unlit !== undefined) {
-            material.unlit = this.unlit;
-        }
-        await Promise.allSettled(promises);
-    }
-
-}

package/tools/Resource.js

@@ -1,177 +0,0 @@
-
-import ImageResourceProvider from "./ImageResourceProvider.js";
-import VideoResourceProvider from "./VideoResourceProvider.js";
-import BinaryResourceProvider from "./BinaryResourceProvider.js";
-import TextResourceProvider from "./TextResourceProvider.js";
-
-export const ResourceType = {
-    PolyList: 'PolyList',   // Array of meshes
-    Drawable: 'Drawable',
-    Node: 'Node',
-    Texture: 'Texture',
-    Material: 'Material'
-};
-
-export const getExtension = (url) => {
-    const reResult = /\.([a-z0-9]+)$/i.exec(url);
-    if (reResult) {
-        return reResult[1];
-    }
-    else {
-        return "";
-    }
-}
-
-export const getFileName = (url) => {
-    const reResult = /(.+)\/(.+)$/.exec(url);
-    if (reResult) {
-        return reResult[2];
-    }
-    else {
-        return url;
-    }
-}
-
-export const removeExtension = (url) => {
-    const reResult = /(.+)\.(.+)$/.exec(url);
-    if (reResult) {
-        return reResult[1];
-    }
-    else {
-        return url;
-    }
-}
-
-export const removeFileName = (url) => {
-    const i = url.lastIndexOf('/');
-    if (i != -1) {
-        return url.substring(0,i + 1);
-    }
-    return url;
-}
-
-export const isAbsolute = (url) => {
-    return /^http|^\//i.test(url);
-}
-
-export const jointUrl = (base,append) => {
-    if (base[base.length - 1] !== '/' && append[0] !== '/') {
-        return `${base}/${append}`;
-    }
-    else if ((base[base.length - 1] === '/' && append[0] !== '/') ||
-             (base[base.length - 1] !== '/' && append[0] === '/')) {
-        return `${base}${append}`;
-    }
-    else {
-        return `${base}${append.slice(1)}`;
-    }
-}
-
-export const isFormat = (url,formats) => formats.some(fmt => (new RegExp(`\.${fmt}`,'i')).test(url));
-
-export const addFormats = (fmts, dst) => {
-    if (!Array.isArray(fmts)) {
-        fmts = [fmts]
-    }
-    fmts.forEach(fmt => {
-        if (dst.indexOf(fmt) === -1) {
-            dst.push(fmt);
-        }
-    });
-}
-
-
-const g_validImageFormats = [
-    "jpg",
-    "jpeg",
-    "gif",
-    "png"
-];
-
-export const isValidImage = (url) => isFormat(url,g_validImageFormats);
-
-export const addImageFormats = (fmts) => {
-    addFormats(fmts, g_validImageFormats);
-}
-
-export const getValidImageFormats = () => g_validImageFormats;
-
-const g_validVideoFormats = [
-    "mp4",
-    "m4v"
-];
-
-export const isValidVideo = (url) => isFormat(url,g_validVideoFormats);
-
-export const addVideoFormats = (fmts) => {
-    addFormats(fmts, g_validVideoFormats);
-}
-
-export const getValidVideoFormats = () => g_validVideoFormats;
-
-const g_validBinaryFormats = [
-    "vwglb",
-    "bg2"
-];
-
-export const isValidBinary = (url) => isFormat(url, g_validBinaryFormats);
-
-export const addBinaryFormats = (fmts) => {
-    addFormats(fmts, g_validBinaryFormats);
-}
-
-export const getValidBinaryFormats = () => g_validBinaryFormats;
-
-export default class Resource {
-
-    constructor({
-        imageProvider = null,
-        videoProvider = null,
-        binaryProvider = null,
-        textProvider = null,
-        writeStrategy = null
-    } = {}) {
-        this._imageProvider = imageProvider || new ImageResourceProvider();
-        this._videoProvider = videoProvider || new VideoResourceProvider();
-        this._binaryProvider = binaryProvider || new BinaryResourceProvider();
-        this._textProvider = textProvider || new TextResourceProvider();
-        this.writeStrategy = writeStrategy;
-    }
-
-    set writeStrategy(ws) {
-        this._writeStrategy = ws;
-
-        this._imageProvider.writeStrategy = ws;
-        this._videoProvider.writeStrategy = ws;
-        this._binaryProvider.writeStrategy = ws;
-        this._textProvider.writeStrategy = ws;
-    }
-
-    get writeStrategy() {
-        return this._writeStrategy;
-    }
-
-    getProvider(url) {
-        switch (true) {
-        case isValidImage(url):
-            return this._imageProvider;
-        case isValidVideo(url):
-            return this._videoProvider;
-        case isValidBinary(url):
-            return this._binaryProvider;
-        default:
-            return this._textProvider;
-        }
-    }
-
-    async load(url) {
-        const provider = this.getProvider(url);
-        const data = await provider.load(url);
-        return data;
-    }
-
-    async write(url,data) {
-        const provider = this.getProvider(url);
-        return await provider.write(url,data);
-    }
-}