@woosh/meep-engine 2.33.22 → 2.33.26

package/engine/graphics/render/forward_plus/query/cube_mapping.js

@@ -0,0 +1,38 @@
+const _lut_array_buffer = new ArrayBuffer(84);
+/**
+ * Mapping from 3 plane bitfield, corresponding to intersection point of the planes
+ * @type {number[]}
+ */
+export const triplanar_corner_mapping = new Uint8Array(_lut_array_buffer, 0, 43);
+
+triplanar_corner_mapping[0b010101] = 0;
+triplanar_corner_mapping[0b100101] = 1;
+triplanar_corner_mapping[0b011001] = 2;
+triplanar_corner_mapping[0b101001] = 3;
+triplanar_corner_mapping[0b010110] = 4;
+triplanar_corner_mapping[0b100110] = 5;
+triplanar_corner_mapping[0b011010] = 6;
+triplanar_corner_mapping[0b101010] = 7;
+/**
+ * Mapping from 2 plane bitfield to 2 corner bitfield, corresponding to corner indices of intersecting planes
+ * @type {number[]}
+ */
+export const biplanar_edge_mapping = new Uint8Array(_lut_array_buffer, 43, 41);
+
+biplanar_edge_mapping[0b000101] = 0 | (1 << 3);
+biplanar_edge_mapping[0b000110] = 4 | (5 << 3);
+
+biplanar_edge_mapping[0b001001] = 2 | (3 << 3);
+biplanar_edge_mapping[0b001010] = 6 | (7 << 3);
+
+biplanar_edge_mapping[0b010100] = 0 | (4 << 3);
+biplanar_edge_mapping[0b011000] = 2 | (6 << 3);
+
+biplanar_edge_mapping[0b100100] = 1 | (5 << 3);
+biplanar_edge_mapping[0b101000] = 3 | (7 << 3);
+
+biplanar_edge_mapping[0b010001] = 0 | (2 << 3);
+biplanar_edge_mapping[0b010010] = 4 | (6 << 3);
+
+biplanar_edge_mapping[0b100001] = 1 | (3 << 3);
+biplanar_edge_mapping[0b100010] = 5 | (7 << 3);

package/engine/graphics/render/forward_plus/query/detailed_sphere_frustum_intersection_test.js

@@ -0,0 +1,86 @@
+import { v3_distance_sqr } from "../../../../../core/geom/v3_distance_sqr.js";
+import { biplanar_edge_mapping, triplanar_corner_mapping } from "./cube_mapping.js";
+import { line3_computeSegmentPointDistance_sqr } from "../../../../../core/geom/3d/line/line3_computeSegmentPointDistance_sqr.js";
+
+/**
+ *
+ * @param {number} radius
+ * @param {number} light_x
+ * @param {number} light_y
+ * @param {number} light_z
+ * @param {number} outside_plane_count
+ * @param {number} outside_plane_bitfield
+ * @param {number[]} points
+ * @return {boolean}
+ */
+export function detailed_sphere_frustum_intersection_test(
+    radius, light_x, light_y, light_z,
+    outside_plane_count, outside_plane_bitfield,
+    points
+) {
+
+    const radius_sqr = radius * radius;
+
+    if (outside_plane_count === 3) {
+        // nearest point in a corner, find the corner
+        const point_index = triplanar_corner_mapping[outside_plane_bitfield];
+
+        const point_address = point_index * 3;
+
+        const point_x = points[point_address];
+        const point_y = points[point_address + 1];
+        const point_z = points[point_address + 2];
+
+        const distance_to_light_sqr = v3_distance_sqr(
+            point_x, point_y, point_z,
+            light_x, light_y, light_z
+        );
+
+        // query_bvh_frustum_from_objects.checks_sphere_frustum_corner++;
+
+        // return distance_to_light_sqr <= radius_sqr;
+
+        if (distance_to_light_sqr > radius_sqr) {
+
+            // query_bvh_frustum_from_objects.rejection_sphere_count++;
+            return false;
+        }
+
+    } else if (outside_plane_count === 2) {
+        // nearest point is on an edge of two plane intersection
+        const edge_bitfield = biplanar_edge_mapping[outside_plane_bitfield];
+
+        // get 2 corners from edge bitfield
+        const corner_index_0 = edge_bitfield & 0b111;
+        const corner_address_0 = corner_index_0 * 3;
+
+        const corner_index_1 = (edge_bitfield >> 3) & 0b111;
+        const corner_address_1 = corner_index_1 * 3;
+
+        const point_0_x = points[corner_address_0];
+        const point_0_y = points[corner_address_0 + 1];
+        const point_0_z = points[corner_address_0 + 2];
+
+        const point_1_x = points[corner_address_1];
+        const point_1_y = points[corner_address_1 + 1];
+        const point_1_z = points[corner_address_1 + 2];
+
+        const distance_to_frustum_sqr = line3_computeSegmentPointDistance_sqr(
+            point_0_x, point_0_y, point_0_z,
+            point_1_x, point_1_y, point_1_z,
+            light_x, light_y, light_z
+        );
+
+        // query_bvh_frustum_from_objects.checks_sphere_frustum_edge++;
+
+        // return distance_to_frustum_sqr <= radius_sqr;
+
+        if (distance_to_frustum_sqr > radius_sqr) {
+
+            // query_bvh_frustum_from_objects.rejection_sphere_count++;
+            return false;
+        }
+    }
+
+    return true;
+}

