@deck.gl/geo-layers 9.0.0-alpha.6 → 9.0.0-beta.1

package/dist/esm/mesh-layer/mesh-layer-vertex.glsl.js

@@ -17,7 +17,9 @@ in vec3 featureIdsPickingColors;
 // Instance attributes
 in vec4 instanceColors;
 in vec3 instancePickingColors;
-in mat3 instanceModelMatrix;
+in vec3 instanceModelMatrixCol0;
+in vec3 instanceModelMatrixCol1;
+in vec3 instanceModelMatrixCol2;
 
 // Outputs to fragment shader
 out vec2 vTexCoord;
@@ -45,6 +47,8 @@ void main(void) {
     geometry.pickingColor = instancePickingColors;
   }
 
+  mat3 instanceModelMatrix = mat3(instanceModelMatrixCol0, instanceModelMatrixCol1, instanceModelMatrixCol2);
+
   vTexCoord = uv;
   cameraPosition = project_uCameraPosition;
   vColor = vec4(colors * instanceColors.rgb, instanceColors.a);

package/dist/esm/mesh-layer/mesh-layer-vertex.glsl.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/mesh-layer/mesh-layer-vertex.glsl.ts"],"names":[],"mappings":"AAAA,eAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CA/EA","sourcesContent":["export default `#version 300 es\n#define SHADER_NAME simple-mesh-layer-vs\n\n// Scale the model\nuniform float sizeScale;\nuniform bool composeModelMatrix;\nuniform bool pickFeatureIds;\n\n// Primitive attributes\nin vec3 positions;\nin vec3 normals;\nin vec3 colors;\nin vec2 texCoords;\nin vec4 uvRegions;\nin vec3 featureIdsPickingColors;\n\n// Instance attributes\nin vec4 instanceColors;\nin vec3 instancePickingColors;\nin mat3 instanceModelMatrix;\n\n// Outputs to fragment shader\nout vec2 vTexCoord;\nout vec3 cameraPosition;\nout vec3 normals_commonspace;\nout vec4 position_commonspace;\nout vec4 vColor;\n\nvec2 applyUVRegion(vec2 uv) {\n  #ifdef HAS_UV_REGIONS\n    // https://github.com/Esri/i3s-spec/blob/master/docs/1.7/geometryUVRegion.cmn.md\n    return fract(uv) * (uvRegions.zw - uvRegions.xy) + uvRegions.xy;\n  #else\n    return uv;\n  #endif\n}\n\nvoid main(void) {\n  vec2 uv = applyUVRegion(texCoords);\n  geometry.uv = uv;\n\n  if (pickFeatureIds) {\n    geometry.pickingColor = featureIdsPickingColors;\n  } else {\n    geometry.pickingColor = instancePickingColors;\n  }\n\n  vTexCoord = uv;\n  cameraPosition = project_uCameraPosition;\n  vColor = vec4(colors * instanceColors.rgb, instanceColors.a);\n\n  vec3 pos = (instanceModelMatrix * positions) * sizeScale;\n  vec3 projectedPosition = project_position(positions);\n  position_commonspace = vec4(projectedPosition, 1.0);\n  gl_Position = project_common_position_to_clipspace(position_commonspace);\n\n  geometry.position = position_commonspace;\n  normals_commonspace = project_normal(instanceModelMatrix * normals);\n  geometry.normal = normals_commonspace;\n\n  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n\n  #ifdef MODULE_PBR\n    // set PBR data\n    pbr_vPosition = geometry.position.xyz;\n    #ifdef HAS_NORMALS\n      pbr_vNormal = geometry.normal;\n    #endif\n\n    #ifdef HAS_UV\n      pbr_vUV = uv;\n    #else\n      pbr_vUV = vec2(0., 0.);\n    #endif\n    geometry.uv = pbr_vUV;\n  #endif\n\n  DECKGL_FILTER_COLOR(vColor, geometry);\n}\n`;\n"],"file":"mesh-layer-vertex.glsl.js"}
+{"version":3,"sources":["../../../src/mesh-layer/mesh-layer-vertex.glsl.ts"],"names":[],"mappings":"AAAA,eAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAnFA","sourcesContent":["export default `#version 300 es\n#define SHADER_NAME simple-mesh-layer-vs\n\n// Scale the model\nuniform float sizeScale;\nuniform bool composeModelMatrix;\nuniform bool pickFeatureIds;\n\n// Primitive attributes\nin vec3 positions;\nin vec3 normals;\nin vec3 colors;\nin vec2 texCoords;\nin vec4 uvRegions;\nin vec3 featureIdsPickingColors;\n\n// Instance attributes\nin vec4 instanceColors;\nin vec3 instancePickingColors;\nin vec3 instanceModelMatrixCol0;\nin vec3 instanceModelMatrixCol1;\nin vec3 instanceModelMatrixCol2;\n\n// Outputs to fragment shader\nout vec2 vTexCoord;\nout vec3 cameraPosition;\nout vec3 normals_commonspace;\nout vec4 position_commonspace;\nout vec4 vColor;\n\nvec2 applyUVRegion(vec2 uv) {\n  #ifdef HAS_UV_REGIONS\n    // https://github.com/Esri/i3s-spec/blob/master/docs/1.7/geometryUVRegion.cmn.md\n    return fract(uv) * (uvRegions.zw - uvRegions.xy) + uvRegions.xy;\n  #else\n    return uv;\n  #endif\n}\n\nvoid main(void) {\n  vec2 uv = applyUVRegion(texCoords);\n  geometry.uv = uv;\n\n  if (pickFeatureIds) {\n    geometry.pickingColor = featureIdsPickingColors;\n  } else {\n    geometry.pickingColor = instancePickingColors;\n  }\n\n  mat3 instanceModelMatrix = mat3(instanceModelMatrixCol0, instanceModelMatrixCol1, instanceModelMatrixCol2);\n\n  vTexCoord = uv;\n  cameraPosition = project_uCameraPosition;\n  vColor = vec4(colors * instanceColors.rgb, instanceColors.a);\n\n  vec3 pos = (instanceModelMatrix * positions) * sizeScale;\n  vec3 projectedPosition = project_position(positions);\n  position_commonspace = vec4(projectedPosition, 1.0);\n  gl_Position = project_common_position_to_clipspace(position_commonspace);\n\n  geometry.position = position_commonspace;\n  normals_commonspace = project_normal(instanceModelMatrix * normals);\n  geometry.normal = normals_commonspace;\n\n  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);\n\n  #ifdef MODULE_PBR\n    // set PBR data\n    pbr_vPosition = geometry.position.xyz;\n    #ifdef HAS_NORMALS\n      pbr_vNormal = geometry.normal;\n    #endif\n\n    #ifdef HAS_UV\n      pbr_vUV = uv;\n    #else\n      pbr_vUV = vec2(0., 0.);\n    #endif\n    geometry.uv = pbr_vUV;\n  #endif\n\n  DECKGL_FILTER_COLOR(vColor, geometry);\n}\n`;\n"],"file":"mesh-layer-vertex.glsl.js"}

