@woosh/meep-engine 2.40.0 → 2.41.0

package/engine/asset/loaders/GLTFAssetLoader.js

@@ -11,7 +11,9 @@ import { MeshDepthMaterial, RGBADepthPacking } from "three";
 import { TextureAttachmentsByMaterialType } from "./material/TextureAttachmensByMaterialType.js";
 import { AssetLoader } from "./AssetLoader.js";
 import { ensureGeometryBoundingSphere } from "../../graphics/geometry/buffered/ensureGeometryBoundingSphere.js";
-import { computeSkinnedMeshBoundingVolumes } from "../../graphics/geometry/skining/computeSkinnedMeshBoundingVolumes.js";
+import {
+    computeSkinnedMeshBoundingVolumes
+} from "../../graphics/geometry/skining/computeSkinnedMeshBoundingVolumes.js";
 import { ensureGeometryBoundingBox } from "../../graphics/util/ensureGeometryBoundingBox.js";
 import { cloneObject3D } from "../../graphics/three/cloneObject3D.js";
 import GLTFTextureDDSExtension from "./gltf/extensions/MSFT_texture_dds.js";
@@ -20,8 +22,8 @@ import { computeObjectBoundingSphere } from "./gltf/computeObjectBoundingSphere.
 import { isMesh } from "./gltf/isMesh.js";
 import { DRACOLoader } from "three/examples/jsm/loaders/DRACOLoader.js";
 import { HashSet } from "../../../core/collection/HashSet.js";
-import { computeGeometryHash } from "./geometry/geometry/computeGeometryHash.js";
-import { computeGeometryEquality } from "./geometry/geometry/computeGeometryEquality.js";
+import { computeGeometryHash } from "../../graphics/geometry/buffered/computeGeometryHash.js";
+import { computeGeometryEquality } from "../../graphics/geometry/buffered/computeGeometryEquality.js";
 import { traverseThreeObject } from "../../graphics/ecs/highlight/renderer/traverseThreeObject.js";
 import { computeTextureHash } from "./material/computeTextureHash.js";
 import { computeTextureEquality } from "./material/computeTextureEquality.js";

package/engine/asset/loaders/image/png/PNG.js

@@ -40,6 +40,12 @@ export function PNG() {
      */
     this.trns = null;
 
+
+    /**
+     * Text metadata coming from tEXt chunks
+     * @type {Object<string>}
+     */
+    this.text = {};
 }
 
 PNG.prototype.getWidth = function () {

package/engine/asset/loaders/image/png/PNGReader.js

@@ -157,12 +157,53 @@ PNGReader.prototype.decodeChunk = function () {
         case 'IEND':
             this.decodeIEND(chunk);
             break;
+        default:
+            //console.log(`Unsupported block ${type}`);
+            break;
     }
 
     return type;
 
 };
 