package/engine/graphics/render/forward_plus/query/point_light_inside_volume.js

@@ -0,0 +1,73 @@
+import { detailed_sphere_frustum_intersection_test } from "./detailed_sphere_frustum_intersection_test.js";
+
+/**
+ *
+ * @param {number} light_x
+ * @param {number} light_y
+ * @param {number} light_z
+ * @param {number} radius
+ * @param {number[]} points
+ * @param {number[]|Float32Array|Float64Array} planes
+ * @returns {boolean}
+ */
+export function point_light_inside_volume(
+    light_x, light_y, light_z, radius,
+    points, planes
+) {
+    let j = 0;
+    let outside_plane_count = 0;
+    let outside_plane_bitfield = 0;
+
+    // validate if the sphere intersects the plane-bound space
+
+    // query_bvh_frustum_from_objects.checks_sphere++;
+
+    for (; j < 6; j++) {
+
+        const plane_address = j * 4;
+
+        const plane_normal_x = planes[plane_address];
+        const plane_normal_y = planes[plane_address + 1];
+        const plane_normal_z = planes[plane_address + 2];
+        const plane_constant = planes[plane_address + 3];
+
+        /*
+         compute distance from the center of the sphere to the plane
+         NOTE: inlined computation of distance from point to plane
+         */
+        const distance = (plane_normal_x * light_x + plane_normal_y * light_y + plane_normal_z * light_z) + plane_constant;
+
+        // query_bvh_frustum_from_objects.checks_sphere_plane++;
+
+        if (distance < 0) {
+            // center of the sphere is below the plane
+
+            if (distance < -radius) {
+                // sphere is entirely below the plane
+
+                // query_bvh_frustum_from_objects.rejection_sphere_count++;
+
+                return false;
+            }
+
+            // sphere intersects the plane
+
+            outside_plane_count++;
+
+            const plane_bit_mask = 1 << j;
+
+            outside_plane_bitfield |= plane_bit_mask;
+        }
+
+    }
+
+    if (outside_plane_count < 2) {
+        return true;
+    } else {
+        return detailed_sphere_frustum_intersection_test(
+            radius, light_x, light_y, light_z,
+            outside_plane_count, outside_plane_bitfield,
+            points
+        );
+    }
+}

package/engine/graphics/render/forward_plus/query/query_bvh_frustum_from_objects.js

