import { BoundingSphere } from "../../Source/Cesium.js";
|
import { Cartesian3 } from "../../Source/Cesium.js";
|
import { Clock } from "../../Source/Cesium.js";
|
import { ClockStep } from "../../Source/Cesium.js";
|
import { defaultValue } from "../../Source/Cesium.js";
|
import { defined } from "../../Source/Cesium.js";
|
import { HeadingPitchRange } from "../../Source/Cesium.js";
|
import { HeadingPitchRoll } from "../../Source/Cesium.js";
|
import { JulianDate } from "../../Source/Cesium.js";
|
import { Matrix4 } from "../../Source/Cesium.js";
|
import { Resource } from "../../Source/Cesium.js";
|
import { TimeIntervalCollection } from "../../Source/Cesium.js";
|
import { Transforms } from "../../Source/Cesium.js";
|
import { Cesium3DTileStyle } from "../../Source/Cesium.js";
|
import { ClippingPlane } from "../../Source/Cesium.js";
|
import { ClippingPlaneCollection } from "../../Source/Cesium.js";
|
import { DracoLoader } from "../../Source/Cesium.js";
|
import { PointCloudEyeDomeLighting } from "../../Source/Cesium.js";
|
import { ShadowMode } from "../../Source/Cesium.js";
|
import { TimeDynamicPointCloud } from "../../Source/Cesium.js";
|
import createCanvas from "../createCanvas.js";
|
import createScene from "../createScene.js";
|
import pollToPromise from "../pollToPromise.js";
|
import { when } from "../../Source/Cesium.js";
|
|
describe(
|
"Scene/TimeDynamicPointCloud",
|
function () {
|
var scene;
|
|
var center = new Cartesian3(
|
1215012.8828876738,
|
-4736313.051199594,
|
4081605.22126042
|
);
|
|
var clock = new Clock({
|
clockStep: ClockStep.TICK_DEPENDENT,
|
shouldAnimate: true,
|
});
|
|
var dates = [
|
JulianDate.fromIso8601("2018-07-19T15:18:00Z"),
|
JulianDate.fromIso8601("2018-07-19T15:18:00.5Z"),
|
JulianDate.fromIso8601("2018-07-19T15:18:01Z"),
|
JulianDate.fromIso8601("2018-07-19T15:18:01.5Z"),
|
JulianDate.fromIso8601("2018-07-19T15:18:02Z"),
|
JulianDate.fromIso8601("2018-07-19T15:18:02.5Z"),
|
];
|
|
var transforms = [
|
Matrix4.fromColumnMajorArray([
|
0.968635634376879,
|
0.24848542777253735,
|
0,
|
0,
|
-0.15986460794399626,
|
0.6231776137472074,
|
0.7655670897127491,
|
0,
|
0.190232265775849,
|
-0.7415555636019701,
|
0.6433560687121489,
|
0,
|
1215012.8828876738,
|
-4736313.051199594,
|
4081605.22126042,
|
1,
|
]),
|
Matrix4.fromColumnMajorArray([
|
0.968634888916237,
|
0.24848833367832227,
|
0,
|
0,
|
-0.1598664774761181,
|
0.6231771341505793,
|
0.7655670897127493,
|
0,
|
0.19023449044168372,
|
-0.7415549929018358,
|
0.6433560687121489,
|
0,
|
1215027.0918213597,
|
-4736309.406139632,
|
4081605.22126042,
|
1,
|
]),
|
Matrix4.fromColumnMajorArray([
|
0.9686341434468771,
|
0.24849123958187078,
|
0,
|
0,
|
-0.1598683470068011,
|
0.6231766545483426,
|
0.7655670897127493,
|
0,
|
0.19023671510580634,
|
-0.7415544221950274,
|
0.6433560687121489,
|
0,
|
1215041.3007441103,
|
-4736305.761037043,
|
4081605.22126042,
|
1,
|
]),
|
Matrix4.fromColumnMajorArray([
|
0.9686333979687994,
|
0.24849414548318288,
|
0,
|
0,
|
-0.15987021653604533,
|
0.6231761749404972,
|
0.7655670897127491,
|
0,
|
0.19023893976821685,
|
-0.7415538514815451,
|
0.6433560687121489,
|
0,
|
1215055.5096559257,
|
-4736302.115891827,
|
4081605.22126042,
|
1,
|
]),
|
Matrix4.fromColumnMajorArray([
|
0.9686326524820043,
|
0.2484970513822586,
|
0,
|
0,
|
-0.15987208606385075,
|
0.6231756953270434,
|
0.7655670897127492,
|
0,
|
0.19024116442891523,
|
-0.7415532807613887,
|
0.6433560687121489,
|
0,
|
1215069.7185568055,
|
-4736298.470703985,
|
4081605.22126042,
|
1,
|
]),
|
];
|
|
function createIntervals(useTransforms, useDraco) {
|
var folderName;
|
if (useTransforms) {
|
folderName =
|
"Data/Cesium3DTiles/PointCloud/PointCloudTimeDynamicWithTransform/";
|
} else if (useDraco) {
|
folderName =
|
"Data/Cesium3DTiles/PointCloud/PointCloudTimeDynamicDraco/";
|
} else {
|
folderName = "Data/Cesium3DTiles/PointCloud/PointCloudTimeDynamic/";
|
}
|
|
var uris = [];
|
for (var i = 0; i < 5; ++i) {
|
uris.push(folderName + i + ".pnts");
|
}
|
|
function dataCallback(interval, index) {
|
return {
|
uri: uris[index],
|
transform: useTransforms ? transforms[index] : undefined,
|
};
|
}
|
|
return TimeIntervalCollection.fromJulianDateArray({
|
julianDates: dates,
|
dataCallback: dataCallback,
|
});
|
}
|
|
function createTimeDynamicPointCloud(options) {
|
options = defaultValue(options, {});
|
var useTransforms = defaultValue(options.useTransforms, false);
|
var useDraco = defaultValue(options.useDraco, false);
|
options.intervals = createIntervals(useTransforms, useDraco);
|
options.clock = clock;
|
if (!defined(options.style)) {
|
options.style = new Cesium3DTileStyle({
|
color: 'color("red")',
|
pointSize: 10,
|
});
|
}
|
return scene.primitives.add(new TimeDynamicPointCloud(options));
|
}
|
|
function zoomTo(center) {
|
scene.camera.lookAt(center, new HeadingPitchRange(0.0, -1.57, 5.0));
|
}
|
|
function loadFrame(pointCloud, index) {
|
index = defaultValue(index, 0);
|
goToFrame(index);
|
return pollToPromise(function () {
|
scene.renderForSpecs();
|
var frame = pointCloud._frames[index];
|
var ready = defined(frame) && frame.ready;
|
if (ready) {
|
scene.renderForSpecs();
|
}
|
return ready;
|
});
|
}
|
|
function getLoadFrameFunction(pointCloud, index) {
|
return function () {
|
return loadFrame(pointCloud, index);
|
};
|
}
|
|
function loadFrames(pointCloud, indexes) {
|
var length = indexes.length;
|
var promise = getLoadFrameFunction(pointCloud, indexes[0])();
|
for (var i = 1; i < length; ++i) {
|
promise = promise.then(getLoadFrameFunction(pointCloud, indexes[i]));
|
}
|
return promise.then(function () {
|
goToFrame(indexes[0]);
|
});
|
}
|
|
function loadAllFrames(pointCloud) {
|
return loadFrames(pointCloud, [0, 1, 2, 3, 4]);
|
}
|
|
function goToFrame(index) {
|
clock.currentTime = dates[index];
|
clock.multiplier = 0.0;
|
}
|
|
function initializeScene() {
|
scene.morphTo3D(0.0);
|
zoomTo(center);
|
goToFrame(0);
|
}
|
|
beforeAll(function () {
|
scene = createScene();
|
});
|
|
afterAll(function () {
|
scene.destroyForSpecs();
|
});
|
|
beforeEach(function () {
|
initializeScene();
|
});
|
|
afterEach(function () {
|
scene.primitives.removeAll();
|
});
|
|
it("throws if options.clock is undefined", function () {
|
var intervals = createIntervals();
|
expect(function () {
|
return new TimeDynamicPointCloud({
|
intervals: intervals,
|
});
|
}).toThrowDeveloperError();
|
});
|
|
it("throws if options.intervals is undefined", function () {
|
expect(function () {
|
return new TimeDynamicPointCloud({
|
clock: clock,
|
});
|
}).toThrowDeveloperError();
|
});
|
|
it("renders in 3D", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
return loadFrame(pointCloud).then(function () {
|
scene.morphTo3D(0.0);
|
expect(scene).toRender([255, 0, 0, 255]);
|
goToFrame(1);
|
expect(scene).toRender([255, 0, 0, 255]);
|
scene.camera.moveRight(10.0);
|
expect(scene).toRender([0, 0, 0, 255]);
|
});
|
});
|
|
it("renders in 2D", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
return loadFrame(pointCloud).then(function () {
|
scene.morphTo2D(0.0);
|
expect(scene).toRender([255, 0, 0, 255]);
|
goToFrame(1);
|
expect(scene).toRender([255, 0, 0, 255]);
|
scene.camera.moveRight(10.0);
|
expect(scene).toRender([0, 0, 0, 255]);
|
});
|
});
|
|
it("renders in CV", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
return loadFrame(pointCloud).then(function () {
|
scene.morphToColumbusView(0.0);
|
expect(scene).toRender([255, 0, 0, 255]);
|
goToFrame(1);
|
expect(scene).toRender([255, 0, 0, 255]);
|
scene.camera.moveRight(10.0);
|
expect(scene).toRender([0, 0, 0, 255]);
|
});
|
});
|
|
it("gets bounding sphere of the rendered frame", function () {
|
var pointCloud = createTimeDynamicPointCloud({
|
useTransforms: true,
|
});
|
expect(pointCloud.boundingSphere).toBeUndefined(); // Undefined until a frame is rendered
|
return loadAllFrames(pointCloud).then(function () {
|
var boundingSphereFrame0 = pointCloud.boundingSphere;
|
expect(boundingSphereFrame0).toBeDefined();
|
goToFrame(1);
|
scene.renderForSpecs();
|
var boundingSphereFrame1 = pointCloud.boundingSphere;
|
expect(boundingSphereFrame1).toBeDefined();
|
expect(
|
BoundingSphere.equals(boundingSphereFrame0, boundingSphereFrame1)
|
).toBe(false);
|
});
|
});
|
|
it("resolves ready promise", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
return loadFrame(pointCloud).then(function () {
|
return pointCloud.readyPromise.then(function (pointCloud) {
|
expect(pointCloud.boundingSphere).toBeDefined();
|
});
|
});
|
});
|
|
it("sets show", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
|
return loadFrame(pointCloud).then(function () {
|
expect(scene).toRender([255, 0, 0, 255]);
|
pointCloud.show = false;
|
expect(scene).toRender([0, 0, 0, 255]);
|
});
|
});
|
|
it("sets model matrix", function () {
|
var translation = new Cartesian3(10000, 2000, 100);
|
var modelMatrix = Matrix4.fromTranslation(translation);
|
var newCenter = Cartesian3.add(center, translation, new Cartesian3());
|
var pointCloud = createTimeDynamicPointCloud({
|
modelMatrix: modelMatrix,
|
});
|
return loadFrame(pointCloud).then(function () {
|
expect(scene).toRender([0, 0, 0, 255]); // Out of view
|
zoomTo(newCenter);
|
expect(scene).toRender([255, 0, 0, 255]);
|
pointCloud.modelMatrix = Matrix4.IDENTITY;
|
expect(scene).toRender([0, 0, 0, 255]); // Out of view
|
zoomTo(center);
|
expect(scene).toRender([255, 0, 0, 255]);
|
});
|
});
|
|
it("sets shadows", function () {
|
var pointCloud = createTimeDynamicPointCloud({
|
shadows: ShadowMode.DISABLED,
|
});
|
return loadFrame(pointCloud).then(function () {
|
scene.renderForSpecs();
|
expect(scene.frameState.commandList[0].castShadows).toBe(false);
|
expect(scene.frameState.commandList[0].receiveShadows).toBe(false);
|
pointCloud.shadows = ShadowMode.ENABLED;
|
scene.renderForSpecs();
|
expect(scene.frameState.commandList[0].castShadows).toBe(true);
|
expect(scene.frameState.commandList[0].receiveShadows).toBe(true);
|
});
|
});
|
|
it("honors maximumMemoryUsage by unloading all frames not currently being loaded or rendered", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
return loadAllFrames(pointCloud).then(function () {
|
var singleFrameMemoryUsage = 33000;
|
var frames = pointCloud._frames;
|
var framesLength = frames.length;
|
expect(pointCloud.totalMemoryUsageInBytes).toBe(
|
singleFrameMemoryUsage * framesLength
|
);
|
pointCloud.maximumMemoryUsage = 0;
|
|
// Expect all frames except the current frame to be undefined
|
scene.renderForSpecs();
|
expect(pointCloud.totalMemoryUsageInBytes).toBe(singleFrameMemoryUsage);
|
expect(frames[0].ready).toBe(true);
|
for (var i = 1; i < length; ++i) {
|
expect(frames[i]).toBeUndefined();
|
}
|
|
// The loading frame and last rendered frame are not unloaded
|
goToFrame(1);
|
scene.renderForSpecs();
|
expect(pointCloud.totalMemoryUsageInBytes).toBe(singleFrameMemoryUsage);
|
expect(frames[0].ready).toBe(true);
|
expect(frames[1].ready).toBe(false);
|
|
// The loaded frame is the only one loaded
|
return loadFrame(pointCloud, 1).then(function () {
|
expect(pointCloud.totalMemoryUsageInBytes).toBe(
|
singleFrameMemoryUsage
|
);
|
expect(frames[0]).toBeUndefined();
|
expect(frames[1].ready).toBe(true);
|
});
|
});
|
});
|
|
it("enables attenuation and eye dome lighting", function () {
|
var oldScene = scene;
|
scene = createScene({
|
canvas: createCanvas(100, 100),
|
});
|
initializeScene();
|
|
var pointCloud = createTimeDynamicPointCloud({
|
shading: {
|
attenuation: true,
|
eyeDomeLighting: false,
|
},
|
style: new Cesium3DTileStyle(),
|
});
|
|
return loadFrame(pointCloud).then(function () {
|
var attenuationPixelCount;
|
expect(scene).toRenderPixelCountAndCall(function (pixelCount) {
|
attenuationPixelCount = pixelCount;
|
});
|
|
// Disable attenuation and expect less pixels to be drawn
|
pointCloud.shading.attenuation = false;
|
expect(scene).toRenderPixelCountAndCall(function (pixelCount) {
|
expect(pixelCount).toBeLessThan(attenuationPixelCount);
|
});
|
|
scene.destroyForSpecs();
|
scene = oldScene;
|
});
|
});
|
|
it("enabled eye dome lighting", function () {
|
if (!PointCloudEyeDomeLighting.isSupported(scene.frameState.context)) {
|
return;
|
}
|
|
var pointCloud = createTimeDynamicPointCloud();
|
return loadFrame(pointCloud).then(function () {
|
expect(scene.frameState.commandList.length).toBe(1);
|
pointCloud.shading.attenuation = true;
|
pointCloud.shading.eyeDomeLighting = true;
|
scene.renderForSpecs();
|
expect(scene.frameState.commandList.length).toBe(3); // Added 2 EDL commands
|
});
|
});
|
|
it("sets style", function () {
|
var pointCloud = createTimeDynamicPointCloud({
|
style: new Cesium3DTileStyle({
|
color: 'color("blue")',
|
pointSize: 10,
|
}),
|
});
|
return loadAllFrames(pointCloud).then(function () {
|
expect(scene).toRender([0, 0, 255, 255]);
|
pointCloud.style = new Cesium3DTileStyle({
|
color: 'color("lime")',
|
pointSize: 10,
|
});
|
expect(scene).toRender([0, 255, 0, 255]);
|
goToFrame(1); // Also check that the style is updated for the next frame
|
expect(scene).toRender([0, 255, 0, 255]);
|
});
|
});
|
|
it("make style dirty", function () {
|
var pointCloud = createTimeDynamicPointCloud({
|
style: new Cesium3DTileStyle({
|
color: 'color("blue")',
|
pointSize: 10,
|
}),
|
});
|
return loadAllFrames(pointCloud).then(function () {
|
expect(scene).toRender([0, 0, 255, 255]);
|
pointCloud.style.color = 'color("lime")';
|
pointCloud.makeStyleDirty();
|
expect(scene).toRender([0, 255, 0, 255]);
|
goToFrame(1); // Also check that the style is updated for the next frame
|
expect(scene).toRender([0, 255, 0, 255]);
|
});
|
});
|
|
it("sets clipping planes", function () {
|
var modelMatrix = new Transforms.headingPitchRollToFixedFrame(
|
center,
|
new HeadingPitchRoll(0, 0, 0)
|
);
|
var clippingPlanesX = new ClippingPlaneCollection({
|
modelMatrix: modelMatrix,
|
planes: [new ClippingPlane(Cartesian3.UNIT_X, 0.0)],
|
});
|
var clippingPlanesY = new ClippingPlaneCollection({
|
modelMatrix: modelMatrix,
|
planes: [new ClippingPlane(Cartesian3.UNIT_Y, 0.0)],
|
});
|
|
var pointCloud = createTimeDynamicPointCloud({
|
clippingPlanes: clippingPlanesX,
|
});
|
return loadAllFrames(pointCloud).then(function () {
|
// Go to unclipped area (right half)
|
scene.camera.moveRight(0.1);
|
goToFrame(0);
|
expect(scene).toRender([255, 0, 0, 255]);
|
goToFrame(1);
|
expect(scene).toRender([255, 0, 0, 255]);
|
|
// Go to clipped area (left half)
|
scene.camera.moveLeft(0.2);
|
goToFrame(0);
|
expect(scene).toRender([0, 0, 0, 255]);
|
goToFrame(1);
|
expect(scene).toRender([0, 0, 0, 255]);
|
|
// Same area no longer clipped. Responds to clipping planes updates.
|
pointCloud.clippingPlanes.enabled = false;
|
goToFrame(0);
|
expect(scene).toRender([255, 0, 0, 255]);
|
goToFrame(1);
|
expect(scene).toRender([255, 0, 0, 255]);
|
|
// Sets a new clipping plane that uses a different axis
|
// Go to unclipped area (bottom left)
|
pointCloud.clippingPlanes = clippingPlanesY;
|
scene.camera.moveRight(0.2);
|
scene.camera.moveUp(0.1);
|
goToFrame(0);
|
expect(scene).toRender([255, 0, 0, 255]);
|
goToFrame(1);
|
expect(scene).toRender([255, 0, 0, 255]);
|
|
// Go to clipped area (bottom right)
|
scene.camera.moveDown(0.2);
|
goToFrame(0);
|
expect(scene).toRender([0, 0, 0, 255]);
|
goToFrame(1);
|
expect(scene).toRender([0, 0, 0, 255]);
|
});
|
});
|
|
it("works with frame transforms", function () {
|
var pointCloud = createTimeDynamicPointCloud({
|
useTransforms: true,
|
});
|
return loadAllFrames(pointCloud).then(function () {
|
goToFrame(0);
|
expect(scene).toRender([255, 0, 0, 255]);
|
// The transform shifted the point cloud to the right
|
goToFrame(1);
|
expect(scene).toRender([0, 0, 0, 255]);
|
scene.camera.moveRight(10.0);
|
expect(scene).toRender([255, 0, 0, 255]);
|
});
|
});
|
|
it("does not render during morph", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
return loadFrame(pointCloud).then(function () {
|
scene.renderForSpecs();
|
expect(scene.frameState.commandList.length).toBeGreaterThan(0);
|
scene.morphToColumbusView(1.0);
|
scene.renderForSpecs();
|
expect(scene.frameState.commandList.length).toBe(0);
|
});
|
});
|
|
it("renders frames using Draco compression", function () {
|
var pointCloud = createTimeDynamicPointCloud({
|
useDraco: true,
|
});
|
return loadFrame(pointCloud).then(function () {
|
expect(scene).toRender([255, 0, 0, 255]);
|
});
|
});
|
|
it("picks", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
return loadFrame(pointCloud).then(function () {
|
pointCloud.show = false;
|
expect(scene).toPickPrimitive(undefined);
|
pointCloud.show = true;
|
expect(scene).toPickPrimitive(pointCloud);
|
});
|
});
|
|
it("does not render if current time is out of range", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
return loadFrame(pointCloud).then(function () {
|
// Before
|
clock.currentTime = JulianDate.addSeconds(
|
dates[0],
|
-10.0,
|
new JulianDate()
|
);
|
scene.renderForSpecs();
|
expect(scene.frameState.commandList.length).toBe(0);
|
// During
|
clock.currentTime = dates[0];
|
scene.renderForSpecs();
|
expect(scene.frameState.commandList.length).toBe(1);
|
// After
|
clock.currentTime = JulianDate.addSeconds(
|
dates[5],
|
10.0,
|
new JulianDate()
|
);
|
scene.renderForSpecs();
|
expect(scene.frameState.commandList.length).toBe(0);
|
});
|
});
|
|
it("prefetches different frame when clock multiplier changes", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
spyOn(pointCloud, "_getAverageLoadTime").and.returnValue(0.5);
|
return loadFrame(pointCloud).then(function () {
|
expect(pointCloud._frames[1]).toBeUndefined();
|
clock.multiplier = 1.0;
|
scene.renderForSpecs();
|
expect(pointCloud._frames[1]).toBeDefined();
|
clock.multiplier = 4.0;
|
scene.renderForSpecs();
|
expect(pointCloud._frames[2]).toBeUndefined();
|
expect(pointCloud._frames[3]).toBeUndefined();
|
expect(pointCloud._frames[4]).toBeDefined();
|
});
|
});
|
|
it("renders last rendered frame while new frame loads", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
return loadFrame(pointCloud).then(function () {
|
var commandList = scene.frameState.commandList;
|
var firstFrameCommand = commandList[0];
|
goToFrame(4);
|
return pollToPromise(function () {
|
scene.renderForSpecs();
|
var frame = pointCloud._frames[4];
|
var ready = defined(frame) && frame.ready;
|
if (!ready) {
|
expect(commandList[0]).toBe(firstFrameCommand);
|
}
|
return ready;
|
}).then(function () {
|
scene.renderForSpecs();
|
expect(commandList[0]).toBeDefined();
|
expect(commandList[0]).not.toBe(firstFrameCommand);
|
});
|
});
|
});
|
|
it("skips frames based on average load time and clock multiplier", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
spyOn(pointCloud, "_getAverageLoadTime").and.returnValue(2.0);
|
scene.renderForSpecs(); // at 0.0 seconds - loads frame 0
|
clock.multiplier = 0.6;
|
scene.renderForSpecs(); // at 0.0 seconds - preloads frame 2 at 1.2 seconds
|
clock.tick();
|
scene.renderForSpecs(); // at 0.6 seconds
|
clock.tick();
|
scene.renderForSpecs(); // at 1.2 seconds - preloads frame 4 at 2.4 seconds
|
clock.tick();
|
scene.renderForSpecs(); // at 1.8 seconds
|
clock.tick();
|
scene.renderForSpecs(); // at 2.4 seconds
|
|
var frames = pointCloud._frames;
|
expect(frames[0]).toBeDefined();
|
expect(frames[1]).toBeUndefined();
|
expect(frames[2]).toBeDefined();
|
expect(frames[3]).toBeUndefined();
|
expect(frames[4]).toBeDefined();
|
});
|
|
it("does not skip frames if clock multiplier is sufficiently slow", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
spyOn(pointCloud, "_getAverageLoadTime").and.returnValue(0.5);
|
scene.renderForSpecs(); // at 0.0 seconds - loads frame 0
|
clock.multiplier = 0.6;
|
scene.renderForSpecs(); // at 0.0 seconds - preloads frame 1
|
clock.tick();
|
scene.renderForSpecs(); // at 0.6 seconds - preloads frame 2
|
clock.tick();
|
scene.renderForSpecs(); // at 1.2 seconds - preloads frame 3
|
clock.tick();
|
scene.renderForSpecs(); // at 1.8 seconds - preloads frame 4
|
clock.tick();
|
scene.renderForSpecs(); // at 2.4 seconds
|
|
var frames = pointCloud._frames;
|
expect(frames[0]).toBeDefined();
|
expect(frames[1]).toBeDefined();
|
expect(frames[2]).toBeDefined();
|
expect(frames[3]).toBeDefined();
|
expect(frames[4]).toBeDefined();
|
});
|
|
it("renders loaded frames between the previous frame and next frame", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
spyOn(pointCloud, "_getAverageLoadTime").and.returnValue(3.4);
|
var frames = pointCloud._frames;
|
return loadFrames(pointCloud, [0, 2]).then(function () {
|
clock.multiplier = 0.6;
|
scene.renderForSpecs(); // at 0.0 seconds - preloads frame 4 at 2.04 seconds - renders frame 0
|
expect(pointCloud._lastRenderedFrame).toBe(frames[0]);
|
clock.tick();
|
scene.renderForSpecs(); // at 0.6 seconds - renders frame 0
|
expect(pointCloud._lastRenderedFrame).toBe(frames[0]);
|
clock.tick();
|
scene.renderForSpecs(); // at 1.2 seconds - renders frame 2 which has already been loaded
|
expect(pointCloud._lastRenderedFrame).toBe(frames[2]);
|
clock.tick();
|
scene.renderForSpecs(); // at 1.8 seconds - renders frame 2
|
expect(pointCloud._lastRenderedFrame).toBe(frames[2]);
|
});
|
});
|
|
it("works with negative clock multiplier", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
spyOn(pointCloud, "_getAverageLoadTime").and.returnValue(2.0);
|
goToFrame(4);
|
scene.renderForSpecs(); // at 2.0 seconds - loads frame 4
|
clock.multiplier = -0.6;
|
scene.renderForSpecs(); // at 2.0 seconds - preloads frame 1 at 0.8 seconds
|
clock.tick();
|
scene.renderForSpecs(); // at 1.4 seconds
|
clock.tick();
|
scene.renderForSpecs(); // at 0.8 seconds - nothing left to preload
|
clock.tick();
|
scene.renderForSpecs(); // at 0.2 seconds
|
clock.tick();
|
scene.renderForSpecs(); // at -0.4 seconds
|
|
var frames = pointCloud._frames;
|
expect(frames[0]).toBeUndefined();
|
expect(frames[1]).toBeDefined();
|
expect(frames[2]).toBeUndefined();
|
expect(frames[3]).toBeUndefined();
|
expect(frames[4]).toBeDefined();
|
});
|
|
it("frames not loaded in sequential updates do not impact average load time", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
expect(pointCloud._runningAverage).toBe(0.0);
|
return loadFrame(pointCloud).then(function () {
|
expect(pointCloud._frames[0].sequential).toBe(true);
|
expect(pointCloud._runningLength).toBe(1);
|
expect(pointCloud._runningAverage).toBeGreaterThan(0.0);
|
goToFrame(2); // Start loading frame 2, but don't finish loading it now
|
scene.renderForSpecs();
|
return loadFrame(pointCloud, 1).then(function () {
|
var twoFrameAverage = pointCloud._runningAverage;
|
expect(pointCloud._frames[1].sequential).toBe(true);
|
expect(pointCloud._runningLength).toBe(2);
|
expect(pointCloud._runningAverage).toBeGreaterThan(0.0);
|
return loadFrame(pointCloud, 2).then(function () {
|
expect(pointCloud._frames[2].sequential).toBe(false);
|
expect(pointCloud._runningLength).toBe(2); // No update
|
expect(pointCloud._runningAverage).toBe(twoFrameAverage); // No update
|
});
|
});
|
});
|
});
|
|
it("frame failed event is raised from request failure", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
spyOn(Resource._Implementations, "loadWithXhr").and.callFake(function (
|
request,
|
responseType,
|
method,
|
data,
|
headers,
|
deferred,
|
overrideMimeType
|
) {
|
deferred.reject("404");
|
});
|
var spyUpdate = jasmine.createSpy("listener");
|
pointCloud.frameFailed.addEventListener(spyUpdate);
|
|
var i;
|
for (i = 0; i < 5; ++i) {
|
goToFrame(i);
|
scene.renderForSpecs();
|
}
|
|
for (i = 0; i < 5; ++i) {
|
var arg = spyUpdate.calls.argsFor(i)[0];
|
expect(arg).toBeDefined();
|
expect(arg.uri).toContain(i + ".pnts");
|
expect(arg.message).toBe("404");
|
}
|
});
|
|
it("failed frame event is raised from Draco failure", function () {
|
var pointCloud = createTimeDynamicPointCloud({
|
useDraco: true,
|
});
|
return loadFrame(pointCloud).then(function () {
|
var decoder = DracoLoader._getDecoderTaskProcessor();
|
spyOn(decoder, "scheduleTask").and.returnValue(
|
when.reject({ message: "my error" })
|
);
|
var spyUpdate = jasmine.createSpy("listener");
|
pointCloud.frameFailed.addEventListener(spyUpdate);
|
goToFrame(1);
|
scene.renderForSpecs();
|
var failedPromise;
|
var frameFailed = false;
|
return pollToPromise(function () {
|
var contents = pointCloud._frames[1].pointCloud;
|
if (defined(contents) && !defined(failedPromise)) {
|
failedPromise = contents.readyPromise.otherwise(function () {
|
frameFailed = true;
|
});
|
}
|
scene.renderForSpecs();
|
return frameFailed;
|
}).then(function () {
|
var arg = spyUpdate.calls.argsFor(0)[0];
|
expect(arg).toBeDefined();
|
expect(arg.uri).toContain("1.pnts");
|
expect(arg.message).toBe("my error");
|
});
|
});
|
});
|
|
it("raises frame changed event", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
var spyFrameChanged = jasmine.createSpy("listener");
|
pointCloud.frameChanged.addEventListener(spyFrameChanged);
|
|
return loadAllFrames(pointCloud).then(function () {
|
expect(spyFrameChanged.calls.count()).toBe(5);
|
|
// Go to random frame
|
goToFrame(2);
|
scene.renderForSpecs();
|
expect(spyFrameChanged.calls.count()).toBe(6);
|
|
// Go out of range. No event raised.
|
clock.currentTime = JulianDate.addSeconds(
|
dates[0],
|
-10.0,
|
new JulianDate()
|
);
|
scene.renderForSpecs();
|
expect(spyFrameChanged.calls.count()).toBe(6);
|
|
goToFrame(0);
|
scene.renderForSpecs();
|
expect(spyFrameChanged.calls.count()).toBe(7);
|
|
expect(spyFrameChanged.calls.argsFor(0)[0]).toBe(pointCloud);
|
});
|
});
|
|
it("destroys", function () {
|
var pointCloud = createTimeDynamicPointCloud();
|
return loadAllFrames(pointCloud).then(function () {
|
expect(pointCloud.isDestroyed()).toEqual(false);
|
scene.primitives.remove(pointCloud);
|
expect(pointCloud.isDestroyed()).toEqual(true);
|
expect(pointCloud.totalMemoryUsageInBytes).toBe(0);
|
});
|
});
|
},
|
"WebGL"
|
);
|
