Merge pull request #235 from vimaec/sroberge/2_0_2a

Sroberge/2 0 2a

Author: vim-sroberge

package.json

@@ -1,6 +1,6 @@
 {
   "name": "vim-webgl-viewer",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "A high-performance 3D viewer and VIM file loader built on top of Three.JS.",
   "files": [
     "dist"

src/images.ts

@@ -10,7 +10,11 @@ export * from './vim-loader/legacy/vimRequest'
 export * from './vim-loader/geometry'
 export type { PointerMode, InputScheme } from './vim-webgl-viewer/inputs/input'
 export { DefaultInputScheme, KEYS } from './vim-webgl-viewer/inputs/input'
-export * from './vim-webgl-viewer/viewerSettings'
+
+export * from './vim-webgl-viewer/settings/viewerSettings'
+export * from './vim-webgl-viewer/settings/viewerSettingsParsing'
+export * from './vim-webgl-viewer/settings/defaultViewerSettings'
+
 export {
   RaycastResult as HitTestResult,
   InputAction

src/index.ts

@@ -1,5 +1,4 @@
-import {Viewer, open, THREE} from '.'
-
+import {Viewer, open, THREE, getViewerSettingsFromUrl} from '.'
 
 // Parse URL for source file
 const params = new URLSearchParams(window.location.search)
@@ -8,10 +7,14 @@ const url = params.has('vim')
   : null
 
 let time: number
-const viewer = new Viewer()
+
+const viewer = new Viewer(getViewerSettingsFromUrl(window.location.search))
 
 load(url ?? "https://vim02.azureedge.net/samples/residence.v1.2.75.vim")
-// load(url ?? "https://vim02.azureedge.net/samples/residence.v1.2.75.vimx")
+//load(url ?? "https://vimdevelopment01storage.blob.core.windows.net/samples/TowerS-ARCHITECTURE-ALL.v1.2.50.vimx")
+//load(url ?? "https://vimdevelopment01storage.blob.core.windows.net/samples/BIM1-AUTOP_ARC_2023.vimx")
+
+
 addLoadButton()
 
 
@@ -21,21 +24,20 @@ async function load (url: string | ArrayBuffer) {
 
   const vim = await open(url,
     {
-      legacy : true,
       rotation: new THREE.Vector3(270, 0, 0)
     }, (p) => console.log(`Downloading Vim (${(p.loaded / 1000).toFixed(0)} kb)`) 
   ) 
   viewer.add(vim)
 
-
   vim.loadAll().then(() =>{
     viewer.gizmos.loading.visible = false
     console.log(`loaded in ${(Date.now() - time) / 1000} seconds`)
   })
-  
+
   viewer.camera.snap(true).frame(vim)
 
   // Useful for debuging in console.
+  globalThis.THREE = THREE
   globalThis.vim = vim
   globalThis.viewer = viewer
 }

src/main.ts

@@ -6,23 +6,24 @@ import * as THREE from 'three'
 import { MergedSubmesh, Submesh } from './mesh'
 import { Vim } from './vim'
 import { InsertableSubmesh } from './progressive/insertableSubmesh'
+import { AttributeTarget } from './objectAttributes'
 
 export class ColorAttribute {
   readonly vim: Vim
-  private _meshes: Submesh[] | undefined
+  private _meshes: AttributeTarget[] | undefined
   private _value: THREE.Color | undefined
 
   constructor (
-    meshes: Submesh[] | undefined,
+    meshes: AttributeTarget[] | undefined,
     value: THREE.Color | undefined,
-    vim: Vim
+    vim: Vim | undefined
   ) {
     this._meshes = meshes
     this._value = value
     this.vim = vim
   }
 
-  updateMeshes (meshes: Submesh[] | undefined) {
+  updateMeshes (meshes: AttributeTarget[] | undefined) {
     this._meshes = meshes
     if (this._value !== undefined) {
       this.apply(this._value)
@@ -154,7 +155,7 @@ export class ColorAttribute {
    * @param index index of the instanced instance
    * @param color rgb representation of the color to apply
    */
-  private applyInstancedColor (sub: Submesh, color: THREE.Color | undefined) {
+  private applyInstancedColor (sub: AttributeTarget, color: THREE.Color | undefined) {
     const colors = this.getOrAddInstanceColorAttribute(
       sub.three as THREE.InstancedMesh
     )
@@ -169,7 +170,13 @@ export class ColorAttribute {
   }
 
   private getOrAddInstanceColorAttribute (mesh: THREE.InstancedMesh) {
-    if (mesh.instanceColor) return mesh.instanceColor
+    if (mesh.instanceColor &&
+      mesh.instanceColor.count <= mesh.instanceMatrix.count
+    ){
+      return mesh.instanceColor
+    }
+        
+    // mesh.count is not always === to capacity so we use instanceMatrix.count
     const count = mesh.instanceMatrix.count
     // Add color instance attribute
     const colors = new Float32Array(count * 3)

src/vim-loader/colorAttributes.ts

@@ -0,0 +1,103 @@
+/**
+ * @module vim-loader/materials
+ */
+
+import * as THREE from 'three'
+
+/**
+ * Material for isolation mode
+ * Non visible item appear as transparent.
+ * Visible items are flat shaded with a basic pseudo lighting.
+ * Supports object coloring for visible objects.
+ * Non-visible objects use fillColor.
+ */
+export function createSimpleMaterial () {
+  return new THREE.ShaderMaterial({
+    uniforms: {
+      opacity: { value: 0.1 },
+      fillColor: { value: new THREE.Vector3(0, 0, 0) }
+    },
+    vertexColors: true,
+    //transparent: true,
+    clipping: true,
+    vertexShader: /* glsl */ `
+
+      #include <common>
+      #include <logdepthbuf_pars_vertex>
+      #include <clipping_planes_pars_vertex>
+        
+      // VISIBILITY
+      // Instance or vertex attribute to hide objects
+      // Used as instance attribute for instanced mesh and as vertex attribute for merged meshes. 
+      attribute float ignore;
+
+      // Passed to fragment to discard them
+      varying float vIgnore;
+      varying vec3 vPosition;
+
+
+      // COLORING
+      varying vec3 vColor;
+
+      // attribute for color override
+      // merged meshes use it as vertex attribute
+      // instanced meshes use it as an instance attribute
+      attribute float colored;
+
+      // There seems to be an issue where setting mehs.instanceColor
+      // doesn't properly set USE_INSTANCING_COLOR
+      // so we always use it as a fix
+      #ifndef USE_INSTANCING_COLOR
+        attribute vec3 instanceColor;
+      #endif
+
+      void main() {
+        #include <begin_vertex>
+        #include <project_vertex>
+        #include <clipping_planes_vertex>
+        #include <logdepthbuf_vertex>
+
+        // VISIBILITY
+        // Set frag ignore from instance or vertex attribute
+        vIgnore = ignore;
+
+        // COLORING
+        vColor = color.xyz;
+
+        // colored == 1 -> instance color
+        // colored == 0 -> vertex color
+        #ifdef USE_INSTANCING
+          vColor.xyz = colored * instanceColor.xyz + (1.0f - colored) * color.xyz;
+        #endif
+
+        gl_Position.z = -10.0f;
+        
+        // LIGHTING
+        vPosition = vec3(mvPosition ) / mvPosition .w;
+      }
+      `,
+    fragmentShader: /* glsl */ `
+      #include <clipping_planes_pars_fragment>
+      varying float vIgnore;
+      varying vec3 vPosition;
+      varying vec3 vColor;
+
+      void main() {
+        #include <clipping_planes_fragment>
+
+        if (vIgnore > 0.0f){
+          discard;
+        }
+        else{ 
+          gl_FragColor = vec4(vColor.x, vColor.y, vColor.z, 1.0f);
+
+          // LIGHTING
+          vec3 normal = normalize( cross(dFdx(vPosition), dFdy(vPosition)) );
+          float light = dot(normal, normalize(vec3(1.4142f, 1.732f, 2.2360f)));
+          light = 0.5 + (light *0.5);
+          gl_FragColor.xyz *= light;
+        }
+      }
+      `
+  })
+}

src/vim-loader/materials/simpleMaterial.ts

@@ -9,6 +9,39 @@ import * as THREE from 'three'
  */
 export type ShaderUniforms = { [uniform: string]: THREE.IUniform<any> }
 
+export function createOpaque(){
+  return new StandardMaterial(createBasicOpaque())
+}
+
+export function createTransparent(){
+  return new StandardMaterial(createBasicTransparent())
+}
+
+/**
+ * Creates a new instance of the default loader opaque material.
+ * @returns {THREE.MeshPhongMaterial} A new instance of MeshPhongMaterial with transparency.
+ */
+export function createBasicOpaque () {
+  return new THREE.MeshPhongMaterial({
+    color: 0x999999,
+    vertexColors: true,
+    flatShading: true,
+    side: THREE.DoubleSide,
+    shininess: 5
+  })
+}
+
+/**
+ * Creates a new instance of the default loader transparent material.
+ * @returns {THREE.MeshPhongMaterial} A new instance of MeshPhongMaterial with transparency.
+ */
+export function createBasicTransparent () {
+  const mat = createBasicOpaque()
+  mat.transparent = true
+  mat.shininess = 70
+  return mat
+}
+
 /**
  * Material used for both opaque and tranparent surfaces of a VIM model.
  */

src/vim-loader/materials/standardMaterial.ts

@@ -3,12 +3,13 @@
  */
 
 import * as THREE from 'three'
-import { StandardMaterial } from './standardMaterial'
+import { StandardMaterial, createOpaque, createTransparent } from './standardMaterial'
 import { createMaskMaterial } from './maskMaterial'
 import { createIsolationMaterial } from './isolationMaterial'
 import { OutlineMaterial } from './outlineMaterial'
-import { Settings } from '../../vim-webgl-viewer/viewerSettings'
+import { ViewerSettings } from '../../vim-webgl-viewer/settings/viewerSettings'
 import { MergeMaterial } from './mergeMaterial'
+import { createSimpleMaterial } from './simpleMaterial'
 import { SignalDispatcher } from 'ste-signals'
 
 /**
@@ -29,19 +30,23 @@ export class ViewerMaterials {
   }
 
   /**
-   * Material used for opaque model geometry
+   * Material used for opaque model geometry.
    */
   opaque: StandardMaterial
   /**
-   * Material used for transparent model geometry
+   * Material used for transparent model geometry.
    */
   transparent: StandardMaterial
   /**
-   * Material used when creating wireframe geometry of the model
+   * Material used for maximum performance.
+   */
+  simple: THREE.Material
+  /**
+   * Material used when creating wireframe geometry of the model.
    */
   wireframe: THREE.LineBasicMaterial
   /**
-   * Material used to show traces of hidden objects
+   * Material used to show traces of hidden objects.
    */
   isolation: THREE.Material
   /**
@@ -69,15 +74,16 @@ export class ViewerMaterials {
   constructor (
     opaque?: StandardMaterial,
     transparent?: StandardMaterial,
+    simple?: THREE.Material,
     wireframe?: THREE.LineBasicMaterial,
     isolation?: THREE.Material,
     mask?: THREE.ShaderMaterial,
     outline?: OutlineMaterial,
-    merge?: MergeMaterial,
-    grid?: THREE.ShaderMaterial
+    merge?: MergeMaterial
   ) {
-    this.opaque = opaque ?? new StandardMaterial(createOpaque())
-    this.transparent = transparent ?? new StandardMaterial(createTransparent())
+    this.opaque = opaque ?? createOpaque()
+    this.transparent = transparent ?? createTransparent()
+    this.simple = simple ?? createSimpleMaterial()
     this.wireframe = wireframe ?? createWireframe()
     this.isolation = isolation ?? createIsolationMaterial()
     this.mask = mask ?? createMaskMaterial()
@@ -87,9 +93,9 @@ export class ViewerMaterials {
 
   /**
    * Updates material settings based on the provided configuration.
-   * @param {Settings} settings - The settings to apply to the materials.
+   * @param {ViewerSettings} settings - The settings to apply to the materials.
    */
-  applySettings (settings: Settings) {
+  applySettings (settings: ViewerSettings) {
     this.isolationOpacity = settings.materials.isolation.opacity
     this.isolationColor = settings.materials.isolation.color
 
@@ -325,31 +331,6 @@ export class ViewerMaterials {
   }
 }
 
-/**
- * Creates a new instance of the default loader opaque material.
- * @returns {THREE.MeshPhongMaterial} A new instance of MeshPhongMaterial with transparency.
- */
-export function createOpaque () {
-  return new THREE.MeshPhongMaterial({
-    color: 0x999999,
-    vertexColors: true,
-    flatShading: true,
-    side: THREE.DoubleSide,
-    shininess: 5
-  })
-}
-
-/**
- * Creates a new instance of the default loader transparent material.
- * @returns {THREE.MeshPhongMaterial} A new instance of MeshPhongMaterial with transparency.
- */
-export function createTransparent () {
-  const mat = createOpaque()
-  mat.transparent = true
-  mat.shininess = 70
-  return mat
-}
-
 /**
  * Creates a new instance of the default wireframe material.
  * @returns {THREE.LineBasicMaterial} A new instance of LineBasicMaterial.

src/vim-loader/materials/viewerMaterials.ts

@@ -164,7 +164,20 @@ export class Mesh {
 }
 
 export type MergedSubmesh = StandardSubmesh | InsertableSubmesh
-export type Submesh = MergedSubmesh | InstancedSubmesh
+export type Submesh = MergedSubmesh | InstancedSubmesh 
+
+export class SimpleInstanceSubmesh
+{
+  mesh: THREE.InstancedMesh
+  get three() {return this.mesh} 
+  index : number
+  readonly merged = false
+
+  constructor(mesh: THREE.InstancedMesh, index : number){
+    this.mesh = mesh
+    this.index = index
+  }
+}
 
 export class StandardSubmesh {
   mesh: Mesh