+/**
+ * https://www.w3.org/TR/PNG/#11tEXt
+ * @param {Uint8Array} chunk
+ */
+PNGReader.prototype.decodetEXt = function (chunk) {
+    const buff = BinaryBuffer.fromArrayBuffer(chunk.buffer);
+    const keyword = buff.readASCIICharacters(Number.POSITIVE_INFINITY, true);
+
+    const value = buff.readASCIICharacters(keyword.length - 1, false);
+
+    this.png.text[keyword] = value;
+}
+/**
+ * NOTE: untested
+ * https://www.w3.org/TR/PNG/#11iEXt
+ * @param {Uint8Array} chunk
+ */
+PNGReader.prototype.decodeiEXt = function (chunk) {
+    const buff = BinaryBuffer.fromArrayBuffer(chunk.buffer);
+
+    const keyword = buff.readASCIICharacters(Number.POSITIVE_INFINITY, true);
+
+    const compression_flag = buff.readUint8();
+    const compression_method = buff.readUint8();
+    const language_tag = buff.readASCIICharacters(Number.POSITIVE_INFINITY, true);
+    const translated_keyword = buff.readUTF8String();
+
+    const separator = buff.readUint8();
+
+    if (separator !== 0) {
+        throw new Error('Expected Null Separator after Translated keyword');
+    }
+
+    const text = buff.readUTF8String();
+
+    this.png.text[keyword] = text;
+}
+
 /**
  * http://www.w3.org/TR/2003/REC-PNG-20031110/#11IHDR
  * http://www.libpng.org/pub/png/spec/1.2/png-1.2-pdg.html#C.IHDR

package/engine/ecs/foliage/ImpostorFoliage.js

@@ -19,6 +19,10 @@ import {
 import Vector2 from "../../../core/geom/Vector2.js";
 import Vector4 from "../../../core/geom/Vector4.js";
 
+/**
+ * @deprecated use other options, such as ShadedMesh with INSTANCED draw mode or dedicated instanced mesh system such as Foliage2System
+ * @constructor
+ */
 const Foliage = function (options) {
     const size = options.size || 1;
     const lightMap = options.lightMap;

package/engine/ecs/terrain/tiles/TerrainTile.js

@@ -496,6 +496,8 @@ class TerrainTile {
             geometry_bb.x0, geometry_bb.y0, geometry_bb.z0,
             geometry_bb.x1, geometry_bb.y1, geometry_bb.z1
         );
+        // update changes up the tree
+        this.boundingBox.bubbleRefit();
     }
 
     /**

package/engine/graphics/ecs/mesh-v2/three_object_to_entity_composition.js

@@ -2,6 +2,22 @@ import { EntityNode } from "../../../ecs/parent/EntityNode.js";
 import { Transform } from "../../../ecs/transform/Transform.js";
 import { ShadedGeometry } from "./ShadedGeometry.js";
 
+/**
+ *
+ * @param {Transform} transform
+ * @param {THREE.Object3D} three_object
+ */
+function copy_three_transform(transform, three_object) {
+
+    // copy object transform
+    transform.position.copy(three_object.position);
+    transform.scale.copy(three_object.scale);
+    transform.rotation.copy(three_object.quaternion);
+
+    //
+    transform.matrix.set(three_object.matrix.elements);
+}
+
 /**
  *
  * @param {THREE.Object3D} root
@@ -13,16 +29,15 @@ export function three_object_to_entity_composition(root) {
     const node_transform = node.transform;
 
     // copy object transform
-    node_transform.position.copy(root.position);
-    node_transform.scale.copy(root.scale);
-    node_transform.rotation.copy(root.quaternion);
-
-    //
-    node_transform.matrix.set(root.matrix.elements);
+    copy_three_transform(node_transform, root);
 
     const entity = node.entity;
 
-    entity.add(new Transform());
+    const transform = new Transform();
+    // initialize world transform
+    transform.fromMatrix4(root.matrixWorld.elements);
+
+    entity.add(transform);
 
     if (root.isMesh) {
         if (root.isSkinnedMesh) {

package/engine/graphics/filter/ImageFilter.js

@@ -3,7 +3,7 @@
  */
 
 
-import { LinearFilter, Mesh, OrthographicCamera, Scene, ShaderMaterial, WebGLRenderTarget } from 'three';
+import { DoubleSide, LinearFilter, Mesh, OrthographicCamera, Scene, ShaderMaterial, WebGLRenderTarget } from 'three';
 import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
 import { FULL_SCREEN_QUAD_VERTEX_SHADER } from "../FULL_SCREEN_QUAD_VERTEX_SHADER.js";
 
