@xeokit/xeokit-sdk 2.6.85-renderers-refactor-v1 → 2.6.86-beta.0

package/src/plugins/CxConverterIFCLoaderPlugin/CxConverterIFCLoaderPlugin.js

@@ -1,86 +0,0 @@
-import { Plugin } from "../../viewer/Plugin.js";
-import { GLTFLoaderPlugin } from "../GLTFLoaderPlugin/GLTFLoaderPlugin.js";
-import { ifc2gltf } from "@creooxag/cxconverter";
-
-/**
- * Fetches a file from the given URL and returns its contents as text.
- *
- * @param {string} url - The URL to fetch the file from.
- * @returns {Promise<string>} A promise that resolves to the file contents.
- * @private
- */
-async function fetchFile(url) {
-    try {
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`HTTP error! Status: ${response.status}`);
-        }
-        return response.text();
-    } catch (error) {
-        console.error('Error fetching file:', error);
-    }
-}
-
-/**
- * {@link Viewer} plugin that uses [CxConverter](https://github.com/Creoox/cxconverter) to load BIM models directly from IFC files, using its WebAssembly buid from [npm package](https://www.npmjs.com/package/@creooxag/cxconverter).
- *
- * ## Overview
- * The WebAssembly build of CxConverter is still in alfa stage, so it may not work as expected. This documentation will be updated as the library and the plugin evolve. The example below shows how to use the plugin:
- * ````javascript
- * import { CxConverterIFCLoaderPlugin, Viewer } from "../../dist/xeokit-sdk.es.js";
- * const cxConverterIFCLoaderPlugin = new CxConverterIFCLoaderPlugin(viewer);
- * 
- * const sceneModel = await cxConverterIFCLoaderPlugin.load({
- *        src: "../../assets/models/ifc/Duplex.ifc"
- * }); 
- * ````
-    See the code in action [here](https://xeokit.github.io/xeokit-sdk/examples/buildings/#cxConverterIFC_vbo_Duplex).
- */
-
-class CxConverterIFCLoaderPlugin extends Plugin {
-    /**
-     * @constructor
-     * @param {Viewer} viewer The Viewer.
-     * @param {Object} [cfg={}] Plugin configuration.
-     */
-    constructor(viewer, cfg = {}) {
-        super("ifcLoader", viewer, cfg);
-
-        /**
-         * The GLTFLoaderPlugin used internally to load the converted GLTF.
-         * @type {GLTFLoaderPlugin}
-         */
-        this.gltfLoader = new GLTFLoaderPlugin(this.viewer);
-    }
-
-    /**
-     * Loads an IFC model from the given source.
-     *
-     * @param {Object} [params={}] Loading parameters.
-     * @param {string} params.src Path to an IFC file.
-     * @param {Function} [params.progressCallback] Callback to track loading progress.
-     * @param {Function} [params.progressTextCallback] Callback to track loading progress with text updates.
-     * @returns {Promise<SceneModel>} A promise that resolves to the loaded SceneModel.
-     */
-    async load(params = {}) {
-        if (!params.src) {
-            this.error("load() param expected: src");
-        }
-        const data = await fetchFile(params.src);
-        const { gltf, metaData } = await ifc2gltf(
-            data,
-            {
-                remote: true,
-                progressCallback: params.progressCallback,
-                progressTextCallback: params.progressTextCallback
-            }
-        );
-        const sceneModel = this.gltfLoader.load({
-            id: "myModel",
-            gltf: gltf,
-            metaModelJSON: metaData
-        });
-        return sceneModel;
-    }
-}
-export { CxConverterIFCLoaderPlugin };

package/src/plugins/CxConverterIFCLoaderPlugin/index.js

@@ -1 +0,0 @@
-export * from "./CxConverterIFCLoaderPlugin.js";

package/src/viewer/scene/mesh/draw/LambertShaderSource.js