package/dist/esm/mesh-layer/mesh-layer.js

@@ -0,0 +1,178 @@
+import { parsePBRMaterial } from '@luma.gl/gltf';
+import { pbr } from '@luma.gl/shadertools';
+import { Model } from '@luma.gl/engine';
+import { GL } from '@luma.gl/constants';
+import { SimpleMeshLayer } from '@deck.gl/mesh-layers';
+import vs from './mesh-layer-vertex.glsl';
+import fs from './mesh-layer-fragment.glsl';
+
+function validateGeometryAttributes(attributes) {
+  const positionAttribute = attributes.positions || attributes.POSITION;
+  const vertexCount = positionAttribute.value.length / positionAttribute.size;
+  const hasColorAttribute = attributes.COLOR_0 || attributes.colors;
+
+  if (!hasColorAttribute) {
+    attributes.colors = {
+      size: 4,
+      value: new Uint8Array(vertexCount * 4).fill(255),
+      normalized: true
+    };
+  }
+}
+
+const defaultProps = {
+  pbrMaterial: {
+    type: 'object',
+    value: null
+  },
+  featureIds: {
+    type: 'array',
+    value: null,
+    optional: true
+  }
+};
+export default class MeshLayer extends SimpleMeshLayer {
+  getShaders() {
+    const shaders = super.getShaders();
+    const modules = shaders.modules;
+    modules.push(pbr);
+    return { ...shaders,
+      vs,
+      fs
+    };
+  }
+
+  initializeState() {
+    const {
+      featureIds
+    } = this.props;
+    super.initializeState();
+    const attributeManager = this.getAttributeManager();
+
+    if (featureIds) {
+      attributeManager.add({
+        featureIdsPickingColors: {
+          type: 5121,
+          size: 3,
+          noAlloc: true,
+          update: this.calculateFeatureIdsPickingColors
+        }
+      });
+    }
+  }
+
+  updateState(params) {
+    super.updateState(params);
+    const {
+      props,
+      oldProps
+    } = params;
+
+    if (props.pbrMaterial !== oldProps.pbrMaterial) {
+      this.updatePbrMaterialUniforms(props.pbrMaterial);
+    }
+  }
+
+  draw(opts) {
+    const {
+      featureIds
+    } = this.props;
+
+    if (!this.state.model) {
+      return;
+    }
+
+    this.state.model.setUniforms({
+      u_Camera: this.state.model.uniforms.project_uCameraPosition,
+      pickFeatureIds: Boolean(featureIds)
+    });
+    super.draw(opts);
+  }
+
+  getModel(mesh) {
+    const {
+      id,
+      pbrMaterial
+    } = this.props;
+    const parsedPBRMaterial = this.parseMaterial(pbrMaterial, mesh);
+    this.setState({
+      parsedPBRMaterial
+    });
+    const shaders = this.getShaders();
+    validateGeometryAttributes(mesh.attributes);
+    const model = new Model(this.context.device, { ...this.getShaders(),
+      id,
+      geometry: mesh,
+      bufferLayout: this.getAttributeManager().getBufferLayouts(),
+      defines: { ...shaders.defines,
+        ...(parsedPBRMaterial === null || parsedPBRMaterial === void 0 ? void 0 : parsedPBRMaterial.defines),
+        HAS_UV_REGIONS: mesh.attributes.uvRegions ? 1 : 0
+      },
+      parameters: parsedPBRMaterial === null || parsedPBRMaterial === void 0 ? void 0 : parsedPBRMaterial.parameters,
+      isInstanced: true
+    });
+    return model;
+  }
+
+  updatePbrMaterialUniforms(pbrMaterial) {
+    const {
+      model
+    } = this.state;
+
+    if (model) {
+      const {
+        mesh
+      } = this.props;
+      const parsedPBRMaterial = this.parseMaterial(pbrMaterial, mesh);
+      this.setState({
+        parsedPBRMaterial
+      });
+      model.setBindings(parsedPBRMaterial.bindings);
+      model.setUniforms(parsedPBRMaterial.uniforms);
+    }
+  }
+
+  parseMaterial(pbrMaterial, mesh) {
+    const unlit = Boolean(pbrMaterial.pbrMetallicRoughness && pbrMaterial.pbrMetallicRoughness.baseColorTexture);
+    return parsePBRMaterial(this.context.device, {
+      unlit,
+      ...pbrMaterial
+    }, {
+      NORMAL: mesh.attributes.normals,
+      TEXCOORD_0: mesh.attributes.texCoords
+    }, {
+      pbrDebug: false,
+      lights: true,
+      useTangents: false
+    });
+  }
+
+  calculateFeatureIdsPickingColors(attribute) {
+    const featureIds = this.props.featureIds;
+    const value = new Uint8ClampedArray(featureIds.length * attribute.size);
+    const pickingColor = [];
+
+    for (let index = 0; index < featureIds.length; index++) {
+      this.encodePickingColor(featureIds[index], pickingColor);
+      value[index * 3] = pickingColor[0];
+      value[index * 3 + 1] = pickingColor[1];
+      value[index * 3 + 2] = pickingColor[2];
+    }
+
+    attribute.value = value;
+  }
+
+  finalizeState(context) {
+    var _this$state$parsedPBR;
+
+    super.finalizeState(context);
+    (_this$state$parsedPBR = this.state.parsedPBRMaterial) === null || _this$state$parsedPBR === void 0 ? void 0 : _this$state$parsedPBR.generatedTextures.forEach(texture => texture.destroy());
+    this.setState({
+      parsedPBRMaterial: null
+    });
+  }
+
+}
+MeshLayer.layerName = 'MeshLayer';
+MeshLayer.defaultProps = defaultProps;
+//# sourceMappingURL=mesh-layer.js.map