@@ -0,0 +1,131 @@
+import { aabb3_computeDistanceAbovePlane } from "../../../../../core/geom/3d/aabb/aabb3_computeDistanceAbovePlane.js";
+import { point_light_inside_volume } from "./point_light_inside_volume.js";
+import { spot_light_inside_volume } from "./spot_light_inside_volume.js";
+
+/**
+ *
+ * @type {(BinaryNode|LeafNode)[]}
+ */
+const stack = [];
+
+let stackPointer = 0;
+
+/**
+ * Most of the data is in flat continuous array for cache coherence
+ * @param {PointLightData[]} destination
+ * @param {number} destination_offset
+ * @param {BinaryNode<PointLightData>} root
+ * @param {number[]|Float32Array|Float64Array} planes
+ * @param {number[]|Float32Array|Float64Array} points
+ * @returns {number} number of items added to the destination, non-negative integer
+ */
+export function query_bvh_frustum_from_objects(
+    destination,
+    destination_offset,
+    root, planes, points
+) {
+    let i = 0;
+    let j = 0;
+    // read out points
+    const stackOffset = stackPointer;
+
+    stack[stackPointer] = root;
+
+    stackPointer++;
+
+    stack_loop:while (stackPointer-- > stackOffset) {
+
+        // query_bvh_frustum_from_objects.iteration_count++;
+
+        const n = stack[stackPointer];
+
+        if (n.isBinaryNode === true) {
+
+            for (j = 0; j < 6; j++) {
+
+                const plane_address = j * 4;
+
+                const plane_normal_x = planes[plane_address];
+                const plane_normal_y = planes[plane_address + 1];
+                const plane_normal_z = planes[plane_address + 2];
+                const plane_constant = planes[plane_address + 3];
+
+                const distanceAbovePlane = aabb3_computeDistanceAbovePlane(
+                    plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
+                    n.x0, n.y0, n.z0,
+                    n.x1, n.y1, n.z1
+                );
+
+                if (distanceAbovePlane < 0) {
+                    // node is below the plane
+
+                    // query_bvh_frustum_from_objects.rejection_count++;
+
+                    continue stack_loop;
+                }
+            }
+
+
+            if (n.right !== null) {
+                stack[stackPointer] = n.right;
+                stackPointer++;
+            }
+
+            if (n.left !== null) {
+                stack[stackPointer] = n.left;
+                stackPointer++
+            }
+
+        } else {
+
+            // leaf node
+
+            /**
+             *
+             * @type {PointLightData}
+             */
+            const light_data = n.object;
+
+            const light = light_data.light;
+
+            if (light.isPointLight) {
+
+                const light_position = light.position;
+
+                const light_x = light_position.x;
+                const light_y = light_position.y;
+                const light_z = light_position.z;
+
+                const radius = light.radius.getValue();
+
+                if (!point_light_inside_volume(light_x, light_y, light_z, radius, points, planes)) {
+                    continue;
+                }
+            } else if (light.isSpotLight) {
+                if (!spot_light_inside_volume(light, points, planes)) {
+                    continue;
+                }
+            }
+
+            destination[destination_offset + i] = light_data;
+
+            i++;
+        }
+
+    }
+
+    //drop the stack frame
+    stackPointer = stackOffset;
+
+    return i;
+}
+
+query_bvh_frustum_from_objects.iteration_count = 0;
+query_bvh_frustum_from_objects.rejection_count = 0;
+query_bvh_frustum_from_objects.rejection_sphere_count = 0;
+query_bvh_frustum_from_objects.plane_tests = 0;
+query_bvh_frustum_from_objects.plane_tests_early_exits = 0;
+query_bvh_frustum_from_objects.checks_sphere = 0;
+query_bvh_frustum_from_objects.checks_sphere_plane = 0;
+query_bvh_frustum_from_objects.checks_sphere_frustum_corner = 0;
+query_bvh_frustum_from_objects.checks_sphere_frustum_edge = 0;

package/engine/graphics/render/forward_plus/query/query_bvh_frustum_from_texture.js