@@ -1,35 +0,0 @@
-import {createLightSetup} from "../../webgl/WebGLRenderer.js";
-
-export const LambertShaderSource = function(meshDrawHash, programVariables, geometry, material, scene) {
-    const lightSetup       = createLightSetup(programVariables, scene._lightsState);
-    const colorize         = programVariables.createUniform("vec4",  "colorize",         (set, state) => set(state.meshColorize));
-    const materialAlpha    = programVariables.createUniform("float", "materialAlpha",    (set, state) => set(state.material.alpha));
-    const materialColor    = programVariables.createUniform("vec3",  "materialColor",    (set, state) => set(state.material.color));
-    const materialEmissive = programVariables.createUniform("vec3",  "materialEmissive", (set, state) => set(state.material.emissive));
-    const vColor           = programVariables.createVarying("vec4", "vColor", () => {
-        const attributes = geometry.attributes;
-        const lightComponents = [
-            lightSetup.getAmbientColor()
-        ].concat(attributes.normal
-                 ? lightSetup.directionalLights.map(
-                     light => `(max(dot(${attributes.normal.view}, ${light.getDirection(geometry.viewMatrix, attributes.position.view)}), 0.0) * ${light.getColor()})`)
-                 : [ ]);
-        return `${colorize} * vec4((${lightComponents.join(" + ")}) * ${materialColor} + ${materialEmissive}, ${materialAlpha});`; // TODO: How to have ambient bright enough for canvas BG but not too bright for scene?
-    });
-    const outColor = programVariables.createOutput("vec4", "outColor");
-
-    return {
-        getHash: () => [
-            meshDrawHash,
-            scene.gammaOutput ? "go" : "",
-            lightSetup.getHash(),
-            material._state.hash
-        ],
-        programName: "Lambert",
-        canActAsBackground: true,
-        discardPoints: true,
-        setupPointSize: true,
-        setsLineWidth: true,
-        appendFragmentOutputs: (src, getGammaOutputExpression) => src.push(`${outColor} = ${getGammaOutputExpression ? getGammaOutputExpression(vColor) : vColor};`)
-    };
-};

package/src/viewer/scene/mesh/emphasis/EmphasisShaderSource.js

@@ -1,34 +0,0 @@
-import {createLightSetup} from "../../webgl/WebGLRenderer.js";
-
-export const EmphasisShaderSource = function(meshHash, programVariables, geometry, scene, isFill) {
-    const lightSetup = isFill && createLightSetup(programVariables, scene._lightsState);
-    const uColor = programVariables.createUniform("vec3",  "uColor", (set, state) => set(isFill ? state.material.fillColor : state.material.edgeColor));
-    const uAlpha = programVariables.createUniform("float", "uAlpha", (set, state) => set(isFill ? state.material.fillAlpha : state.material.edgeAlpha));
-    const vColor = programVariables.createVarying("vec4", "vColor", () => {
-        const attributes = geometry.attributes;
-        const lightComponents = isFill && [
-            lightSetup.getAmbientColor()
-        ].concat(attributes.normal
-                 ? lightSetup.directionalLights.map(
-                     light => `(max(dot(${attributes.normal.view}, ${light.getDirection(geometry.viewMatrix, attributes.position.view)}), 0.0) * ${light.getColor()})`)
-                 : [ ]);
-        // TODO: A blending mode for emphasis materials, to select add/multiply/mix
-        // `vec4((mix(reflectedColor, ${uColor}, 0.7)), ${uAlpha})`
-        return `vec4(${uColor}${lightComponents ? ` * (${lightComponents.join(" + ")})` : ""}, ${uAlpha})`;
-        // `${vColor} = vec4(reflectedColor + ${uColor}, ${uAlpha})`
-    });
-
-    const outColor = programVariables.createOutput("vec4", "outColor");
-    return {
-        getHash: () => [
-            meshHash,
-            scene.gammaOutput ? "go" : "", // Gamma input not needed
-            lightSetup && lightSetup.getHash()
-        ],
-        programName: isFill ? "EmphasisFill" : "EmphasisEdges",
-        dontSetFrontFace: true,
-        discardPoints: isFill,
-        drawEdges: ! isFill,
-        appendFragmentOutputs: (src, getGammaOutputExpression) => src.push(`${outColor} = ${getGammaOutputExpression ? getGammaOutputExpression(vColor) : vColor};`)
-    };
-};