import { BoundingSphere } from "../../Source/Cesium.js";
|
import { Cartesian3 } from "../../Source/Cesium.js";
|
import { Color } from "../../Source/Cesium.js";
|
import { ColorGeometryInstanceAttribute } from "../../Source/Cesium.js";
|
import { combine } from "../../Source/Cesium.js";
|
import { destroyObject } from "../../Source/Cesium.js";
|
import { Ellipsoid } from "../../Source/Cesium.js";
|
import { GeometryInstance } from "../../Source/Cesium.js";
|
import { Matrix4 } from "../../Source/Cesium.js";
|
import { Rectangle } from "../../Source/Cesium.js";
|
import { RectangleGeometry } from "../../Source/Cesium.js";
|
import { Transforms } from "../../Source/Cesium.js";
|
import { Pass } from "../../Source/Cesium.js";
|
import { RenderState } from "../../Source/Cesium.js";
|
import { Cesium3DTileBatchTable } from "../../Source/Cesium.js";
|
import { ClassificationType } from "../../Source/Cesium.js";
|
import { ColorBlendMode } from "../../Source/Cesium.js";
|
import { PerInstanceColorAppearance } from "../../Source/Cesium.js";
|
import { Primitive } from "../../Source/Cesium.js";
|
import { StencilConstants } from "../../Source/Cesium.js";
|
import { Vector3DTileGeometry } from "../../Source/Cesium.js";
|
import createContext from "../createContext.js";
|
import createScene from "../createScene.js";
|
import pollToPromise from "../pollToPromise.js";
|
|
describe(
|
"Scene/Vector3DTileGeometry",
|
function () {
|
createGeometrySpecs({});
|
var c = createContext({ requestWebgl2: true });
|
// Don't repeat WebGL 1 tests when WebGL 2 is not supported
|
if (c.webgl2) {
|
createGeometrySpecs({ requestWebgl2: true });
|
}
|
c.destroyForSpecs();
|
|
function createGeometrySpecs(contextOptions) {
|
var webglMessage = contextOptions.requestWebgl2 ? ": WebGL 2" : "";
|
|
var scene;
|
var rectangle;
|
var geometry;
|
var globePrimitive;
|
var tilesetPrimitive;
|
var reusableGlobePrimitive;
|
var reusableTilesetPrimitive;
|
|
var ellipsoid = Ellipsoid.WGS84;
|
|
var mockTileset = {
|
_statistics: {
|
texturesByteLength: 0,
|
},
|
tileset: {
|
_statistics: {
|
batchTableByteLength: 0,
|
},
|
colorBlendMode: ColorBlendMode.HIGHLIGHT,
|
},
|
getFeature: function (id) {
|
return { batchId: id };
|
},
|
};
|
|
function createPrimitive(rectangle, pass) {
|
var renderState;
|
if (pass === Pass.CESIUM_3D_TILE) {
|
renderState = RenderState.fromCache({
|
stencilTest: StencilConstants.setCesium3DTileBit(),
|
stencilMask: StencilConstants.CESIUM_3D_TILE_MASK,
|
depthTest: {
|
enabled: true,
|
},
|
});
|
}
|
var depthColorAttribute = ColorGeometryInstanceAttribute.fromColor(
|
new Color(1.0, 0.0, 0.0, 1.0)
|
);
|
return new Primitive({
|
geometryInstances: new GeometryInstance({
|
geometry: new RectangleGeometry({
|
ellipsoid: Ellipsoid.WGS84,
|
rectangle: rectangle,
|
}),
|
id: "depth rectangle",
|
attributes: {
|
color: depthColorAttribute,
|
},
|
}),
|
appearance: new PerInstanceColorAppearance({
|
translucent: false,
|
flat: true,
|
renderState: renderState,
|
}),
|
asynchronous: false,
|
});
|
}
|
|
function MockPrimitive(primitive, pass) {
|
this._primitive = primitive;
|
this._pass = pass;
|
this.show = true;
|
}
|
|
MockPrimitive.prototype.update = function (frameState) {
|
if (!this.show) {
|
return;
|
}
|
|
var commandList = frameState.commandList;
|
var startLength = commandList.length;
|
this._primitive.update(frameState);
|
|
for (var i = startLength; i < commandList.length; ++i) {
|
var command = commandList[i];
|
command.pass = this._pass;
|
}
|
};
|
|
MockPrimitive.prototype.isDestroyed = function () {
|
return false;
|
};
|
|
MockPrimitive.prototype.destroy = function () {
|
return destroyObject(this);
|
};
|
|
beforeAll(function () {
|
scene = createScene({ contextOptions: contextOptions });
|
|
rectangle = Rectangle.fromDegrees(-80.0, 20.0, -70.0, 30.0);
|
reusableGlobePrimitive = createPrimitive(rectangle, Pass.GLOBE);
|
reusableTilesetPrimitive = createPrimitive(
|
rectangle,
|
Pass.CESIUM_3D_TILE
|
);
|
});
|
|
afterAll(function () {
|
reusableGlobePrimitive.destroy();
|
reusableTilesetPrimitive.destroy();
|
scene.destroyForSpecs();
|
});
|
|
beforeEach(function () {
|
// wrap rectangle primitive so it gets executed during the globe pass and 3D Tiles pass to lay down depth
|
globePrimitive = new MockPrimitive(reusableGlobePrimitive, Pass.GLOBE);
|
tilesetPrimitive = new MockPrimitive(
|
reusableTilesetPrimitive,
|
Pass.CESIUM_3D_TILE
|
);
|
});
|
|
afterEach(function () {
|
scene.primitives.removeAll();
|
globePrimitive =
|
globePrimitive &&
|
!globePrimitive.isDestroyed() &&
|
globePrimitive.destroy();
|
tilesetPrimitive =
|
tilesetPrimitive &&
|
!tilesetPrimitive.isDestroyed() &&
|
tilesetPrimitive.destroy();
|
geometry = geometry && !geometry.isDestroyed() && geometry.destroy();
|
});
|
|
function loadGeometries(geometries) {
|
var ready = false;
|
geometries.readyPromise.then(function () {
|
ready = true;
|
});
|
return pollToPromise(function () {
|
geometries.update(scene.frameState);
|
scene.frameState.commandList.length = 0;
|
return ready;
|
});
|
}
|
|
function packBoxes(boxes) {
|
var length = boxes.length;
|
var packedBoxes = new Float32Array(
|
length * Vector3DTileGeometry.packedBoxLength
|
);
|
var offset = 0;
|
for (var i = 0; i < length; ++i) {
|
var box = boxes[i];
|
Cartesian3.pack(box.dimensions, packedBoxes, offset);
|
offset += Cartesian3.packedLength;
|
Matrix4.pack(box.modelMatrix, packedBoxes, offset);
|
offset += Matrix4.packedLength;
|
}
|
return packedBoxes;
|
}
|
|
function packCylinders(cylinders) {
|
var length = cylinders.length;
|
var packedCylinders = new Float32Array(
|
length * Vector3DTileGeometry.packedCylinderLength
|
);
|
var offset = 0;
|
for (var i = 0; i < length; ++i) {
|
var cylinder = cylinders[i];
|
packedCylinders[offset++] = cylinder.radius;
|
packedCylinders[offset++] = cylinder.length;
|
Matrix4.pack(cylinder.modelMatrix, packedCylinders, offset);
|
offset += Matrix4.packedLength;
|
}
|
return packedCylinders;
|
}
|
|
function packEllipsoids(ellipsoids) {
|
var length = ellipsoids.length;
|
var packedEllipsoids = new Float32Array(
|
length * Vector3DTileGeometry.packedEllipsoidLength
|
);
|
var offset = 0;
|
for (var i = 0; i < length; ++i) {
|
var ellipsoid = ellipsoids[i];
|
Cartesian3.pack(ellipsoid.radii, packedEllipsoids, offset);
|
offset += Cartesian3.packedLength;
|
Matrix4.pack(ellipsoid.modelMatrix, packedEllipsoids, offset);
|
offset += Matrix4.packedLength;
|
}
|
return packedEllipsoids;
|
}
|
|
function packSpheres(spheres) {
|
var length = spheres.length;
|
var packedSpheres = new Float32Array(
|
length * Vector3DTileGeometry.packedSphereLength
|
);
|
var offset = 0;
|
for (var i = 0; i < length; ++i) {
|
var sphere = spheres[i];
|
packedSpheres[offset++] = sphere.radius;
|
Cartesian3.pack(
|
Matrix4.getTranslation(sphere.modelMatrix, new Cartesian3()),
|
packedSpheres,
|
offset
|
);
|
offset += Cartesian3.packedLength;
|
}
|
return packedSpheres;
|
}
|
|
function verifySingleRender(geometryOptions) {
|
var origin = Rectangle.center(rectangle);
|
var center = ellipsoid.cartographicToCartesian(origin);
|
var modelMatrix = Transforms.eastNorthUpToFixedFrame(center);
|
|
Cartesian3.clone(center, geometryOptions.boundingVolume.center);
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
batchTable.update(mockTileset, scene.frameState);
|
|
scene.primitives.add(globePrimitive);
|
|
geometry = scene.primitives.add(
|
new Vector3DTileGeometry(
|
combine(geometryOptions, {
|
center: center,
|
modelMatrix: modelMatrix,
|
batchTable: batchTable,
|
})
|
)
|
);
|
return loadGeometries(geometry).then(function () {
|
scene.camera.setView({
|
destination: rectangle,
|
});
|
scene.camera.zoomIn(scene.camera.positionCartographic.height * 0.9);
|
expect(scene).toRender([255, 255, 255, 255]);
|
|
batchTable.setColor(0, Color.BLUE);
|
geometry.updateCommands(0, Color.BLUE);
|
batchTable.update(mockTileset, scene.frameState);
|
expect(scene).toRender([0, 0, 255, 255]);
|
});
|
}
|
|
function verifyMultipleRender(modelMatrices, geometryOptions) {
|
var origin = Rectangle.center(rectangle);
|
var center = ellipsoid.cartographicToCartesian(origin);
|
var modelMatrix = Transforms.eastNorthUpToFixedFrame(center);
|
|
Cartesian3.clone(center, geometryOptions.boundingVolume.center);
|
|
var length = modelMatrices.length;
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, length);
|
batchTable.update(mockTileset, scene.frameState);
|
|
scene.primitives.add(globePrimitive);
|
|
geometry = scene.primitives.add(
|
new Vector3DTileGeometry(
|
combine(geometryOptions, {
|
center: center,
|
modelMatrix: modelMatrix,
|
batchTable: batchTable,
|
})
|
)
|
);
|
return loadGeometries(geometry).then(function () {
|
var i;
|
for (i = 0; i < length; ++i) {
|
batchTable.setShow(i, false);
|
}
|
|
for (i = 0; i < length; ++i) {
|
var transform = Matrix4.multiply(
|
modelMatrix,
|
modelMatrices[i],
|
new Matrix4()
|
);
|
scene.camera.lookAtTransform(
|
transform,
|
new Cartesian3(0.0, 0.0, 10.0)
|
);
|
|
batchTable.setShow(i, true);
|
batchTable.update(mockTileset, scene.frameState);
|
expect(scene).toRender([255, 255, 255, 255]);
|
|
batchTable.setColor(i, Color.BLUE);
|
geometry.updateCommands(i, Color.BLUE);
|
batchTable.update(mockTileset, scene.frameState);
|
expect(scene).toRender([0, 0, 255, 255]);
|
|
batchTable.setShow(i, false);
|
}
|
});
|
}
|
|
it("renders a single box" + webglMessage, function () {
|
var dimensions = new Cartesian3(1000000.0, 1000000.0, 1000000.0);
|
var boxes = packBoxes([
|
{
|
modelMatrix: Matrix4.IDENTITY,
|
dimensions: dimensions,
|
},
|
]);
|
var boxBatchIds = new Uint16Array([0]);
|
var bv = new BoundingSphere(
|
undefined,
|
Math.sqrt(3.0 * dimensions.x * dimensions.x)
|
);
|
return verifySingleRender({
|
boxes: boxes,
|
boxBatchIds: boxBatchIds,
|
boundingVolume: bv,
|
});
|
});
|
|
it("renders multiple boxes" + webglMessage, function () {
|
var dimensions = new Cartesian3(500000.0, 500000.0, 500000.0);
|
var modelMatrices = [
|
Matrix4.fromTranslation(new Cartesian3(dimensions.x, 0.0, 0.0)),
|
Matrix4.fromTranslation(new Cartesian3(-dimensions.x, 0.0, 0.0)),
|
];
|
var boxes = packBoxes([
|
{
|
modelMatrix: modelMatrices[0],
|
dimensions: dimensions,
|
},
|
{
|
modelMatrix: modelMatrices[1],
|
dimensions: dimensions,
|
},
|
]);
|
var boxBatchIds = new Uint16Array([0, 1]);
|
var bv = new BoundingSphere(
|
undefined,
|
Math.sqrt(3.0 * 2.0 * dimensions.x * dimensions.x)
|
);
|
return verifyMultipleRender(modelMatrices, {
|
boxes: boxes,
|
boxBatchIds: boxBatchIds,
|
boundingVolume: bv,
|
});
|
});
|
|
it("renders a single cylinder" + webglMessage, function () {
|
var radius = 1000000.0;
|
var length = 1000000.0;
|
var cylinders = packCylinders([
|
{
|
modelMatrix: Matrix4.IDENTITY,
|
radius: radius,
|
length: length,
|
},
|
]);
|
var cylinderBatchIds = new Uint16Array([0]);
|
var bv = new BoundingSphere(
|
undefined,
|
Math.sqrt(radius * radius + length * length)
|
);
|
return verifySingleRender({
|
cylinders: cylinders,
|
cylinderBatchIds: cylinderBatchIds,
|
boundingVolume: bv,
|
});
|
});
|
|
it("renders multiple cylinders" + webglMessage, function () {
|
var radius = 500000.0;
|
var length = 500000.0;
|
var modelMatrices = [
|
Matrix4.fromTranslation(new Cartesian3(radius, 0.0, 0.0)),
|
Matrix4.fromTranslation(new Cartesian3(-radius, 0.0, 0.0)),
|
];
|
var cylinders = packCylinders([
|
{
|
modelMatrix: modelMatrices[0],
|
radius: radius,
|
length: length,
|
},
|
{
|
modelMatrix: modelMatrices[1],
|
radius: radius,
|
length: length,
|
},
|
]);
|
var cylinderBatchIds = new Uint16Array([0, 1]);
|
var bv = new BoundingSphere(
|
undefined,
|
Math.sqrt(2.0 * (radius * radius + length * length))
|
);
|
return verifyMultipleRender(modelMatrices, {
|
cylinders: cylinders,
|
cylinderBatchIds: cylinderBatchIds,
|
boundingVolume: bv,
|
});
|
});
|
|
it("renders a single ellipsoid" + webglMessage, function () {
|
var radii = new Cartesian3(500000.0, 500000.0, 500000.0);
|
var ellipsoid = packEllipsoids([
|
{
|
modelMatrix: Matrix4.IDENTITY,
|
radii: radii,
|
},
|
]);
|
var ellipsoidBatchIds = new Uint16Array([0]);
|
var bv = new BoundingSphere(
|
undefined,
|
Cartesian3.maximumComponent(radii)
|
);
|
return verifySingleRender({
|
ellipsoids: ellipsoid,
|
ellipsoidBatchIds: ellipsoidBatchIds,
|
boundingVolume: bv,
|
});
|
});
|
|
it("renders multiple ellipsoids" + webglMessage, function () {
|
var radii = new Cartesian3(500000.0, 500000.0, 500000.0);
|
var modelMatrices = [
|
Matrix4.fromTranslation(new Cartesian3(radii.x, 0.0, 0.0)),
|
Matrix4.fromTranslation(new Cartesian3(-radii.x, 0.0, 0.0)),
|
];
|
var ellipsoids = packEllipsoids([
|
{
|
modelMatrix: modelMatrices[0],
|
radii: radii,
|
},
|
{
|
modelMatrix: modelMatrices[1],
|
radii: radii,
|
},
|
]);
|
var ellipsoidBatchIds = new Uint16Array([0, 1]);
|
var bv = new BoundingSphere(
|
undefined,
|
2.0 * Cartesian3.maximumComponent(radii)
|
);
|
return verifyMultipleRender(modelMatrices, {
|
ellipsoids: ellipsoids,
|
ellipsoidBatchIds: ellipsoidBatchIds,
|
boundingVolume: bv,
|
});
|
});
|
|
it("renders a single sphere" + webglMessage, function () {
|
var radius = 500000.0;
|
var sphere = packSpheres([
|
{
|
radius: radius,
|
modelMatrix: Matrix4.IDENTITY,
|
},
|
]);
|
var sphereBatchIds = new Uint16Array([0]);
|
var bv = new BoundingSphere(undefined, radius);
|
return verifySingleRender({
|
spheres: sphere,
|
sphereBatchIds: sphereBatchIds,
|
boundingVolume: bv,
|
});
|
});
|
|
it("renders multiple spheres" + webglMessage, function () {
|
var radius = 500000.0;
|
var modelMatrices = [
|
Matrix4.fromTranslation(new Cartesian3(radius, 0.0, 0.0)),
|
Matrix4.fromTranslation(new Cartesian3(-radius, 0.0, 0.0)),
|
];
|
var spheres = packSpheres([
|
{
|
modelMatrix: modelMatrices[0],
|
radius: radius,
|
},
|
{
|
modelMatrix: modelMatrices[1],
|
radius: radius,
|
},
|
]);
|
var sphereBatchIds = new Uint16Array([0, 1]);
|
var bv = new BoundingSphere(undefined, 2.0 * radius);
|
return verifyMultipleRender(modelMatrices, {
|
spheres: spheres,
|
sphereBatchIds: sphereBatchIds,
|
boundingVolume: bv,
|
});
|
});
|
|
it(
|
"renders with multiple types of each geometry" + webglMessage,
|
function () {
|
var dimensions = new Cartesian3(125000.0, 125000.0, 125000.0);
|
var modelMatrices = [
|
Matrix4.fromTranslation(new Cartesian3(dimensions.x, 0.0, 0.0)),
|
Matrix4.fromTranslation(new Cartesian3(-dimensions.x, 0.0, 0.0)),
|
];
|
var boxes = packBoxes([
|
{
|
modelMatrix: modelMatrices[0],
|
dimensions: dimensions,
|
},
|
{
|
modelMatrix: modelMatrices[1],
|
dimensions: dimensions,
|
},
|
]);
|
var boxBatchIds = new Uint16Array([0, 1]);
|
|
var radius = 125000.0;
|
var length = 125000.0;
|
modelMatrices.push(
|
Matrix4.fromTranslation(new Cartesian3(radius, 0.0, 0.0)),
|
Matrix4.fromTranslation(new Cartesian3(-radius, 0.0, 0.0))
|
);
|
var cylinders = packCylinders([
|
{
|
modelMatrix: modelMatrices[2],
|
radius: radius,
|
length: length,
|
},
|
{
|
modelMatrix: modelMatrices[3],
|
radius: radius,
|
length: length,
|
},
|
]);
|
var cylinderBatchIds = new Uint16Array([2, 3]);
|
|
var radii = new Cartesian3(125000.0, 125000.0, 125000.0);
|
modelMatrices.push(
|
Matrix4.fromTranslation(new Cartesian3(radii.x, 0.0, 0.0)),
|
Matrix4.fromTranslation(new Cartesian3(-radii.x, 0.0, 0.0))
|
);
|
var ellipsoids = packEllipsoids([
|
{
|
modelMatrix: modelMatrices[4],
|
radii: radii,
|
},
|
{
|
modelMatrix: modelMatrices[5],
|
radii: radii,
|
},
|
]);
|
var ellipsoidBatchIds = new Uint16Array([4, 5]);
|
|
modelMatrices.push(
|
Matrix4.fromTranslation(new Cartesian3(radius, 0.0, 0.0)),
|
Matrix4.fromTranslation(new Cartesian3(-radius, 0.0, 0.0))
|
);
|
var spheres = packSpheres([
|
{
|
modelMatrix: modelMatrices[6],
|
radius: radius,
|
},
|
{
|
modelMatrix: modelMatrices[7],
|
radius: radius,
|
},
|
]);
|
var sphereBatchIds = new Uint16Array([6, 7]);
|
|
var bv = new BoundingSphere(undefined, 50000000.0);
|
|
return verifyMultipleRender(modelMatrices, {
|
boxes: boxes,
|
boxBatchIds: boxBatchIds,
|
cylinders: cylinders,
|
cylinderBatchIds: cylinderBatchIds,
|
ellipsoids: ellipsoids,
|
ellipsoidBatchIds: ellipsoidBatchIds,
|
spheres: spheres,
|
sphereBatchIds: sphereBatchIds,
|
boundingVolume: bv,
|
});
|
}
|
);
|
|
it(
|
"renders multiple geometries after a re-batch" + webglMessage,
|
function () {
|
var dimensions = new Cartesian3(125000.0, 125000.0, 125000.0);
|
var modelMatrices = [
|
Matrix4.fromTranslation(new Cartesian3(dimensions.x, 0.0, 0.0)),
|
Matrix4.fromTranslation(new Cartesian3(-dimensions.x, 0.0, 0.0)),
|
];
|
var boxes = packBoxes([
|
{
|
modelMatrix: modelMatrices[0],
|
dimensions: dimensions,
|
},
|
{
|
modelMatrix: modelMatrices[1],
|
dimensions: dimensions,
|
},
|
]);
|
var boxBatchIds = new Uint16Array([0, 1]);
|
|
var radius = 125000.0;
|
var length = 125000.0;
|
modelMatrices.push(
|
Matrix4.fromTranslation(new Cartesian3(radius, 0.0, 0.0)),
|
Matrix4.fromTranslation(new Cartesian3(-radius, 0.0, 0.0))
|
);
|
var cylinders = packCylinders([
|
{
|
modelMatrix: modelMatrices[2],
|
radius: radius,
|
length: length,
|
},
|
{
|
modelMatrix: modelMatrices[3],
|
radius: radius,
|
length: length,
|
},
|
]);
|
var cylinderBatchIds = new Uint16Array([2, 3]);
|
|
var origin = Rectangle.center(rectangle);
|
var center = ellipsoid.cartographicToCartesian(origin);
|
var modelMatrix = Transforms.eastNorthUpToFixedFrame(center);
|
|
var bv = new BoundingSphere(center, 50000000.0);
|
|
length = modelMatrices.length;
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, length);
|
batchTable.update(mockTileset, scene.frameState);
|
|
scene.primitives.add(globePrimitive);
|
|
geometry = scene.primitives.add(
|
new Vector3DTileGeometry({
|
boxes: boxes,
|
boxBatchIds: boxBatchIds,
|
cylinders: cylinders,
|
cylinderBatchIds: cylinderBatchIds,
|
center: center,
|
modelMatrix: modelMatrix,
|
batchTable: batchTable,
|
boundingVolume: bv,
|
})
|
);
|
geometry.forceRebatch = true;
|
return loadGeometries(geometry).then(function () {
|
var i;
|
for (i = 0; i < length; ++i) {
|
batchTable.setShow(i, false);
|
}
|
|
for (i = 0; i < length; ++i) {
|
var transform = Matrix4.multiply(
|
modelMatrix,
|
modelMatrices[i],
|
new Matrix4()
|
);
|
scene.camera.lookAtTransform(
|
transform,
|
new Cartesian3(0.0, 0.0, 10.0)
|
);
|
|
batchTable.setShow(i, true);
|
batchTable.update(mockTileset, scene.frameState);
|
expect(scene).toRender([255, 255, 255, 255]);
|
|
batchTable.setColor(i, Color.BLUE);
|
geometry.updateCommands(i, Color.BLUE);
|
batchTable.update(mockTileset, scene.frameState);
|
expect(scene).toRender([0, 0, 255, 255]);
|
|
batchTable.setShow(i, false);
|
}
|
});
|
}
|
);
|
|
it("renders with inverted classification" + webglMessage, function () {
|
var radii = new Cartesian3(100.0, 100.0, 1000.0);
|
var ellipsoids = packEllipsoids([
|
{
|
modelMatrix: Matrix4.IDENTITY,
|
radii: radii,
|
},
|
]);
|
var ellipsoidBatchIds = new Uint16Array([0]);
|
|
var origin = Rectangle.center(rectangle);
|
var center = ellipsoid.cartographicToCartesian(origin);
|
var modelMatrix = Transforms.eastNorthUpToFixedFrame(center);
|
|
var bv = new BoundingSphere(center, Cartesian3.maximumComponent(radii));
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
batchTable.update(mockTileset, scene.frameState);
|
|
scene.primitives.add(tilesetPrimitive);
|
|
geometry = scene.primitives.add(
|
new Vector3DTileGeometry({
|
ellipsoids: ellipsoids,
|
ellipsoidBatchIds: ellipsoidBatchIds,
|
boundingVolume: bv,
|
center: center,
|
modelMatrix: modelMatrix,
|
batchTable: batchTable,
|
})
|
);
|
return loadGeometries(geometry).then(function () {
|
scene.camera.lookAtTransform(
|
modelMatrix,
|
new Cartesian3(0.0, 0.0, 1.0)
|
);
|
expect(scene).toRender([255, 255, 255, 255]);
|
|
scene.camera.lookAtTransform(
|
modelMatrix,
|
new Cartesian3(radii.x, 0.0, 1.0)
|
);
|
expect(scene).toRender([255, 0, 0, 255]);
|
|
scene.invertClassification = true;
|
scene.invertClassificationColor = new Color(0.25, 0.25, 0.25, 1.0);
|
expect(scene).toRender([64, 0, 0, 255]);
|
|
scene.invertClassification = false;
|
});
|
});
|
|
it("renders wireframe" + webglMessage, function () {
|
var origin = Rectangle.center(rectangle);
|
var center = ellipsoid.cartographicToCartesian(origin);
|
var modelMatrix = Transforms.eastNorthUpToFixedFrame(center);
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
batchTable.update(mockTileset, scene.frameState);
|
|
scene.primitives.add(globePrimitive);
|
|
geometry = scene.primitives.add(
|
new Vector3DTileGeometry({
|
ellipsoids: packEllipsoids([
|
{
|
modelMatrix: Matrix4.IDENTITY,
|
radii: new Cartesian3(1000000.0, 1000000.0, 1000000.0),
|
},
|
]),
|
ellipsoidBatchIds: new Uint16Array([0]),
|
center: center,
|
modelMatrix: modelMatrix,
|
batchTable: batchTable,
|
boundingVolume: new BoundingSphere(center, 1000000.0),
|
})
|
);
|
geometry.debugWireframe = true;
|
return loadGeometries(geometry).then(function () {
|
scene.camera.setView({
|
destination: rectangle,
|
});
|
scene.camera.zoomIn(scene.camera.positionCartographic.height * 0.9);
|
expect(scene).toRender([255, 255, 255, 255]);
|
|
batchTable.setColor(0, Color.BLUE);
|
geometry.updateCommands(0, Color.BLUE);
|
batchTable.update(mockTileset, scene.frameState);
|
expect(scene).toRender([0, 0, 255, 255]);
|
});
|
});
|
|
it("renders based on classificationType" + webglMessage, function () {
|
var radii = new Cartesian3(100.0, 100.0, 1000.0);
|
var ellipsoids = packEllipsoids([
|
{
|
modelMatrix: Matrix4.IDENTITY,
|
radii: radii,
|
},
|
]);
|
var ellipsoidBatchIds = new Uint16Array([0]);
|
|
var origin = Rectangle.center(rectangle);
|
var center = ellipsoid.cartographicToCartesian(origin);
|
var modelMatrix = Transforms.eastNorthUpToFixedFrame(center);
|
|
var bv = new BoundingSphere(center, Cartesian3.maximumComponent(radii));
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
batchTable.update(mockTileset, scene.frameState);
|
|
scene.primitives.add(globePrimitive);
|
scene.primitives.add(tilesetPrimitive);
|
|
geometry = scene.primitives.add(
|
new Vector3DTileGeometry({
|
ellipsoids: ellipsoids,
|
ellipsoidBatchIds: ellipsoidBatchIds,
|
boundingVolume: bv,
|
center: center,
|
modelMatrix: modelMatrix,
|
batchTable: batchTable,
|
})
|
);
|
return loadGeometries(geometry).then(function () {
|
scene.camera.lookAtTransform(
|
modelMatrix,
|
new Cartesian3(0.0, 0.0, 1.0)
|
);
|
|
geometry.classificationType = ClassificationType.CESIUM_3D_TILE;
|
globePrimitive.show = false;
|
tilesetPrimitive.show = true;
|
expect(scene).toRender([255, 255, 255, 255]);
|
globePrimitive.show = true;
|
tilesetPrimitive.show = false;
|
expect(scene).toRender([255, 0, 0, 255]);
|
|
geometry.classificationType = ClassificationType.TERRAIN;
|
globePrimitive.show = false;
|
tilesetPrimitive.show = true;
|
expect(scene).toRender([255, 0, 0, 255]);
|
globePrimitive.show = true;
|
tilesetPrimitive.show = false;
|
expect(scene).toRender([255, 255, 255, 255]);
|
|
geometry.classificationType = ClassificationType.BOTH;
|
globePrimitive.show = false;
|
tilesetPrimitive.show = true;
|
expect(scene).toRender([255, 255, 255, 255]);
|
globePrimitive.show = true;
|
tilesetPrimitive.show = false;
|
expect(scene).toRender([255, 255, 255, 255]);
|
|
globePrimitive.show = true;
|
tilesetPrimitive.show = true;
|
});
|
});
|
|
it("picks geometry" + webglMessage, function () {
|
var origin = Rectangle.center(rectangle);
|
var center = ellipsoid.cartographicToCartesian(origin);
|
var modelMatrix = Transforms.eastNorthUpToFixedFrame(center);
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
scene.primitives.add(globePrimitive);
|
|
geometry = scene.primitives.add(
|
new Vector3DTileGeometry({
|
ellipsoids: packEllipsoids([
|
{
|
modelMatrix: Matrix4.IDENTITY,
|
radii: new Cartesian3(500000.0, 500000.0, 500000.0),
|
},
|
]),
|
ellipsoidBatchIds: new Uint16Array([0]),
|
center: center,
|
modelMatrix: modelMatrix,
|
batchTable: batchTable,
|
boundingVolume: new BoundingSphere(center, 500000.0),
|
})
|
);
|
return loadGeometries(geometry).then(function () {
|
scene.camera.setView({
|
destination: rectangle,
|
});
|
scene.camera.zoomIn(scene.camera.positionCartographic.height * 0.9);
|
|
var features = [];
|
geometry.createFeatures(mockTileset, features);
|
|
var getFeature = mockTileset.getFeature;
|
mockTileset.getFeature = function (index) {
|
return features[index];
|
};
|
|
scene.frameState.passes.pick = true;
|
batchTable.update(mockTileset, scene.frameState);
|
expect(scene).toPickAndCall(function (result) {
|
expect(result).toBe(features[0]);
|
});
|
|
mockTileset.getFeature = getFeature;
|
});
|
});
|
|
it("isDestroyed" + webglMessage, function () {
|
geometry = new Vector3DTileGeometry({});
|
expect(geometry.isDestroyed()).toEqual(false);
|
geometry.destroy();
|
expect(geometry.isDestroyed()).toEqual(true);
|
});
|
}
|
},
|
"WebGL"
|
);
|