@@ -0,0 +1,129 @@
+import { aabb3_computeDistanceAbovePlane } from "../../../../../core/geom/3d/aabb/aabb3_computeDistanceAbovePlane.js";
+import { point_light_inside_volume } from "./point_light_inside_volume.js";
+import { BVH_BINARY_NODE_SIZE, BVH_LEAF_NODE_SIZE } from "../../../../../core/bvh2/binary/2/BinaryUint32BVH.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const stack = [];
+
+/**
+ * Most of the data is in flat continuous array for cache coherence
+ * @param {number[]} destination
+ * @param {number} destination_offset
+ * @param {BinaryUint32BVH} root
+ * @param {number[]|Uint8ClampedArray} source_data
+ * @param {number[]|Float32Array|Float64Array} planes
+ * @param {number[]|Float32Array|Float64Array} points
+ * @returns {number} number of items added to the destination, non-negative integer
+ */
+export function query_bvh_frustum_from_texture(
+    destination,
+    destination_offset,
+    root,
+    source_data,
+    planes, points
+) {
+
+    let stackPointer = 1;
+    let result = 0;
+
+    /**
+     * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
+     * @type {number}
+     */
+    stack[0] = 0;
+
+    const binary_node_count = root.getBinaryNodeCount();
+    const last_valid_index = binary_node_count + root.getLeafNodeCount();
+    const data_view = root.getDataView();
+
+    stack_loop:while (stackPointer-- > 0) {
+
+        // query_bvh_frustum_from_objects.iteration_count++;
+        const node_index = stack[stackPointer];
+
+        if (node_index < binary_node_count) {
+            // is intermediate node
+            const node_address = node_index * BVH_BINARY_NODE_SIZE;
+
+            const n_x0 = data_view.getFloat32(node_address);
+            const n_y0 = data_view.getFloat32(node_address + 4);
+            const n_z0 = data_view.getFloat32(node_address + 8);
+            const n_x1 = data_view.getFloat32(node_address + 12);
+            const n_y1 = data_view.getFloat32(node_address + 16);
+            const n_z1 = data_view.getFloat32(node_address + 20);
+
+            for (let j = 0; j < 6; j++) {
+
+                const plane_address = j * 4;
+
+                const plane_normal_x = planes[plane_address];
+                const plane_normal_y = planes[plane_address + 1];
+                const plane_normal_z = planes[plane_address + 2];
+                const plane_constant = planes[plane_address + 3];
+
+                const distanceAbovePlane = aabb3_computeDistanceAbovePlane(
+                    plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
+                    n_x0, n_y0, n_z0,
+                    n_x1, n_y1, n_z1
+                );
+
+                if (distanceAbovePlane < 0) {
+                    // node is below the plane
+
+                    // query_bvh_frustum_from_objects.rejection_count++;
+
+                    continue stack_loop;
+                }
+
+                // TODO under current scheme we can reserve 6 bit in what we push onto the stack for plane mask (allows us to skip some planar tests)
+            }
+
+            const left_index = (node_index << 1) + 1;
+            const right_index = left_index + 1;
+
+            if (left_index < last_valid_index) {
+                stack[stackPointer] = left_index;
+                stackPointer++;
+            }
+
+            if (right_index < last_valid_index) {
+                stack[stackPointer] = right_index;
+                stackPointer++;
+            }
+
+
+        } else {
+            // leaf node
+            const leaf_index = node_index - binary_node_count;
+            const node_address = leaf_index * BVH_LEAF_NODE_SIZE + binary_node_count * BVH_BINARY_NODE_SIZE;
+
+            const light_index = data_view.getUint32(node_address + 24);
+
+            const light_address = light_index * 8;
+
+            // TODO figure out light type from address
+
+
+            const light_x = source_data[light_address];
+            const light_y = source_data[light_address + 1];
+            const light_z = source_data[light_address + 2];
+
+            const radius = source_data[light_address + 3];
+
+            if (!point_light_inside_volume(light_x, light_y, light_z, radius, points, planes)) {
+                continue;
+            }
+
+            // write to output
+            destination[destination_offset + result] = light_index;
+
+            result++;
+        }
+
+    }
+
+    return result;
+}

package/engine/graphics/render/forward_plus/query/spot_light_inside_volume.js

@@ -0,0 +1,33 @@
+import { computeConePlaneSide } from "../../../../../core/geom/3d/cone/computeConePlaneSide.js";
+
+/**
+ *
+ * @param {SpotLight} light
+ * @param {number[]} points
+ * @param {number[]|Float32Array|Float64Array} planes
+ * @returns {boolean}
+ */
+export function spot_light_inside_volume(light, points, planes) {
+    for (let j = 0; j < 6; j++) {
+
+        const plane_address = j * 4;
+
+        const plane_normal_x = planes[plane_address];
+        const plane_normal_y = planes[plane_address + 1];
+        const plane_normal_z = planes[plane_address + 2];
+        const plane_constant = planes[plane_address + 3];
+
+        const side = computeConePlaneSide(
+            plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
+            light.position.x, light.position.y, light.position.z,
+            light.direction.x, light.direction.y, light.direction.z,
+            light.angle.getValue(), light.distance.getValue()
+        );
+
+        if (side < 0) {
+            return false;
+        }
+    }
+
+    return true;
+}