@@ -41,6 +41,7 @@ function processTexture(
     material.fog = false;
     material.uniformsNeedUpdate = true;
     material.needsUpdate = true;
+    material.side = DoubleSide;
 
     const quad = new Mesh(FULL_SCREEN_TRIANGLE_GEOMETRY, material);
 

package/engine/graphics/geometry/MikkT/MikkTSpace.spec.js

@@ -14,7 +14,13 @@ test('single triangle', () => {
 
     ctx.geometry_buffer_index = [0, 1, 2];
     ctx.geometry_buffer_vertex_position = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-    ctx.geometry_buffer_vertex_normal = [0, 1, 0, 0, 1, 0, 0, 1, 0];
+
+    ctx.geometry_buffer_vertex_normal = [
+        0, 1, 0,
+        0, 1, 0,
+        0, 1, 0
+    ];
+
     ctx.geometry_buffer_vertex_uv = [0, 0, 0, 0, 0, 0];
 
     genTangSpace(ctx);

package/engine/{asset/loaders/geometry/geometry → graphics/geometry/buffered}/computeBufferAttributeHash.js

@@ -1,4 +1,4 @@
-import { computeStridedIntegerArrayHash } from "../../../../computeStridedIntegerArrayHash.js";
+import { computeStridedIntegerArrayHash } from "../../../computeStridedIntegerArrayHash.js";
 
 /**
  *

package/engine/{asset/loaders/geometry/geometry → graphics/geometry/buffered}/computeGeometryEquality.js

@@ -1,5 +1,5 @@
-import { isArrayEqualStrict } from "../../../../../core/collection/array/isArrayEqualStrict.js";
-import { is_typed_array_equals } from "../../../../../core/collection/array/typed/is_typed_array_equals.js";
+import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.d.ts";
+import { is_typed_array_equals } from "../../../../core/collection/array/typed/is_typed_array_equals.js";
 
 
 /**

package/engine/{asset/loaders/geometry/geometry → graphics/geometry/buffered}/computeGeometryHash.js

@@ -1,5 +1,5 @@
 import { computeBufferAttributeHash } from "./computeBufferAttributeHash.js";
-import { computeStringHash } from "../../../../../core/primitives/strings/computeStringHash.js";
+import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.d.ts";
 
 /**
  *

package/engine/graphics/geometry/optimization/merge/merge_geometry_hierarchy.js

@@ -1,7 +1,7 @@
 import { StaticMaterialCache } from "../../../../asset/loaders/material/StaticMaterialCache.js";
 import { HashMap } from "../../../../../core/collection/HashMap.js";
-import { computeGeometryEquality } from "../../../../asset/loaders/geometry/geometry/computeGeometryEquality.js";
-import { computeGeometryHash } from "../../../../asset/loaders/geometry/geometry/computeGeometryHash.js";
+import { computeGeometryEquality } from "../../buffered/computeGeometryEquality.js";
+import { computeGeometryHash } from "../../buffered/computeGeometryHash.js";
 import { array_copy } from "../../../../../core/collection/array/copyArray.js";
 import { mat4 } from "gl-matrix";
 import { Group, Matrix4, Mesh } from "three";

package/engine/graphics/impostors/card_cluster/FacePlaneAssignment.js

@@ -0,0 +1,30 @@
+/**
+ * A geometry is separated into individual triangles, with each triangle projected onto a single plane.
+ * This class contains and fully describes such assignment
+ */
+export class FacePlaneAssignment {
+    /**
+     * Flat plane data array
+     * Format: [normal_0_x, normal_0_y, normal_0_z, plane_0_offset, normal_1_x, ... ]
+     * @type {number[]}
+     */
+    planes = [];
+
+    /**
+     *
+     * @type {number}
+     */
+    plane_count = 0;
+
+    /**
+     *
+     * @type {THREE.BufferGeometry|null}
+     */
+    geometry = null;
+
+    /**
+     * Indices of planes associated with each face (triangle) for a given face index
+     * @type {number[]}
+     */
+    face_assignments = [];
+}

package/engine/graphics/impostors/card_cluster/README.md

@@ -0,0 +1,13 @@
+# Card Cluster Impostors
+
+The system is fairly trivial in concept. It generates a specified number of *cards* (quads) along with textures to represent original mesh.
+
+The idea for this system was inspired by Sean Feeley's talk at GDC 2019 "Interactive Wind and Vegetation in 'God of War'", where he briefly explained how impostors work in their engine.
+
+---
+### References
+
+1. [2003] "Billboard Clouds for Extreme Model Simplification" by Xavier Decoret, Fr ´ edo Durand, Franc ´ ¸ois X. Sillion, Julie Dorsey
+2. [2005] "Extreme Model Simplification for Forest Rendering" by Anton L. Fuhrmann, Eike Umlauf and Stephan Mantler
+3. [2005] "Tree Rendering with Billboard Clouds" by Ismael Garcia, Mateu Sbert, and László Szirmay-Kalos
+4. [2009] "Implementation of an Improved Billboard Cloud Algorithm" by Christian Luksch

package/engine/graphics/impostors/octahedral/ImpostorBaker.js

@@ -0,0 +1,332 @@
+import { ImpostorCaptureType } from "./ImpostorCaptureType.js";
+import { assert } from "../../../../core/assert.js";
+import { isPowerOfTwo } from "../../../../core/math/isPowerOrTwo.js";
+import { Mesh, OrthographicCamera, Scene, Vector4, WebGLMultipleRenderTargets } from "three";
+import { ImpostorDescription } from "./ImpostorDescription.js";
+import { mat4 } from "gl-matrix";
+import { BakeShaderStandard } from "./shader/BakeShaderStandard.js";
+import { Sampler2D } from "../../texture/sampler/Sampler2D.js";
+import Signal from "../../../../core/events/signal/Signal.js";
+import { HashMap } from "../../../../core/collection/HashMap.js";
+import { computeMaterialHash } from "../../../asset/loaders/material/computeMaterialHash.js";
+import { computeMaterialEquality } from "../../../asset/loaders/material/computeMaterialEquality.js";
+import { UvEncoder } from "./grid/UvEncoder.js";
+import { OctahedralUvEncoder } from "./grid/OctahedralUvEncoder.js";
+import { HemiOctahedralUvEncoder } from "./grid/HemiOctahedralUvEncoder.js";
+import { prepare_bake_material } from "./bake/prepare_bake_material.js";
+import { compute_bounding_sphere } from "./bake/compute_bounding_sphere.js";
+import { collectIteratorValueToArray } from "../../../../core/collection/IteratorUtils.js";
+
+export class ImpostorBaker {
+
+    /**
+     *
+     * @type {THREE.WebGLRenderer|null}
+     * @private
+     */
+    _renderer = null;
+
+    /**
+     *
+     * @param {THREE.WebGLRenderer} v
+     */
+    set renderer(v) {
+        this._renderer = v;
+    }
+
+
+    /**
+     *
+     * @param {number} distance
+     * @param {{mesh:ShadedGeometry, transform:mat4}[]} objects
+     * @param {number} resolution
+     * @param {number} frames
+     * @param {UvEncoder} encoder
+     */
+    bake_internal({
+                      distance,
+                      objects,
+                      resolution,
+                      frames,
+                      encoder
+                  }) {
+
+        assert.isNumber(distance, 'distance');
+        assert.isNonNegativeInteger(resolution, 'resolution');
+        assert.isNonNegativeInteger(frames, 'frames');
+
+        const unit_sphere_direction = [];
+
+        const cam = new OrthographicCamera();
+        const rt = new WebGLMultipleRenderTargets(resolution, resolution, 3);
+        rt.scissorTest = false;
+        rt.stencilBuffer = false;
+
+        rt.texture[0].name = 'diffuse+alpha';
+        rt.texture[1].name = 'normal+depth';
+        rt.texture[2].name = 'orm'; // Occlusion, Roughness, Metalness
+
+
+        const renderer = this._renderer;
+
+        // remember render state
+        const _rt = renderer.getRenderTarget();
+        const _vp = new Vector4();
+        renderer.getViewport(_vp);
+        const _autoClear = renderer.autoClear;
+
+        const gl = this._renderer.getContext();
+
+        // Baking should be done without anti-aliasing, so we make sure to disable it
+        const _enabled_antialias = gl.isEnabled(gl.SAMPLE_ALPHA_TO_COVERAGE);
+
+        if (_enabled_antialias) {
+            gl.disable(gl.SAMPLE_ALPHA_TO_COVERAGE);
+        }
+
+
+        // set new render state
+        renderer.autoClear = false;
+        renderer.setRenderTarget(rt);
+        renderer.setClearColor(0xFFFFFF, 0);
+        renderer.clearColor();
+
+        const frame_width = resolution / frames;
+        const frame_height = resolution / frames;
+
+        const object_count = objects.length;
+
+        // construct scene
+        const scene = new Scene();
+
+        scene.autoUpdate = false;
+        scene.matrixAutoUpdate = false;
+        scene.matrixWorldNeedsUpdate = false;
+
+        const id = new ImpostorDescription();
+        id.frame_count = frames;
+        id.resolution = resolution;
+
+        /**
+         * Fired when all the rendering is done to indicate that cleanup should happen
+         * @type {Signal}
+         */
+        const cleanup_signal = new Signal();
+
+        /**
+         *
+         * @type {HashMap<Material, BakeShaderStandard>}
+         */
+        const bake_material_map = new HashMap({
+            keyHashFunction: computeMaterialHash,
+            keyEqualityFunction: computeMaterialEquality
+        });
+
+
+        for (let k = 0; k < object_count; k++) {
+            const object = objects[k];
+
+            const source_mesh = object.mesh;
+
+            // ensure tangents are generated
+            // buffer_geometry_ensure_tangents(source_mesh.geometry);
+
+            const source_material = source_mesh.material;
+
+            // obtain material for baking
+            const bake_material = bake_material_map.getOrCompute(source_material, (source_material) => {
+
+                const bake_material = new BakeShaderStandard();
+
+                // prepare bake material to match the source material
+                prepare_bake_material(bake_material, source_material, cleanup_signal);
+
+                cleanup_signal.addOne(bake_material.dispose, bake_material);
+
+                id.source_material_count++;
+
+                return bake_material;
+            });
+
+
+            const geometry = source_mesh.geometry;
+            const mesh = new Mesh(geometry, bake_material);
+
+            mesh.matrixAutoUpdate = false;
+            mesh.matrixWorldNeedsUpdate = false;
+            mesh.frustumCulled = false;
+
+            mat4.copy(mesh.matrixWorld.elements, object.transform);
+
+            scene.add(mesh);
+
+            // update stats
+            id.source_geometry_polygon_count += geometry.getIndex().count / 3;
+            id.source_geometry_vertex_count += geometry.getAttribute('position').count;
+            id.source_instance_count++;
+        }
+
+
+        const bake_material_array = collectIteratorValueToArray([], bake_material_map.values());
+
+        // traverse octahedron
+        const max_frame_index = frames - 1;
+
+        for (let i = 0; i < frames; i++) {
+            const octahedron_u = max_frame_index > 0 ? (i / max_frame_index) : 0;
+
+            for (let j = 0; j < frames; j++) {
+
+                const octahedron_v = max_frame_index > 0 ? (j / max_frame_index) : 0;
+
+                // compute vector direction where to place camera
+                encoder.uv_to_unit(unit_sphere_direction, [octahedron_u, octahedron_v]);
+
+                // offset by the radius of the sphere
+                const camera_px = distance * unit_sphere_direction[0];
+                const camera_py = distance * unit_sphere_direction[1];
+                const camera_pz = distance * unit_sphere_direction[2];
+
+                // console.log(`UV:${octahedron_u.toFixed(2)},${octahedron_v.toFixed(2)}\t V3:${unit_sphere_direction.map(n => n.toFixed(2)).join(', ')}`);
+
+                // construct projection matrix
+                cam.left = -distance;
+                cam.right = distance;
+                cam.top = distance;
+                cam.bottom = -distance;
+                cam.near = 0;
+                cam.far = distance * 2;
+
+                cam.position.set(
+                    camera_px,
+                    camera_py,
+                    camera_pz
+                );
+
+                cam.lookAt(0, 0, 0);
+                cam.updateProjectionMatrix();
+
+                // update materials
+                for (let k = 0; k < bake_material_array.length; k++) {
+                    const mat = bake_material_array[k];
+
+                    mat.uniforms.projection_params.value.set(
+                        0, 0, 0, 1 / cam.far
+                    );
+                    mat.uniformsNeedUpdate = true;
+                }
+
+                //TODO consider doing super-sampling for some textures for better-looking results
+
+                /*
+                TODO it's possible to reduce bounding sphere in some cases where thin geometry would produce 0 texels
+                 in the actual render, but we can't know that without doing the rendering first.
+                 Consider doing a cheap pre-pass, rendering out pixels and checking if we can crop the bounding sphere further
+                 */
+
+                renderer.setViewport(i * frame_width, j * frame_height, frame_width, frame_height);
+                renderer.render(scene, cam);
+            }
+        }
+
+        /*
+         TODO dilate non-color textures to prevent artifacts when sampling around the edges
+         */
+
+        //restore renderer state
+        renderer.setRenderTarget(_rt);
+        renderer.setViewport(_vp);
+        renderer.autoClear = _autoClear;
+        if (_enabled_antialias) {
+            gl.enable(gl.SAMPLE_ALPHA_TO_COVERAGE);
+        }
+
+        // cleanup
+        cleanup_signal.send0();
+
+        // const sampler = convertTexture2Sampler2D(rt.texture);
+
+
+        id.atlas = Sampler2D.uint8(1, resolution, resolution);
+        // id.atlas = sampler;
+        id.rt = rt;
+
+        return id;
+    }
+
+    /**
+     *
+     * @param {{mesh:ShadedGeometry, transform:mat4}[]} objects objects that should make up the impostor. Baking will be done around the origin, so make sure to position meshes accordingly to make good use of texture space.
+     * @param {number} frames how many views to capture for the atlas in each X and Y direction. Setting this to 4 will result in 16 (4*4) views captured, higher value will sacrifice detail but result in transitions being more smooth
+     * @param {number} resolution resolution of the final asset, higher = more detail
+     * @param {ImpostorCaptureType} type
+     * @returns {ImpostorDescription}
+     */
+    bake({
+             objects,
+             frames = 12,
+             resolution = 1024,
+             type = ImpostorCaptureType.FullSphere
+         }) {
+
+        console.time('bake');
+
+        assert.defined(objects, 'object');
+        assert.isNonNegativeInteger(frames, 'frames');
+        assert.isNonNegativeInteger(resolution, 'resolution');
+        assert.greaterThanOrEqual(frames, 1, 'number of frames must be >= 1');
+
+        if (frames > resolution) {
+            throw new Error(`Frame count(=${frames}) is greater than the resolution(=${resolution}) of the bake texture, packing description is unachievable`);
+        }
+
+        const frame_resolution = resolution / frames;
+
+        if (frames >= resolution / 4) {
+            console.warn(`Bake configuration will produce less frames, this will likely result in a useless impostor that contains too little texel density to properly represent the underlying scene.  [frames=${frames}, resolution=${resolution}, resulting density = ${Math.pow(frame_resolution, 2)} texels per frame]`);
+        }
+
+        if (resolution % frames !== 0 && frame_resolution < 16) {
+            console.warn(`To get results at low frame resolutions number of frames should be a divisor of resolution, instead got [frames=${frames}, resolution=${resolution}, resolution/frames=${frame_resolution}]`);
+        }
+
+        if (!isPowerOfTwo(resolution)) {
+            throw new Error(` 'resolution' must be a power of two, instead was '${resolution}'`);
+        }
+
+        if (frames < 2) {
+            console.warn(`Frame count is set to ${frames}, which is too low to be useful. Consider values of 2 and above. A good default is 12`);
+        }
+
+        if (this._renderer === null) {
+            throw new Error('No renderer attached. Renderer is required for baking.');
+        }
+
+        const objects_radius = compute_bounding_sphere(objects);
+
+        // we need to compute bounding sphere around origin of the object
+        let encoder;
+        if (type === ImpostorCaptureType.FullSphere) {
+            encoder = new OctahedralUvEncoder();
+        } else if (type === ImpostorCaptureType.Hemisphere) {
+            encoder = new HemiOctahedralUvEncoder();
+        } else {
+            throw new Error(`Unsupported capture mode '${type}'`);
+        }
+
+        const r = this.bake_internal({
+            resolution,
+            frames,
+            objects,
+            distance: objects_radius,
+            encoder
+        });
+
+        r.capture_type = type;
+        r.sphere_radius = objects_radius;
+
+        console.timeEnd('bake');
+
+        return r;
+    }
+}

package/engine/graphics/impostors/octahedral/ImpostorCaptureType.js

@@ -0,0 +1,10 @@
+export const ImpostorCaptureType = {
+    /**
+     * Capture from all sides
+     */
+    FullSphere: 0,
+    /**
+     * Only capture from the top hemisphere, good for things that will never be seen from "below", such as trees, houses etc.
+     */
+    Hemisphere: 1
+};

package/engine/graphics/impostors/octahedral/ImpostorDescription.js

@@ -0,0 +1,63 @@
+import { ImpostorCaptureType } from "./ImpostorCaptureType.js";
+
+export class ImpostorDescription {
+    /**
+     * How many XY frames should be captured
+     * More frames will result in less distortion, but lower texel density (lower resolution for each individual frame)
+     * @type {number}
+     */
+    frame_count = 16;
+
+    /**
+     * How the impostor is being captured
+     * @type {number}
+     */
+    capture_type = ImpostorCaptureType.FullSphere;
+
+    /**
+     * Resolution of the texture atlas used for baking. All "frames" will be packed here
+     * Must be power of two
+     * @type {number}
+     */
+    resolution = 1024;
+
+    /**
+     * Radius of baking sphere, this is centered on origin
+     * @type {number}
+     */
+    sphere_radius = 0;
+
+    /**
+     * Actual baked data
+     * @type {Sampler2D|null}
+     */
+    atlas = null;
+
+    /**
+     * Source scene from which impostor was baked
+     * @type {number}
+     */
+    source_geometry_polygon_count = 0;
+    /**
+     * @type {number}
+     */
+    source_geometry_vertex_count = 0;
+    /**
+     *
+     * @type {number}
+     */
+    source_material_count = 0;
+    /**
+     *
+     * @type {number}
+     */
+    source_instance_count = 0;
+
+
+    /**
+     * TODO: replace with something non-three.js specific
+     * @deprecated use non-three.js specific accessors instead
+     * @type {THREE.WebGLMultipleRenderTargets}
+     */
+    rt = null;
+}