Cesium-Prequel/Specs/Scene/Cesium3DTileSpec.js

import { Cartesian3 } from "../../Source/Cesium.js";
import { clone } from "../../Source/Cesium.js";
import { HeadingPitchRoll } from "../../Source/Cesium.js";
import { Math as CesiumMath } from "../../Source/Cesium.js";
import { Matrix3 } from "../../Source/Cesium.js";
import { Matrix4 } from "../../Source/Cesium.js";
import { Rectangle } from "../../Source/Cesium.js";
import { Transforms } from "../../Source/Cesium.js";
import { Cesium3DTile } from "../../Source/Cesium.js";
import { Cesium3DTilePass } from "../../Source/Cesium.js";
import { Cesium3DTileRefine } from "../../Source/Cesium.js";
import { Cesium3DTilesetHeatmap } from "../../Source/Cesium.js";
import { TileBoundingRegion } from "../../Source/Cesium.js";
import { TileOrientedBoundingBox } from "../../Source/Cesium.js";
import createScene from "../createScene.js";

describe(
  "Scene/Cesium3DTile",
  function () {
    var tileWithBoundingSphere = {
      geometricError: 1,
      refine: "REPLACE",
      children: [],
      boundingVolume: {
        sphere: [0.0, 0.0, 0.0, 5.0],
      },
    };

    var tileWithContentBoundingSphere = {
      geometricError: 1,
      refine: "REPLACE",
      content: {
        url: "0/0.b3dm",
        boundingVolume: {
          sphere: [0.0, 0.0, 1.0, 5.0],
        },
      },
      children: [],
      boundingVolume: {
        sphere: [0.0, 0.0, 1.0, 5.0],
      },
    };

    var tileWithBoundingRegion = {
      geometricError: 1,
      refine: "REPLACE",
      children: [],
      boundingVolume: {
        region: [-1.2, -1.2, 0.0, 0.0, -30, -34],
      },
    };

    var tileWithContentBoundingRegion = {
      geometricError: 1,
      refine: "REPLACE",
      children: [],
      content: {
        url: "0/0.b3dm",
        boundingVolume: {
          region: [-1.2, -1.2, 0, 0, -30, -34],
        },
      },
      boundingVolume: {
        region: [-1.2, -1.2, 0, 0, -30, -34],
      },
    };

    var tileWithBoundingBox = {
      geometricError: 1,
      refine: "REPLACE",
      children: [],
      boundingVolume: {
        box: [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0],
      },
    };

    var tileWithContentBoundingBox = {
      geometricError: 1,
      refine: "REPLACE",
      children: [],
      content: {
        url: "0/0.b3dm",
        boundingVolume: {
          box: [0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 2.0],
        },
      },
      boundingVolume: {
        box: [0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 2.0],
      },
    };

    var tileWithViewerRequestVolume = {
      geometricError: 1,
      refine: "REPLACE",
      children: [],
      boundingVolume: {
        box: [0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 2.0],
      },
      viewerRequestVolume: {
        box: [0.0, 0.0, 1.0, 2.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 2.0],
      },
    };

    var mockTileset = {
      debugShowBoundingVolume: true,
      debugShowViewerRequestVolume: true,
      modelMatrix: Matrix4.IDENTITY,
      _geometricError: 2,
      _heatmap: new Cesium3DTilesetHeatmap(),
    };

    var centerLongitude = -1.31968;
    var centerLatitude = 0.698874;

    function getTileTransform(longitude, latitude) {
      var transformCenter = Cartesian3.fromRadians(longitude, latitude, 0.0);
      var hpr = new HeadingPitchRoll();
      var transformMatrix = Transforms.headingPitchRollToFixedFrame(
        transformCenter,
        hpr
      );
      return Matrix4.pack(transformMatrix, new Array(16));
    }

    it("destroys", function () {
      var tile = new Cesium3DTile(
        mockTileset,
        "/some_url",
        tileWithBoundingSphere,
        undefined
      );
      expect(tile.isDestroyed()).toEqual(false);
      tile.destroy();
      expect(tile.isDestroyed()).toEqual(true);
    });

    it("throws if boundingVolume is undefined", function () {
      var tileWithoutBoundingVolume = clone(tileWithBoundingSphere, true);
      delete tileWithoutBoundingVolume.boundingVolume;
      expect(function () {
        return new Cesium3DTile(
          mockTileset,
          "/some_url",
          tileWithoutBoundingVolume,
          undefined
        );
      }).toThrowRuntimeError();
    });

    it("throws if boundingVolume does not contain a sphere, region, or box", function () {
      var tileWithoutBoundingVolume = clone(tileWithBoundingSphere, true);
      delete tileWithoutBoundingVolume.boundingVolume.sphere;
      expect(function () {
        return new Cesium3DTile(
          mockTileset,
          "/some_url",
          tileWithoutBoundingVolume,
          undefined
        );
      }).toThrowRuntimeError();
    });

    it("logs deprecation warning if refine is lowercase", function () {
      spyOn(Cesium3DTile, "_deprecationWarning");
      var header = clone(tileWithBoundingSphere, true);
      header.refine = "replace";
      var tile = new Cesium3DTile(mockTileset, "/some_url", header, undefined);
      expect(tile.refine).toBe(Cesium3DTileRefine.REPLACE);
      expect(Cesium3DTile._deprecationWarning).toHaveBeenCalled();
    });

    it("logs deprecation warning if geometric error is undefined", function () {
      spyOn(Cesium3DTile, "_deprecationWarning");

      var geometricErrorMissing = clone(tileWithBoundingSphere, true);
      delete geometricErrorMissing.geometricError;

      var parent = new Cesium3DTile(
        mockTileset,
        "/some_url",
        tileWithBoundingSphere,
        undefined
      );
      var child = new Cesium3DTile(
        mockTileset,
        "/some_url",
        geometricErrorMissing,
        parent
      );
      expect(child.geometricError).toBe(parent.geometricError);
      expect(child.geometricError).toBe(1);

      var tile = new Cesium3DTile(
        mockTileset,
        "/some_url",
        geometricErrorMissing,
        undefined
      );
      expect(tile.geometricError).toBe(mockTileset._geometricError);
      expect(tile.geometricError).toBe(2);

      expect(Cesium3DTile._deprecationWarning.calls.count()).toBe(2);
    });

    describe("bounding volumes", function () {
      it("returns the tile bounding volume if the content bounding volume is undefined", function () {
        var tile = new Cesium3DTile(
          mockTileset,
          "/some_url",
          tileWithBoundingSphere,
          undefined
        );
        expect(tile.boundingVolume).toBeDefined();
        expect(tile.contentBoundingVolume).toBe(tile.boundingVolume);
      });

      it("can have a bounding sphere", function () {
        var tile = new Cesium3DTile(
          mockTileset,
          "/some_url",
          tileWithBoundingSphere,
          undefined
        );
        var radius = tileWithBoundingSphere.boundingVolume.sphere[3];
        expect(tile.boundingVolume).toBeDefined();
        expect(tile.boundingVolume.boundingVolume.radius).toEqual(radius);
        expect(tile.boundingVolume.boundingVolume.center).toEqual(
          Cartesian3.ZERO
        );
      });

      it("can have a content bounding sphere", function () {
        var tile = new Cesium3DTile(
          mockTileset,
          "/some_url",
          tileWithContentBoundingSphere,
          undefined
        );
        var radius =
          tileWithContentBoundingSphere.content.boundingVolume.sphere[3];
        expect(tile.contentBoundingVolume).toBeDefined();
        expect(tile.contentBoundingVolume.boundingVolume.radius).toEqual(
          radius
        );
        expect(tile.contentBoundingVolume.boundingVolume.center).toEqual(
          new Cartesian3(0.0, 0.0, 1.0)
        );
      });

      it("can have a bounding region", function () {
        var box = tileWithBoundingRegion.boundingVolume.region;
        var rectangle = new Rectangle(box[0], box[1], box[2], box[3]);
        var minimumHeight = tileWithBoundingRegion.boundingVolume.region[4];
        var maximumHeight = tileWithBoundingRegion.boundingVolume.region[5];
        var tile = new Cesium3DTile(
          mockTileset,
          "/some_url",
          tileWithBoundingRegion,
          undefined
        );
        var tbr = new TileBoundingRegion({
          rectangle: rectangle,
          minimumHeight: minimumHeight,
          maximumHeight: maximumHeight,
        });
        expect(tile.boundingVolume).toBeDefined();
        expect(tile.boundingVolume).toEqual(tbr);
      });

      it("can have a content bounding region", function () {
        var region =
          tileWithContentBoundingRegion.content.boundingVolume.region;
        var tile = new Cesium3DTile(
          mockTileset,
          "/some_url",
          tileWithContentBoundingRegion,
          undefined
        );
        expect(tile.contentBoundingVolume).toBeDefined();
        var tbb = new TileBoundingRegion({
          rectangle: new Rectangle(region[0], region[1], region[2], region[3]),
          minimumHeight: region[4],
          maximumHeight: region[5],
        });
        expect(tile.contentBoundingVolume).toEqual(tbb);
      });

      it("can have an oriented bounding box", function () {
        var box = tileWithBoundingBox.boundingVolume.box;
        var tile = new Cesium3DTile(
          mockTileset,
          "/some_url",
          tileWithBoundingBox,
          undefined
        );
        expect(tile.boundingVolume).toBeDefined();
        var center = new Cartesian3(box[0], box[1], box[2]);
        var halfAxes = Matrix3.fromArray(box, 3);
        var obb = new TileOrientedBoundingBox(center, halfAxes);
        expect(tile.boundingVolume).toEqual(obb);
      });

      it("does not crash for bounding box with 0 volume", function () {
        // Create a copy of the tile with bounding box.
        var tileWithBoundingBox0Volume = JSON.parse(
          JSON.stringify(tileWithBoundingBox)
        );
        // Generate all the combinations of missing axes.
        var boxes = [];
        for (var x = 0; x < 2; ++x) {
          for (var y = 0; y < 2; ++y) {
            for (var z = 0; z < 2; ++z) {
              boxes.push([
                0.0,
                0.0,
                0.0,
                x,
                0.0,
                0.0,
                0.0,
                y,
                0.0,
                0.0,
                0.0,
                z,
              ]);
            }
          }
        }

        for (var i = 0; i < boxes.length; ++i) {
          var box = boxes[i];

          tileWithBoundingBox0Volume.boundingVolume.box = box;

          var tile = new Cesium3DTile(
            mockTileset,
            "/some_url",
            tileWithBoundingBox0Volume,
            undefined
          );
          expect(tile.boundingVolume).toBeDefined();
          var center = new Cartesian3(box[0], box[1], box[2]);
          var halfAxes = Matrix3.fromArray(box, 3);
          var obb = new TileOrientedBoundingBox(center, halfAxes);
          expect(tile.boundingVolume).toEqual(obb);
        }
      });

      it("can have a content oriented bounding box", function () {
        var box = tileWithContentBoundingBox.boundingVolume.box;
        var tile = new Cesium3DTile(
          mockTileset,
          "/some_url",
          tileWithContentBoundingBox,
          undefined
        );
        expect(tile.contentBoundingVolume).toBeDefined();
        var center = new Cartesian3(box[0], box[1], box[2]);
        var halfAxes = Matrix3.fromArray(box, 3);
        var obb = new TileOrientedBoundingBox(center, halfAxes);
        expect(tile.contentBoundingVolume).toEqual(obb);
      });

      it("tile transform affects bounding sphere", function () {
        var header = clone(tileWithContentBoundingSphere, true);
        header.transform = getTileTransform(centerLongitude, centerLatitude);
        var tile = new Cesium3DTile(
          mockTileset,
          "/some_url",
          header,
          undefined
        );
        var boundingSphere = tile.boundingVolume.boundingVolume;
        var contentBoundingSphere = tile.contentBoundingVolume.boundingVolume;

        var boundingVolumeCenter = Cartesian3.fromRadians(
          centerLongitude,
          centerLatitude,
          1.0
        );
        expect(boundingSphere.center).toEqualEpsilon(
          boundingVolumeCenter,
          CesiumMath.EPSILON4
        );
        expect(boundingSphere.radius).toEqual(5.0); // No change

        expect(contentBoundingSphere.center).toEqualEpsilon(
          boundingVolumeCenter,
          CesiumMath.EPSILON4
        );
        expect(contentBoundingSphere.radius).toEqual(5.0); // No change
      });

      it("tile transform affects oriented bounding box", function () {
        var header = clone(tileWithContentBoundingBox, true);
        header.transform = getTileTransform(centerLongitude, centerLatitude);
        var tile = new Cesium3DTile(
          mockTileset,
          "/some_url",
          header,
          undefined
        );
        var boundingBox = tile.boundingVolume.boundingVolume;
        var contentBoundingBox = tile.contentBoundingVolume.boundingVolume;

        var boundingVolumeCenter = Cartesian3.fromRadians(
          centerLongitude,
          centerLatitude,
          1.0
        );
        expect(boundingBox.center).toEqualEpsilon(
          boundingVolumeCenter,
          CesiumMath.EPSILON7
        );
        expect(contentBoundingBox.center).toEqualEpsilon(
          boundingVolumeCenter,
          CesiumMath.EPSILON7
        );
      });

      it("tile transform does not affect bounding region", function () {
        var header = clone(tileWithContentBoundingRegion, true);
        header.transform = getTileTransform(centerLongitude, centerLatitude);
        var tile = new Cesium3DTile(
          mockTileset,
          "/some_url",
          header,
          undefined
        );
        var boundingRegion = tile.boundingVolume;
        var contentBoundingRegion = tile.contentBoundingVolume;

        var region = header.boundingVolume.region;
        var rectangle = Rectangle.unpack(region);
        expect(boundingRegion.rectangle).toEqual(rectangle);
        expect(contentBoundingRegion.rectangle).toEqual(rectangle);
      });

      it("tile transform affects viewer request volume", function () {
        var header = clone(tileWithViewerRequestVolume, true);
        header.transform = getTileTransform(centerLongitude, centerLatitude);
        var tile = new Cesium3DTile(
          mockTileset,
          "/some_url",
          header,
          undefined
        );
        var requestVolume = tile._viewerRequestVolume.boundingVolume;
        var requestVolumeCenter = Cartesian3.fromRadians(
          centerLongitude,
          centerLatitude,
          1.0
        );
        expect(requestVolume.center).toEqualEpsilon(
          requestVolumeCenter,
          CesiumMath.EPSILON7
        );
      });

      it("tile transform changes", function () {
        var mockTileset = {
          modelMatrix: Matrix4.IDENTITY,
        };
        var header = clone(tileWithBoundingSphere, true);
        header.transform = getTileTransform(centerLongitude, centerLatitude);
        var tile = new Cesium3DTile(
          mockTileset,
          "/some_url",
          header,
          undefined
        );
        var boundingSphere = tile.boundingVolume.boundingVolume;

        // Check the original transform
        var boundingVolumeCenter = Cartesian3.fromRadians(
          centerLongitude,
          centerLatitude
        );
        expect(boundingSphere.center).toEqualEpsilon(
          boundingVolumeCenter,
          CesiumMath.EPSILON7
        );

        // Change the transform
        var newLongitude = -1.012;
        var newLatitude = 0.698874;
        tile.transform = getTileTransform(newLongitude, newLatitude);
        tile.updateTransform();

        // Check the new transform
        var newCenter = Cartesian3.fromRadians(newLongitude, newLatitude);
        expect(boundingSphere.center).toEqualEpsilon(
          newCenter,
          CesiumMath.EPSILON7
        );
      });
    });

    describe("debug bounding volumes", function () {
      var scene;
      beforeEach(function () {
        scene = createScene();
        scene.frameState.passes.render = true;
      });

      afterEach(function () {
        scene.destroyForSpecs();
      });

      it("can be a bounding region", function () {
        var tile = new Cesium3DTile(
          mockTileset,
          "/some_url",
          tileWithBoundingRegion,
          undefined
        );
        var passOptions = Cesium3DTilePass.getPassOptions(
          Cesium3DTilePass.RENDER
        );
        tile.update(mockTileset, scene.frameState, passOptions);
        expect(tile._debugBoundingVolume).toBeDefined();
      });

      it("can be an oriented bounding box", function () {
        var tile = new Cesium3DTile(
          mockTileset,
          "/some_url",
          tileWithBoundingBox,
          undefined
        );
        var passOptions = Cesium3DTilePass.getPassOptions(
          Cesium3DTilePass.RENDER
        );
        tile.update(mockTileset, scene.frameState, passOptions);
        expect(tile._debugBoundingVolume).toBeDefined();
      });

      it("can be a bounding sphere", function () {
        var tile = new Cesium3DTile(
          mockTileset,
          "/some_url",
          tileWithBoundingSphere,
          undefined
        );
        var passOptions = Cesium3DTilePass.getPassOptions(
          Cesium3DTilePass.RENDER
        );
        tile.update(mockTileset, scene.frameState, passOptions);
        expect(tile._debugBoundingVolume).toBeDefined();
      });

      it("creates debug bounding volume for viewer request volume", function () {
        var tile = new Cesium3DTile(
          mockTileset,
          "/some_url",
          tileWithViewerRequestVolume,
          undefined
        );
        var passOptions = Cesium3DTilePass.getPassOptions(
          Cesium3DTilePass.RENDER
        );
        tile.update(mockTileset, scene.frameState, passOptions);
        expect(tile._debugViewerRequestVolume).toBeDefined();
      });
    });

    it("updates priority", function () {
      var tile1 = new Cesium3DTile(
        mockTileset,
        "/some_url",
        tileWithBoundingSphere,
        undefined
      );
      tile1._priorityHolder = tile1;
      tile1._foveatedFactor = 0.0;
      tile1._distanceToCamera = 1.0;
      tile1._depth = 0.0;
      tile1._priorityProgressiveResolution = true;

      var tile2 = new Cesium3DTile(
        mockTileset,
        "/some_url",
        tileWithBoundingSphere,
        undefined
      );
      tile2._priorityHolder = tile1;
      tile2._foveatedFactor = 1.0; // foveatedFactor (when considered for priority in certain modes) is actually 0 since its linked up to tile1
      tile2._distanceToCamera = 0.0;
      tile2._depth = 1.0;
      tile2._priorityProgressiveResolution = true;

      mockTileset._minimumPriority = {
        depth: 0.0,
        distance: 0.0,
        foveatedFactor: 0.0,
      };
      mockTileset._maximumPriority = {
        depth: 1.0,
        distance: 1.0,
        foveatedFactor: 1.0,
      };

      tile1.updatePriority();
      tile2.updatePriority();

      var nonPreloadFlightPenalty = 10000000000.0;
      var tile1ExpectedPriority = nonPreloadFlightPenalty + 0.0;
      var tile2ExpectedPriority = nonPreloadFlightPenalty + 1.0;
      expect(
        CesiumMath.equalsEpsilon(
          tile1._priority,
          tile1ExpectedPriority,
          CesiumMath.EPSILON2
        )
      ).toBe(true);
      expect(
        CesiumMath.equalsEpsilon(
          tile2._priority,
          tile2ExpectedPriority,
          CesiumMath.EPSILON2
        )
      ).toBe(true);

      // Penalty for not being a progressive resolution
      tile2._priorityProgressiveResolution = false;
      tile2.updatePriority();
      var nonProgressiveResoutionPenalty = 100000000.0;
      expect(tile2._priority).toBeGreaterThan(nonProgressiveResoutionPenalty);
      tile2._priorityProgressiveResolution = true;

      // Penalty for being a foveated deferral
      tile2.priorityDeferred = true;
      tile2.updatePriority();
      var foveatedDeferralPenalty = 10000000.0;
      expect(tile2._priority).toBeGreaterThanOrEqualTo(foveatedDeferralPenalty);
      tile2._priorityDeferred = false;
    });
  },
  "WebGL"
);