package/engine/graphics/render/forward_plus/read_frustum_corner.js

@@ -0,0 +1,14 @@
+/**
+ *
+ * @param {number[]|Float32Array|Float64Array} source
+ * @param {number} source_index
+ * @param {number[]|Float32Array|Float64Array} destination
+ * @param {number} destination_offset
+ */
+export function read_frustum_corner(source, source_index, destination, destination_offset) {
+    const address = source_index * 3;
+
+    destination[destination_offset] = source[address];
+    destination[destination_offset + 1] = source[address + 1];
+    destination[destination_offset + 2] = source[address + 2];
+}

package/engine/graphics/render/forward_plus/testClusterEquality.js

@@ -0,0 +1,22 @@
+/**
+ *
+ * @param {number[]} light_data
+ * @param {number} count
+ * @param {number[]|Uint32Array|Uint16Array|Uint8Array|Uint8ClampedArray} light_lookup_texture_data
+ * @param {number} address
+ * @returns {boolean}
+ */
+export function testClusterEquality(light_data, count, light_lookup_texture_data, address) {
+    for (let i = 0; i < count; i++) {
+
+        const existing_light_address = light_lookup_texture_data[address + i];
+
+        const datum = light_data[i] * 2;
+
+        if (datum !== existing_light_address) {
+            return false;
+        }
+    }
+
+    return true;
+}

package/engine/graphics/render/layers/RenderLayerUtils.js

@@ -1,4 +1,3 @@
-import Vector3 from "../../../../core/geom/Vector3.js";
 import { computePointDistanceToPlane } from "../../../../core/geom/Plane.js";
 import { plane_three_computeConvex3PlaneIntersection } from "../../../../core/geom/3d/plane/plane_computeConvex3PlaneIntersection.js";
 