package/dist/esm/mesh-layer/mesh-layer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/mesh-layer/mesh-layer.ts"],"names":["parsePBRMaterial","pbr","Model","GL","SimpleMeshLayer","vs","fs","validateGeometryAttributes","attributes","positionAttribute","positions","POSITION","vertexCount","value","length","size","hasColorAttribute","COLOR_0","colors","Uint8Array","fill","normalized","defaultProps","pbrMaterial","type","featureIds","optional","MeshLayer","getShaders","shaders","modules","push","initializeState","props","attributeManager","getAttributeManager","add","featureIdsPickingColors","noAlloc","update","calculateFeatureIdsPickingColors","updateState","params","oldProps","updatePbrMaterialUniforms","draw","opts","state","model","setUniforms","u_Camera","uniforms","project_uCameraPosition","pickFeatureIds","Boolean","getModel","mesh","id","parsedPBRMaterial","parseMaterial","setState","context","device","geometry","bufferLayout","getBufferLayouts","defines","HAS_UV_REGIONS","uvRegions","parameters","isInstanced","setBindings","bindings","unlit","pbrMetallicRoughness","baseColorTexture","NORMAL","normals","TEXCOORD_0","texCoords","pbrDebug","lights","useTangents","attribute","Uint8ClampedArray","pickingColor","index","encodePickingColor","finalizeState","generatedTextures","forEach","texture","destroy","layerName"],"mappings":"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","sourcesContent":["import type {NumericArray} from '@math.gl/core';\nimport {parsePBRMaterial, ParsedPBRMaterial} from '@luma.gl/gltf';\nimport {pbr} from '@luma.gl/shadertools';\nimport {Model} from '@luma.gl/engine';\nimport {GL} from '@luma.gl/constants';\nimport type {MeshAttribute, MeshAttributes} from '@loaders.gl/schema';\nimport type {UpdateParameters, DefaultProps, LayerContext} from '@deck.gl/core';\nimport {SimpleMeshLayer, SimpleMeshLayerProps} from '@deck.gl/mesh-layers';\n\nimport vs from './mesh-layer-vertex.glsl';\nimport fs from './mesh-layer-fragment.glsl';\n\nexport type Mesh = {\n  attributes: MeshAttributes;\n  indices?: MeshAttribute;\n};\n\nfunction validateGeometryAttributes(attributes: MeshAttributes) {\n  const positionAttribute = attributes.positions || attributes.POSITION;\n  const vertexCount = positionAttribute.value.length / positionAttribute.size;\n  const hasColorAttribute = attributes.COLOR_0 || attributes.colors;\n  if (!hasColorAttribute) {\n    attributes.colors = {\n      size: 4,\n      value: new Uint8Array(vertexCount * 4).fill(255),\n      normalized: true\n    };\n  }\n}\n\nconst defaultProps: DefaultProps<MeshLayerProps> = {\n  pbrMaterial: {type: 'object', value: null},\n  featureIds: {type: 'array', value: null, optional: true}\n};\n\n/** All properties supported by MeshLayer. */\nexport type MeshLayerProps<DataT = unknown> = _MeshLayerProps & SimpleMeshLayerProps<DataT>;\n\n/** Properties added by MeshLayer. */\ntype _MeshLayerProps = {\n  /**\n   * PBR material object. _lighting must be pbr for this to work\n   */\n  pbrMaterial?: any; // TODO add type when converting Tile3DLayer\n\n  /**\n   * List of feature ids.\n   */\n  featureIds?: NumericArray | null;\n};\n\nexport default class MeshLayer<DataT = any, ExtraProps extends {} = {}> extends SimpleMeshLayer<\n  DataT,\n  Required<_MeshLayerProps> & ExtraProps\n> {\n  static layerName = 'MeshLayer';\n  static defaultProps = defaultProps;\n\n  getShaders() {\n    const shaders = super.getShaders();\n    const modules = shaders.modules;\n    modules.push(pbr);\n    return {...shaders, vs, fs};\n  }\n\n  initializeState() {\n    const {featureIds} = this.props;\n    super.initializeState();\n\n    const attributeManager = this.getAttributeManager();\n    if (featureIds) {\n      // attributeManager is always defined in a primitive layer\n      attributeManager!.add({\n        featureIdsPickingColors: {\n          type: GL.UNSIGNED_BYTE,\n          size: 3,\n          noAlloc: true,\n          // eslint-disable-next-line @typescript-eslint/unbound-method\n          update: this.calculateFeatureIdsPickingColors\n        }\n      });\n    }\n  }\n\n  updateState(params: UpdateParameters<this>) {\n    super.updateState(params);\n\n    const {props, oldProps} = params;\n    if (props.pbrMaterial !== oldProps.pbrMaterial) {\n      this.updatePbrMaterialUniforms(props.pbrMaterial);\n    }\n  }\n\n  draw(opts) {\n    const {featureIds} = this.props;\n    if (!this.state.model) {\n      return;\n    }\n    this.state.model.setUniforms({\n      // Needed for PBR (TODO: find better way to get it)\n      // eslint-disable-next-line camelcase\n      u_Camera: this.state.model.uniforms.project_uCameraPosition,\n      pickFeatureIds: Boolean(featureIds)\n    });\n\n    super.draw(opts);\n  }\n\n  protected getModel(mesh: Mesh): Model {\n    const {id, pbrMaterial} = this.props;\n    const parsedPBRMaterial = this.parseMaterial(pbrMaterial, mesh);\n    // Keep material to explicitly remove textures\n    this.setState({parsedPBRMaterial});\n    const shaders = this.getShaders();\n    validateGeometryAttributes(mesh.attributes);\n    const model = new Model(this.context.device, {\n      ...this.getShaders(),\n      id,\n      geometry: mesh,\n      bufferLayout: this.getAttributeManager()!.getBufferLayouts(),\n      defines: {\n        ...shaders.defines,\n        ...parsedPBRMaterial?.defines,\n        HAS_UV_REGIONS: mesh.attributes.uvRegions ? 1 : 0\n      },\n      parameters: parsedPBRMaterial?.parameters,\n      isInstanced: true\n    });\n\n    return model;\n  }\n\n  updatePbrMaterialUniforms(pbrMaterial) {\n    const {model} = this.state;\n    if (model) {\n      const {mesh} = this.props;\n      const parsedPBRMaterial = this.parseMaterial(pbrMaterial, mesh as Mesh);\n      // Keep material to explicitly remove textures\n      this.setState({parsedPBRMaterial});\n      model.setBindings(parsedPBRMaterial.bindings);\n      model.setUniforms(parsedPBRMaterial.uniforms);\n    }\n  }\n\n  parseMaterial(pbrMaterial, mesh: Mesh): ParsedPBRMaterial {\n    const unlit = Boolean(\n      pbrMaterial.pbrMetallicRoughness && pbrMaterial.pbrMetallicRoughness.baseColorTexture\n    );\n\n    return parsePBRMaterial(\n      this.context.device,\n      {unlit, ...pbrMaterial},\n      {NORMAL: mesh.attributes.normals, TEXCOORD_0: mesh.attributes.texCoords},\n      {\n        pbrDebug: false,\n        lights: true,\n        useTangents: false\n      }\n    );\n  }\n\n  calculateFeatureIdsPickingColors(attribute) {\n    // This updater is only called if featureIds is not null\n    const featureIds = this.props.featureIds!;\n    const value = new Uint8ClampedArray(featureIds.length * attribute.size);\n\n    const pickingColor = [];\n    for (let index = 0; index < featureIds.length; index++) {\n      this.encodePickingColor(featureIds[index], pickingColor);\n\n      value[index * 3] = pickingColor[0];\n      value[index * 3 + 1] = pickingColor[1];\n      value[index * 3 + 2] = pickingColor[2];\n    }\n\n    attribute.value = value;\n  }\n\n  finalizeState(context: LayerContext) {\n    super.finalizeState(context);\n    this.state.parsedPBRMaterial?.generatedTextures.forEach(texture => texture.destroy());\n    this.setState({parsedPBRMaterial: null});\n  }\n}\n"],"file":"mesh-layer.js"}

package/dist/esm/tile-3d-layer/tile-3d-layer.js

@@ -0,0 +1,438 @@
+import { Geometry } from '@luma.gl/engine';
+import { CompositeLayer, COORDINATE_SYSTEM, log } from '@deck.gl/core';
+import { PointCloudLayer } from '@deck.gl/layers';
+import { ScenegraphLayer } from '@deck.gl/mesh-layers';
+import { default as MeshLayer } from '../mesh-layer/mesh-layer';
+import { load } from '@loaders.gl/core';
+import { Tileset3D, TILE_TYPE } from '@loaders.gl/tiles';
+import { Tiles3DLoader } from '@loaders.gl/3d-tiles';
+const SINGLE_DATA = [0];
+const defaultProps = {
+  getPointColor: {
+    type: 'accessor',
+    value: [0, 0, 0, 255]
+  },
+  pointSize: 1.0,
+  data: '',
+  loader: Tiles3DLoader,
+  onTilesetLoad: {
+    type: 'function',
+    value: tileset3d => {}
+  },
+  onTileLoad: {
+    type: 'function',
+    value: tileHeader => {}
+  },
+  onTileUnload: {
+    type: 'function',
+    value: tileHeader => {}
+  },
+  onTileError: {
+    type: 'function',
+    value: (tile, message, url) => {}
+  },
+  _getMeshColor: {
+    type: 'function',
+    value: tileHeader => [255, 255, 255]
+  }
+};
+export default class Tile3DLayer extends CompositeLayer {
+  constructor(...args) {
+    super(...args);
+    this.state = void 0;
+  }
+
+  initializeState() {
+    if ('onTileLoadFail' in this.props) {
+      log.removed('onTileLoadFail', 'onTileError')();
+    }
+
+    this.state = {
+      layerMap: {},
+      tileset3d: null,
+      activeViewports: {},
+      lastUpdatedViewports: null
+    };
+  }
+
+  get isLoaded() {
+    var _this$state, _this$state$tileset3d;
+
+    return Boolean(((_this$state = this.state) === null || _this$state === void 0 ? void 0 : (_this$state$tileset3d = _this$state.tileset3d) === null || _this$state$tileset3d === void 0 ? void 0 : _this$state$tileset3d.isLoaded()) && super.isLoaded);
+  }
+
+  shouldUpdateState({
+    changeFlags
+  }) {
+    return changeFlags.somethingChanged;
+  }
+
+  updateState({
+    props,
+    oldProps,
+    changeFlags
+  }) {
+    if (props.data && props.data !== oldProps.data) {
+      this._loadTileset(props.data);
+    }
+
+    if (changeFlags.viewportChanged) {
+      const {
+        activeViewports
+      } = this.state;
+      const viewportsNumber = Object.keys(activeViewports).length;
+
+      if (viewportsNumber) {
+        this._updateTileset(activeViewports);
+
+        this.state.lastUpdatedViewports = activeViewports;
+        this.state.activeViewports = {};
+      }
+    }
+
+    if (changeFlags.propsChanged) {
+      const {
+        layerMap
+      } = this.state;
+
+      for (const key in layerMap) {
+        layerMap[key].needsUpdate = true;
+      }
+    }
+  }
+
+  activateViewport(viewport) {
+    const {
+      activeViewports,
+      lastUpdatedViewports
+    } = this.state;
+    this.internalState.viewport = viewport;
+    activeViewports[viewport.id] = viewport;
+    const lastViewport = lastUpdatedViewports === null || lastUpdatedViewports === void 0 ? void 0 : lastUpdatedViewports[viewport.id];
+
+    if (!lastViewport || !viewport.equals(lastViewport)) {
+      this.setChangeFlags({
+        viewportChanged: true
+      });
+      this.setNeedsUpdate();
+    }
+  }
+
+  getPickingInfo({
+    info,
+    sourceLayer
+  }) {
+    const sourceTile = sourceLayer && sourceLayer.props.tile;
+
+    if (info.picked) {
+      info.object = sourceTile;
+    }
+
+    info.sourceTile = sourceTile;
+    return info;
+  }
+
+  filterSubLayer({
+    layer,
+    viewport
+  }) {
+    const {
+      tile
+    } = layer.props;
+    const {
+      id: viewportId
+    } = viewport;
+    return tile.selected && tile.viewportIds.includes(viewportId);
+  }
+
+  _updateAutoHighlight(info) {
+    const sourceTile = info.sourceTile;
+    const layerCache = this.state.layerMap[sourceTile === null || sourceTile === void 0 ? void 0 : sourceTile.id];
+
+    if (layerCache && layerCache.layer) {
+      layerCache.layer.updateAutoHighlight(info);
+    }
+  }
+
+  async _loadTileset(tilesetUrl) {
+    const {
+      loadOptions = {}
+    } = this.props;
+    const loaders = this.props.loader || this.props.loaders;
+    const loader = Array.isArray(loaders) ? loaders[0] : loaders;
+    const options = {
+      loadOptions: { ...loadOptions
+      }
+    };
+    let actualTilesetUrl = tilesetUrl;
+
+    if (loader.preload) {
+      const preloadOptions = await loader.preload(tilesetUrl, loadOptions);
+
+      if (preloadOptions.url) {
+        actualTilesetUrl = preloadOptions.url;
+      }
+
+      if (preloadOptions.headers) {
+        options.loadOptions.fetch = { ...options.loadOptions.fetch,
+          headers: preloadOptions.headers
+        };
+      }
+
+      Object.assign(options, preloadOptions);
+    }
+
+    const tilesetJson = await load(actualTilesetUrl, loader, options.loadOptions);
+    const tileset3d = new Tileset3D(tilesetJson, {
+      onTileLoad: this._onTileLoad.bind(this),
+      onTileUnload: this._onTileUnload.bind(this),
+      onTileError: this.props.onTileError,
+      ...options
+    });
+    this.setState({
+      tileset3d,
+      layerMap: {}
+    });
+
+    this._updateTileset(this.state.activeViewports);
+
+    this.props.onTilesetLoad(tileset3d);
+  }
+
+  _onTileLoad(tileHeader) {
+    const {
+      lastUpdatedViewports
+    } = this.state;
+    this.props.onTileLoad(tileHeader);
+
+    this._updateTileset(lastUpdatedViewports);
+
+    this.setNeedsUpdate();
+  }
+
+  _onTileUnload(tileHeader) {
+    delete this.state.layerMap[tileHeader.id];
+    this.props.onTileUnload(tileHeader);
+  }
+
+  _updateTileset(viewports) {
+    if (!viewports) {
+      return;
+    }
+
+    const {
+      tileset3d
+    } = this.state;
+    const {
+      timeline
+    } = this.context;
+    const viewportsNumber = Object.keys(viewports).length;
+
+    if (!timeline || !viewportsNumber || !tileset3d) {
+      return;
+    }
+
+    tileset3d.selectTiles(Object.values(viewports)).then(frameNumber => {
+      const tilesetChanged = this.state.frameNumber !== frameNumber;
+
+      if (tilesetChanged) {
+        this.setState({
+          frameNumber
+        });
+      }
+    });
+  }
+
+  _getSubLayer(tileHeader, oldLayer) {
+    if (!tileHeader.content) {
+      return null;
+    }
+
+    switch (tileHeader.type) {
+      case TILE_TYPE.POINTCLOUD:
+        return this._makePointCloudLayer(tileHeader, oldLayer);
+
+      case TILE_TYPE.SCENEGRAPH:
+        return this._make3DModelLayer(tileHeader);
+
+      case TILE_TYPE.MESH:
+        return this._makeSimpleMeshLayer(tileHeader, oldLayer);
+
+      default:
+        throw new Error(`Tile3DLayer: Failed to render layer of type ${tileHeader.content.type}`);
+    }
+  }
+
+  _makePointCloudLayer(tileHeader, oldLayer) {
+    const {
+      attributes,
+      pointCount,
+      constantRGBA,
+      cartographicOrigin,
+      modelMatrix
+    } = tileHeader.content;
+    const {
+      positions,
+      normals,
+      colors
+    } = attributes;
+
+    if (!positions) {
+      return null;
+    }
+
+    const data = oldLayer && oldLayer.props.data || {
+      header: {
+        vertexCount: pointCount
+      },
+      attributes: {
+        POSITION: positions,
+        NORMAL: normals,
+        COLOR_0: colors
+      }
+    };
+    const {
+      pointSize,
+      getPointColor
+    } = this.props;
+    const SubLayerClass = this.getSubLayerClass('pointcloud', PointCloudLayer);
+    return new SubLayerClass({
+      pointSize
+    }, this.getSubLayerProps({
+      id: 'pointcloud'
+    }), {
+      id: `${this.id}-pointcloud-${tileHeader.id}`,
+      tile: tileHeader,
+      data,
+      coordinateSystem: COORDINATE_SYSTEM.METER_OFFSETS,
+      coordinateOrigin: cartographicOrigin,
+      modelMatrix,
+      getColor: constantRGBA || getPointColor,
+      _offset: 0
+    });
+  }
+
+  _make3DModelLayer(tileHeader) {
+    const {
+      gltf,
+      instances,
+      cartographicOrigin,
+      modelMatrix
+    } = tileHeader.content;
+    const SubLayerClass = this.getSubLayerClass('scenegraph', ScenegraphLayer);
+    return new SubLayerClass({
+      _lighting: 'pbr'
+    }, this.getSubLayerProps({
+      id: 'scenegraph'
+    }), {
+      id: `${this.id}-scenegraph-${tileHeader.id}`,
+      tile: tileHeader,
+      data: instances || SINGLE_DATA,
+      scenegraph: gltf,
+      coordinateSystem: COORDINATE_SYSTEM.METER_OFFSETS,
+      coordinateOrigin: cartographicOrigin,
+      modelMatrix,
+      getTransformMatrix: instance => instance.modelMatrix,
+      getPosition: [0, 0, 0],
+      _offset: 0
+    });
+  }
+
+  _makeSimpleMeshLayer(tileHeader, oldLayer) {
+    const content = tileHeader.content;
+    const {
+      attributes,
+      indices,
+      modelMatrix,
+      cartographicOrigin,
+      coordinateSystem = COORDINATE_SYSTEM.METER_OFFSETS,
+      material,
+      featureIds
+    } = content;
+    const {
+      _getMeshColor
+    } = this.props;
+    const geometry = oldLayer && oldLayer.props.mesh || new Geometry({
+      topology: 'triangle-list',
+      attributes: getMeshGeometry(attributes),
+      indices
+    });
+    const SubLayerClass = this.getSubLayerClass('mesh', MeshLayer);
+    return new SubLayerClass(this.getSubLayerProps({
+      id: 'mesh'
+    }), {
+      id: `${this.id}-mesh-${tileHeader.id}`,
+      tile: tileHeader,
+      mesh: geometry,
+      data: SINGLE_DATA,
+      getColor: _getMeshColor(tileHeader),
+      pbrMaterial: material,
+      modelMatrix,
+      coordinateOrigin: cartographicOrigin,
+      coordinateSystem,
+      featureIds,
+      _offset: 0
+    });
+  }
+
+  renderLayers() {
+    const {
+      tileset3d,
+      layerMap
+    } = this.state;
+
+    if (!tileset3d) {
+      return null;
+    }
+
+    return tileset3d.tiles.map(tile => {
+      const layerCache = layerMap[tile.id] = layerMap[tile.id] || {
+        tile
+      };
+      let {
+        layer
+      } = layerCache;
+
+      if (tile.selected) {
+        if (!layer) {
+          layer = this._getSubLayer(tile);
+        } else if (layerCache.needsUpdate) {
+          layer = this._getSubLayer(tile, layer);
+          layerCache.needsUpdate = false;
+        }
+      }
+
+      layerCache.layer = layer;
+      return layer;
+    }).filter(Boolean);
+  }
+
+}
+Tile3DLayer.defaultProps = defaultProps;
+Tile3DLayer.layerName = 'Tile3DLayer';
+
+function getMeshGeometry(contentAttributes) {
+  const attributes = {};
+  attributes.positions = { ...contentAttributes.positions,
+    value: new Float32Array(contentAttributes.positions.value)
+  };
+
+  if (contentAttributes.normals) {
+    attributes.normals = contentAttributes.normals;
+  }
+
+  if (contentAttributes.texCoords) {
+    attributes.texCoords = contentAttributes.texCoords;
+  }
+
+  if (contentAttributes.colors) {
+    attributes.colors = contentAttributes.colors;
+  }
+
+  if (contentAttributes.uvRegions) {
+    attributes.uvRegions = contentAttributes.uvRegions;
+  }
+
+  return attributes;
+}
+//# sourceMappingURL=tile-3d-layer.js.map