@@ -10,7 +9,11 @@ import { plane_three_computeConvex3PlaneIntersection } from "../../../../core/ge
  */
 export function buildPlanarRenderLayerClipPlaneComputationMethod(traversePlanes, bias = 0) {
 
-    const p = new Vector3();
+    /**
+     *
+     * @type {number[]}
+     */
+    const p = [];
 
     const adjacentPlanePairs = [
         [],
@@ -38,7 +41,7 @@ export function buildPlanarRenderLayerClipPlaneComputationMethod(traversePlanes,
             const p0 = pair[0];
             const p1 = pair[1];
 
-            const planeIntersection = plane_three_computeConvex3PlaneIntersection(p, p0, p1, objectPlane);
+            const planeIntersection = plane_three_computeConvex3PlaneIntersection(p, 0, p0, p1, objectPlane);
 
             if (!planeIntersection) {
                 //no intersection
@@ -48,7 +51,7 @@ export function buildPlanarRenderLayerClipPlaneComputationMethod(traversePlanes,
 
             const plane_normal = nearPlane.normal;
 
-            const distanceToNearPlane = computePointDistanceToPlane(p.x, p.y, p.z, plane_normal.x, plane_normal.y, plane_normal.z, nearPlane.constant);
+            const distanceToNearPlane = computePointDistanceToPlane(p[0], p[1], p[2], plane_normal.x, plane_normal.y, plane_normal.z, nearPlane.constant);
 
             //update near and far plane distances
             if (distanceToNearPlane > 0 && distanceToNearPlane < range.near) {

package/engine/graphics/render/visibility/IncrementalDeltaSet.js

@@ -2,6 +2,7 @@ import { BitSet } from "../../../../core/binary/BitSet.js";
 import Signal from "../../../../core/events/signal/Signal.js";
 import { assert } from "../../../../core/assert.js";
 import { IllegalStateException } from "../../../../core/fsm/exceptions/IllegalStateException.js";
+import { arrayQuickSort } from "../../../../core/collection/array/arrayQuickSort.js";
 
 /**
  * @readonly
@@ -68,6 +69,16 @@ export class IncrementalDeltaSet {
         this.state = IncrementalDeltaSetState.Clear;
     }
 
+
+    /**
+     *
+     * @param {function(T):number} score_function
+     * @param {*} [score_context]
+     */
+    sort(score_function, score_context) {
+        arrayQuickSort(this.elements, score_function, score_context, 0, this.size - 1);
+    }
+
     /**
      *
      * @param {V} element

package/engine/graphics/render/visibility/hiz/prototypeHiZ.js

@@ -62,7 +62,6 @@ import { buildCanvasViewFromTexture } from "./buildCanvasViewFromTexture.js";
 import { BatchOcclusionQuery } from "./query/BatchOcclusionQuery.js";
 import HeadsUpDisplay from "../../../../ecs/gui/hud/HeadsUpDisplay.js";
 import LabelView from "../../../../../view/common/LabelView.js";
-import { randomFloatBetween } from "../../../../../core/math/MathUtils.js";
 import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
 import { Sampler2D } from "../../../texture/sampler/Sampler2D.js";
 import { inverseLerp } from "../../../../../core/math/inverseLerp.js";
@@ -71,6 +70,7 @@ import { max2 } from "../../../../../core/math/max2.js";
 import { min2 } from "../../../../../core/math/min2.js";
 import { buildCubeURLs } from "../../../texture/cubemap/buildCubeURLs.js";
 import { mat4 } from "gl-matrix";
+import { randomFloatBetween } from "../../../../../core/math/random/randomFloatBetween.js";
 
 const engineHarness = new EngineHarness();
 
@@ -112,7 +112,7 @@ function makeConfig(engine) {
         new ClingToTerrainSystem(),
         new TerrainSystem(graphics, assetManager),
         new WaterSystem(graphics),
-        new Trail2DSystem(graphics, assetManager),
+        new Trail2DSystem(engine),
         new Foliage2System(assetManager, graphics),
         new ViewportPositionSystem(graphics.viewport.size),
         new GridPosition2TransformSystem(),

package/engine/graphics/shaders/TerrainShader.js

@@ -121,7 +121,6 @@ function fragment() {
     uniform float opacity;
     
     varying vec3 vViewPosition;
-
    
 
     #include <common>
@@ -364,10 +363,10 @@ function fragment() {
         
         vec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;
                     
-        pc_fragColor  = vec4( outgoingLight, diffuseColor.a );
+        gl_FragColor  = vec4( outgoingLight, diffuseColor.a );
       
         #if defined( TONE_MAPPING )
-            pc_fragColor.rgb = toneMapping( pc_fragColor.rgb );
+            gl_FragColor.rgb = toneMapping( pc_fragColor.rgb );
         #endif
         
         //encode fragment
@@ -378,12 +377,12 @@ function fragment() {
             #else
                 float fogFactor = smoothstep( fogNear, fogFar, fogDepth );
             #endif
-            pc_fragColor.rgb = mix( pc_fragColor.rgb, fogColor, fogFactor );
+            gl_FragColor.rgb = mix( pc_fragColor.rgb, fogColor, fogFactor );
         #endif
         
         #ifdef PREMULTIPLIED_ALPHA
             // Get get normal blending with premultipled, use with CustomBlending, OneFactor, OneMinusSrcAlphaFactor, AddEquation.
-            pc_fragColor.rgb *= pc_fragColor.a;
+            gl_FragColor.rgb *= pc_fragColor.a;
         #endif
         
         #ifdef DITHERING

package/engine/graphics/shadows/ShadowMapRenderer.js

@@ -173,13 +173,19 @@ export class ShadowMapRenderer {
 
         if (shadow.map === null) {
 
-            const pars = { format: RGBAFormat };
+            const pars = {
+                format: RGBAFormat,
+                scissorTest: false,
+                stencilBuffer: false
+            };
 
             if (!shadow.isPointLightShadow && renderer.shadowMap.type === VSMShadowMap) {
                 pars.minFilter = LinearFilter;
                 pars.magFilter = LinearFilter;
 
-                shadow.mapPass = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, pars);
+                shadow.mapPass = new WebGLRenderTarget(_shadowMapSize.x, _shadowMapSize.y, Object.assign({
+                    depthBuffer: false
+                }, pars));
 
             } else {
                 pars.minFilter = NearestFilter;