1123 lines
45 KiB
JavaScript
1123 lines
45 KiB
JavaScript
defineSuite([
|
|
'Scene/Cesium3DTileBatchTable',
|
|
'Core/Cartesian2',
|
|
'Core/Cartesian3',
|
|
'Core/Cartesian4',
|
|
'Core/Color',
|
|
'Core/HeadingPitchRange',
|
|
'Core/Matrix2',
|
|
'Core/Matrix3',
|
|
'Core/Matrix4',
|
|
'Renderer/ContextLimits',
|
|
'Scene/Batched3DModel3DTileContent',
|
|
'Scene/Cesium3DTileStyle',
|
|
'Specs/Cesium3DTilesTester',
|
|
'Specs/createScene'
|
|
], function(
|
|
Cesium3DTileBatchTable,
|
|
Cartesian2,
|
|
Cartesian3,
|
|
Cartesian4,
|
|
Color,
|
|
HeadingPitchRange,
|
|
Matrix2,
|
|
Matrix3,
|
|
Matrix4,
|
|
ContextLimits,
|
|
Batched3DModel3DTileContent,
|
|
Cesium3DTileStyle,
|
|
Cesium3DTilesTester,
|
|
createScene) {
|
|
'use strict';
|
|
|
|
var scene;
|
|
var centerLongitude = -1.31968;
|
|
var centerLatitude = 0.698874;
|
|
|
|
var withBatchTableUrl = './Data/Cesium3DTiles/Batched/BatchedWithBatchTable/tileset.json';
|
|
var withoutBatchTableUrl = './Data/Cesium3DTiles/Batched/BatchedWithoutBatchTable/tileset.json';
|
|
var noBatchIdsUrl = './Data/Cesium3DTiles/Batched/BatchedNoBatchIds/tileset.json';
|
|
var batchTableHierarchyUrl = './Data/Cesium3DTiles/Hierarchy/BatchTableHierarchy/tileset.json';
|
|
var batchTableHierarchyBinaryUrl = './Data/Cesium3DTiles/Hierarchy/BatchTableHierarchyBinary/tileset.json';
|
|
var batchTableHierarchyMultipleParentsUrl = './Data/Cesium3DTiles/Hierarchy/BatchTableHierarchyMultipleParents/tileset.json';
|
|
var batchTableHierarchyNoParentsUrl = './Data/Cesium3DTiles/Hierarchy/BatchTableHierarchyNoParents/tileset.json';
|
|
var batchTableHierarchyLegacyUrl = './Data/Cesium3DTiles/Hierarchy/BatchTableHierarchyLegacy/tileset.json';
|
|
|
|
var result = new Color();
|
|
|
|
var mockTileset = {
|
|
_statistics : {
|
|
texturesByteLength : 0
|
|
},
|
|
getFeature : function(batchId) {
|
|
return { batchId : batchId };
|
|
}
|
|
};
|
|
mockTileset._tileset = mockTileset;
|
|
|
|
beforeAll(function() {
|
|
scene = createScene();
|
|
|
|
// One feature is located at the center, point the camera there
|
|
var center = Cartesian3.fromRadians(centerLongitude, centerLatitude);
|
|
scene.camera.lookAt(center, new HeadingPitchRange(0.0, -1.57, 20.0));
|
|
|
|
// Keep the error from logging to the console when running tests
|
|
spyOn(Cesium3DTileBatchTable, '_deprecationWarning');
|
|
spyOn(Batched3DModel3DTileContent, '_deprecationWarning');
|
|
});
|
|
|
|
afterAll(function() {
|
|
scene.destroyForSpecs();
|
|
});
|
|
|
|
afterEach(function() {
|
|
scene.primitives.removeAll();
|
|
});
|
|
|
|
it('setShow throws with invalid batchId', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.setShow();
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.setShow(-1);
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.setShow(2);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('setShow throws with undefined value', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.setShow(0);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('setShow sets show', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
|
|
// Batch table resources are undefined by default
|
|
expect(batchTable._batchValues).toBeUndefined();
|
|
expect(batchTable._batchTexture).toBeUndefined();
|
|
|
|
// Check that batch table resources are still undefined because value is true by default
|
|
batchTable.setShow(0, true);
|
|
batchTable.update(mockTileset, scene.frameState);
|
|
expect(batchTable._batchValues).toBeUndefined();
|
|
expect(batchTable._batchTexture).toBeUndefined();
|
|
expect(batchTable.getShow(0)).toEqual(true);
|
|
|
|
// Check that batch values are dirty and resources are created when value changes
|
|
batchTable.setShow(0, false);
|
|
expect(batchTable._batchValuesDirty).toEqual(true);
|
|
batchTable.update(mockTileset, scene.frameState);
|
|
expect(batchTable._batchValues).toBeDefined();
|
|
expect(batchTable._batchTexture).toBeDefined();
|
|
expect(batchTable._batchValuesDirty).toEqual(false);
|
|
expect(batchTable.getShow(0)).toEqual(false);
|
|
|
|
// Check that dirty stays false when value is the same
|
|
batchTable.setShow(0, false);
|
|
expect(batchTable._batchValuesDirty).toEqual(false);
|
|
expect(batchTable.getShow(0)).toEqual(false);
|
|
});
|
|
|
|
it('getShow throws with invalid batchId', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.getShow();
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.getShow(-1);
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.getShow(2);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('getShow', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
// Show is true by default
|
|
expect(batchTable.getShow(0)).toEqual(true);
|
|
batchTable.setShow(0, false);
|
|
expect(batchTable.getShow(0)).toEqual(false);
|
|
});
|
|
|
|
it('setColor throws with invalid batchId', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.setColor();
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.setColor(-1);
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.setColor(2);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('setColor throws with undefined value', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.setColor(0);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('setColor', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
|
|
// Batch table resources are undefined by default
|
|
expect(batchTable._batchValues).toBeUndefined();
|
|
expect(batchTable._batchTexture).toBeUndefined();
|
|
|
|
// Check that batch table resources are still undefined because value is true by default
|
|
batchTable.setColor(0, Color.WHITE);
|
|
batchTable.update(mockTileset, scene.frameState);
|
|
expect(batchTable._batchValues).toBeUndefined();
|
|
expect(batchTable._batchTexture).toBeUndefined();
|
|
expect(batchTable.getColor(0, result)).toEqual(Color.WHITE);
|
|
|
|
// Check that batch values are dirty and resources are created when value changes
|
|
batchTable.setColor(0, Color.YELLOW);
|
|
expect(batchTable._batchValuesDirty).toEqual(true);
|
|
batchTable.update(mockTileset, scene.frameState);
|
|
expect(batchTable._batchValues).toBeDefined();
|
|
expect(batchTable._batchTexture).toBeDefined();
|
|
expect(batchTable._batchValuesDirty).toEqual(false);
|
|
expect(batchTable.getColor(0, result)).toEqual(Color.YELLOW);
|
|
|
|
// Check that dirty stays false when value is the same
|
|
batchTable.setColor(0, Color.YELLOW);
|
|
expect(batchTable._batchValuesDirty).toEqual(false);
|
|
expect(batchTable.getColor(0, result)).toEqual(Color.YELLOW);
|
|
});
|
|
|
|
it('setAllColor throws with undefined value', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.setAllColor();
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('setAllColor', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 2);
|
|
batchTable.setAllColor(Color.YELLOW);
|
|
expect(batchTable.getColor(0, result)).toEqual(Color.YELLOW);
|
|
expect(batchTable.getColor(1, result)).toEqual(Color.YELLOW);
|
|
});
|
|
|
|
it('setAllShow throws with undefined value', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.setAllShow();
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('setAllShow', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 2);
|
|
batchTable.setAllShow(false);
|
|
expect(batchTable.getShow(0)).toBe(false);
|
|
expect(batchTable.getShow(1)).toBe(false);
|
|
});
|
|
|
|
it('getColor throws with invalid batchId', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.getColor();
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.getColor(-1);
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.getColor(2);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('getColor throws with undefined result', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.getColor(0);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('getColor', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
// Color is true by default
|
|
expect(batchTable.getColor(0, result)).toEqual(Color.WHITE);
|
|
batchTable.setColor(0, Color.YELLOW);
|
|
expect(batchTable.getColor(0, result)).toEqual(Color.YELLOW);
|
|
});
|
|
|
|
it('hasProperty throws with invalid batchId', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.hasProperty();
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.hasProperty(-1);
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.hasProperty(2);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('hasProperty throws with undefined name', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.hasProperty(0);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('hasProperty', function() {
|
|
var batchTableJson = {
|
|
height: [0.0]
|
|
};
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1, batchTableJson);
|
|
expect(batchTable.hasProperty(0, 'height')).toEqual(true);
|
|
expect(batchTable.hasProperty(0, 'id')).toEqual(false);
|
|
});
|
|
|
|
it('getPropertyNames throws with invalid batchId', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.getPropertyNames();
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.getPropertyNames(-1);
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.getPropertyNames(2);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('getPropertyNames', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(batchTable.getPropertyNames(0)).toEqual([]);
|
|
|
|
var batchTableJson = {
|
|
height: [0.0],
|
|
id : [0]
|
|
};
|
|
batchTable = new Cesium3DTileBatchTable(mockTileset, 1, batchTableJson);
|
|
expect(batchTable.getPropertyNames(0)).toEqual(['height', 'id']);
|
|
});
|
|
|
|
it('getPropertyNames works with results argument', function() {
|
|
var batchTableJson = {
|
|
height: [0.0],
|
|
id : [0]
|
|
};
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1, batchTableJson);
|
|
var results = [];
|
|
var names = batchTable.getPropertyNames(0, results);
|
|
expect(names).toBe(results);
|
|
expect(names).toEqual(['height', 'id']);
|
|
});
|
|
|
|
it('getProperty throws with invalid batchId', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.getProperty();
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.getProperty(-1);
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.getProperty(2);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('getProperty throws with undefined name', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.getProperty(0);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('getProperty', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(batchTable.getProperty(0, 'height')).toBeUndefined();
|
|
|
|
var batchTableJson = {
|
|
height: [1.0]
|
|
};
|
|
batchTable = new Cesium3DTileBatchTable(mockTileset, 1, batchTableJson);
|
|
expect(batchTable.getProperty(0, 'height')).toEqual(1.0);
|
|
expect(batchTable.getProperty(0, 'id')).toBeUndefined();
|
|
});
|
|
|
|
it('setProperty throws with invalid batchId', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.setProperty();
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.setProperty(-1);
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.setProperty(2);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('setProperty throws with undefined name', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.setProperty(0);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('setProperty without existing batch table', function() {
|
|
// Check that a batch table is created with a height of 1.0 for the first resource and undefined for the others
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 3);
|
|
batchTable.setProperty(0, 'height', 1.0);
|
|
|
|
expect(batchTable._properties.height.length).toEqual(3);
|
|
expect(batchTable.getProperty(0, 'height')).toEqual(1.0);
|
|
expect(batchTable.getProperty(1, 'height')).toBeUndefined();
|
|
expect(batchTable.getProperty(2, 'height')).toBeUndefined();
|
|
});
|
|
|
|
it('setProperty with existing batch table', function() {
|
|
var batchTableJson = {
|
|
height : [1.0, 2.0]
|
|
};
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 2, batchTableJson);
|
|
batchTable.setProperty(0, 'height', 3.0);
|
|
|
|
expect(batchTable.getProperty(0, 'height')).toEqual(3.0);
|
|
expect(batchTable.getProperty(1, 'height')).toEqual(2.0);
|
|
});
|
|
|
|
it('setProperty with object value', function() {
|
|
var batchTableJson = {
|
|
info : [{name : 'building0', year : 2000}, {name : 'building1', year : 2001}]
|
|
};
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 2, batchTableJson);
|
|
batchTable.setProperty(0, 'info', {name : 'building0_new', year : 2002});
|
|
|
|
expect(batchTable.getProperty(0, 'info')).toEqual({name : 'building0_new', year : 2002});
|
|
expect(batchTable.getProperty(1, 'info')).toEqual({name : 'building1', year : 2001});
|
|
});
|
|
|
|
it('setProperty with array value', function() {
|
|
var batchTableJson = {
|
|
rooms : [['room1', 'room2'], ['room3', 'room4']]
|
|
};
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 2, batchTableJson);
|
|
batchTable.setProperty(0, 'rooms', ['room1_new', 'room2']);
|
|
|
|
expect(batchTable.getProperty(0, 'rooms')).toEqual(['room1_new', 'room2']);
|
|
expect(batchTable.getProperty(1, 'rooms')).toEqual(['room3', 'room4']);
|
|
});
|
|
|
|
it('throws if the binary property does not specify a componentType', function() {
|
|
var batchTableJson = {
|
|
propertyScalar : {
|
|
byteOffset : 0,
|
|
type : 'SCALAR'
|
|
}
|
|
};
|
|
var batchTableBinary = new Float64Array([0, 1]);
|
|
expect(function() {
|
|
return new Cesium3DTileBatchTable(mockTileset, 2, batchTableJson, batchTableBinary);
|
|
}).toThrowRuntimeError();
|
|
});
|
|
|
|
it('throws if the binary property does not specify a type', function() {
|
|
var batchTableJson = {
|
|
propertyScalar : {
|
|
byteOffset : 0,
|
|
componentType : 'DOUBLE'
|
|
}
|
|
};
|
|
var batchTableBinary = new Float64Array([0, 1]);
|
|
expect(function() {
|
|
return new Cesium3DTileBatchTable(mockTileset, 2, batchTableJson, batchTableBinary);
|
|
}).toThrowRuntimeError();
|
|
});
|
|
|
|
it('throws if a binary property exists but there is no batchTableBinary', function() {
|
|
var batchTableJson = {
|
|
propertyScalar : {
|
|
byteOffset : 0,
|
|
componentType : 'DOUBLE',
|
|
type : 'SCALAR'
|
|
}
|
|
};
|
|
expect(function() {
|
|
return new Cesium3DTileBatchTable(mockTileset, 2, batchTableJson);
|
|
}).toThrowRuntimeError();
|
|
});
|
|
|
|
function concatTypedArrays(arrays) {
|
|
var i;
|
|
var length = arrays.length;
|
|
|
|
var byteLength = 0;
|
|
for (i = 0; i < length; ++i) {
|
|
byteLength += arrays[i].byteLength;
|
|
}
|
|
var buffer = new Uint8Array(byteLength);
|
|
|
|
var byteOffset = 0;
|
|
for (i = 0; i < length; ++i) {
|
|
var data = new Uint8Array(arrays[i].buffer);
|
|
byteLength = data.length;
|
|
for (var j = 0; j < byteLength; ++j) {
|
|
buffer[byteOffset++] = data[j];
|
|
}
|
|
}
|
|
return buffer;
|
|
}
|
|
|
|
it('getProperty and setProperty work for binary properties', function() {
|
|
var propertyScalarBinary = new Float64Array([0, 1]);
|
|
var propertyVec2Binary = new Float32Array([2, 3, 4, 5]);
|
|
var propertyVec3Binary = new Int32Array([6, 7, 8, 9, 10, 11]);
|
|
var propertyVec4Binary = new Uint32Array([12, 13, 14, 15, 16, 17, 18, 19]);
|
|
var propertyMat2Binary = new Int16Array([20, 21, 22, 23, 24, 25, 26, 27]);
|
|
var propertyMat3Binary = new Uint16Array([28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45]);
|
|
var propertyMat4Binary = new Uint8Array([46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77]);
|
|
|
|
var buffers = [propertyScalarBinary, propertyVec2Binary, propertyVec3Binary, propertyVec4Binary, propertyMat2Binary, propertyMat3Binary, propertyMat4Binary];
|
|
var batchTableBinary = concatTypedArrays(buffers);
|
|
var batchTableJson = {
|
|
propertyScalar : {
|
|
byteOffset : 0,
|
|
componentType : 'DOUBLE',
|
|
type : 'SCALAR'
|
|
},
|
|
propertyVec2 : {
|
|
byteOffset : 16,
|
|
componentType : 'FLOAT',
|
|
type : 'VEC2'
|
|
},
|
|
propertyVec3 : {
|
|
byteOffset : 32,
|
|
componentType : 'INT',
|
|
type : 'VEC3'
|
|
},
|
|
propertyVec4 : {
|
|
byteOffset : 56,
|
|
componentType : 'UNSIGNED_INT',
|
|
type : 'VEC4'
|
|
},
|
|
propertyMat2 : {
|
|
byteOffset : 88,
|
|
componentType : 'SHORT',
|
|
type : 'MAT2'
|
|
},
|
|
propertyMat3 : {
|
|
byteOffset : 104,
|
|
componentType : 'UNSIGNED_SHORT',
|
|
type : 'MAT3'
|
|
},
|
|
propertyMat4 : {
|
|
byteOffset : 140,
|
|
componentType : 'UNSIGNED_BYTE',
|
|
type : 'MAT4'
|
|
}
|
|
};
|
|
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 2, batchTableJson, batchTableBinary);
|
|
|
|
expect(batchTable.getProperty(1, 'propertyScalar')).toEqual(1);
|
|
expect(batchTable.getProperty(1, 'propertyVec2')).toEqual(new Cartesian2(4, 5));
|
|
expect(batchTable.getProperty(1, 'propertyVec3')).toEqual(new Cartesian3(9, 10, 11));
|
|
expect(batchTable.getProperty(1, 'propertyVec4')).toEqual(new Cartesian4(16, 17, 18, 19));
|
|
expect(batchTable.getProperty(1, 'propertyMat2')).toEqual(new Matrix2(24, 26, 25, 27)); // Constructor is row-major, data is column major
|
|
expect(batchTable.getProperty(1, 'propertyMat3')).toEqual(new Matrix3(37, 40, 43, 38, 41, 44, 39, 42, 45)); // Constructor is row-major, data is column major
|
|
expect(batchTable.getProperty(1, 'propertyMat4')).toEqual(new Matrix4(62, 66, 70, 74, 63, 67, 71, 75, 64, 68, 72, 76, 65, 69, 73, 77)); // Constructor is row-major, data is column major
|
|
|
|
batchTable.setProperty(1, 'propertyScalar', 2);
|
|
batchTable.setProperty(1, 'propertyVec2', new Cartesian2(5, 6));
|
|
batchTable.setProperty(1, 'propertyVec3', new Cartesian3(10, 11, 12));
|
|
batchTable.setProperty(1, 'propertyVec4', new Cartesian4(17, 18, 19, 20));
|
|
batchTable.setProperty(1, 'propertyMat2', new Matrix2(25, 27, 26, 28));
|
|
batchTable.setProperty(1, 'propertyMat3', new Matrix3(38, 41, 44, 39, 42, 45, 40, 43, 46));
|
|
batchTable.setProperty(1, 'propertyMat4', new Matrix4(63, 67, 71, 75, 64, 68, 72, 76, 65, 69, 73, 77, 66, 70, 74, 78));
|
|
|
|
expect(batchTable.getProperty(1, 'propertyScalar')).toEqual(2);
|
|
expect(batchTable.getProperty(1, 'propertyVec2')).toEqual(new Cartesian2(5, 6));
|
|
expect(batchTable.getProperty(1, 'propertyVec3')).toEqual(new Cartesian3(10, 11, 12));
|
|
expect(batchTable.getProperty(1, 'propertyVec4')).toEqual(new Cartesian4(17, 18, 19, 20));
|
|
expect(batchTable.getProperty(1, 'propertyMat2')).toEqual(new Matrix2(25, 27, 26, 28));
|
|
expect(batchTable.getProperty(1, 'propertyMat3')).toEqual(new Matrix3(38, 41, 44, 39, 42, 45, 40, 43, 46));
|
|
expect(batchTable.getProperty(1, 'propertyMat4')).toEqual(new Matrix4(63, 67, 71, 75, 64, 68, 72, 76, 65, 69, 73, 77, 66, 70, 74, 78));
|
|
});
|
|
|
|
it('renders tileset with batch table', function() {
|
|
return Cesium3DTilesTester.loadTileset(scene, withBatchTableUrl).then(function(tileset) {
|
|
var content = tileset.root.content;
|
|
|
|
// Each feature in the b3dm file has an id property from 0 to 9,
|
|
// check that the 2nd resource has an id of 2
|
|
expect(content.getFeature(2).getProperty('id')).toEqual(2);
|
|
|
|
// Check that a property can be an array
|
|
expect(content.getFeature(2).getProperty('rooms')).toEqual(['room2_a', 'room2_b', 'room2_c']);
|
|
|
|
// Check that a property can be an object
|
|
expect(content.getFeature(2).getProperty('info')).toEqual({name : 'building2', year : 2});
|
|
|
|
Cesium3DTilesTester.expectRenderTileset(scene, tileset);
|
|
});
|
|
});
|
|
|
|
it('renders tileset without batch table', function() {
|
|
return Cesium3DTilesTester.loadTileset(scene, withoutBatchTableUrl).then(function(tileset) {
|
|
var content = tileset.root.content;
|
|
|
|
expect(content.getFeature(2).getProperty('id')).toBeUndefined();
|
|
|
|
Cesium3DTilesTester.expectRenderTileset(scene, tileset);
|
|
});
|
|
});
|
|
|
|
it('renders when vertex texture fetch is not supported', function() {
|
|
// Disable VTF
|
|
var maximumVertexTextureImageUnits = ContextLimits.maximumVertexTextureImageUnits;
|
|
ContextLimits._maximumVertexTextureImageUnits = 0;
|
|
|
|
return Cesium3DTilesTester.loadTileset(scene, withoutBatchTableUrl).then(function(tileset) {
|
|
Cesium3DTilesTester.expectRenderTileset(scene, tileset);
|
|
|
|
// Re-enable VTF
|
|
ContextLimits._maximumVertexTextureImageUnits = maximumVertexTextureImageUnits;
|
|
});
|
|
});
|
|
|
|
it('renders with featuresLength greater than maximumTextureSize', function() {
|
|
// Set maximum texture size to 4 temporarily. Batch length of b3dm file is 10.
|
|
var maximumTextureSize = ContextLimits.maximumTextureSize;
|
|
ContextLimits._maximumTextureSize = 4;
|
|
|
|
return Cesium3DTilesTester.loadTileset(scene, withoutBatchTableUrl).then(function(tileset) {
|
|
var content = tileset.root.content;
|
|
expect(content.featuresLength).toBeGreaterThan(ContextLimits._maximumTextureSize);
|
|
Cesium3DTilesTester.expectRenderTileset(scene, tileset);
|
|
|
|
// Reset maximum texture size
|
|
ContextLimits._maximumTextureSize = maximumTextureSize;
|
|
});
|
|
});
|
|
|
|
it('renders with featuresLength of zero', function() {
|
|
return Cesium3DTilesTester.loadTileset(scene, noBatchIdsUrl).then(function(tileset) {
|
|
Cesium3DTilesTester.expectRender(scene, tileset);
|
|
|
|
expect(scene).toPickAndCall(function(result) {
|
|
expect(result).toBeDefined();
|
|
expect(result.primitive).toBe(tileset);
|
|
});
|
|
});
|
|
});
|
|
|
|
function expectRenderTranslucent(tileset) {
|
|
var batchTable = tileset.root.content.batchTable;
|
|
|
|
// Get initial color
|
|
var opaqueColor;
|
|
Cesium3DTilesTester.expectRender(scene, tileset, function(rgba) {
|
|
opaqueColor = rgba;
|
|
});
|
|
|
|
// Render translucent
|
|
batchTable.setAllColor(new Color(1.0, 1.0, 1.0, 0.5));
|
|
Cesium3DTilesTester.expectRender(scene, tileset, function(rgba) {
|
|
expect(rgba).not.toEqual(opaqueColor);
|
|
});
|
|
|
|
// Render restored to opaque
|
|
batchTable.setAllColor(Color.WHITE);
|
|
Cesium3DTilesTester.expectRender(scene, tileset, function(rgba) {
|
|
expect(rgba).toEqual(opaqueColor);
|
|
});
|
|
|
|
// Generate both translucent and opaque commands
|
|
batchTable.setColor(0, new Color(1.0, 1.0, 1.0, 0.5));
|
|
Cesium3DTilesTester.expectRender(scene, tileset);
|
|
|
|
// Fully transparent
|
|
batchTable.setAllColor(new Color(1.0, 1.0, 1.0, 0.0));
|
|
Cesium3DTilesTester.expectRenderBlank(scene, tileset);
|
|
}
|
|
|
|
it('renders translucent style', function() {
|
|
return Cesium3DTilesTester.loadTileset(scene, withoutBatchTableUrl).then(function(tileset) {
|
|
expectRenderTranslucent(tileset);
|
|
});
|
|
});
|
|
|
|
it('renders translucent style when vertex texture fetch is not supported', function() {
|
|
// Disable VTF
|
|
var maximumVertexTextureImageUnits = ContextLimits.maximumVertexTextureImageUnits;
|
|
ContextLimits._maximumVertexTextureImageUnits = 0;
|
|
return Cesium3DTilesTester.loadTileset(scene, withoutBatchTableUrl).then(function(tileset) {
|
|
expectRenderTranslucent(tileset);
|
|
// Re-enable VTF
|
|
ContextLimits._maximumVertexTextureImageUnits = maximumVertexTextureImageUnits;
|
|
});
|
|
});
|
|
|
|
it('isExactClass throws with invalid batchId', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.isExactClass();
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.isExactClass(2, 'door');
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.isExactClass(-1, 'door');
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('isExactClass throws with undefined className', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.isExactClass(0);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('isClass throws with invalid batchId', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.isClass();
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.isClass(2, 'door');
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.isClass(-1, 'door');
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('isClass throws with undefined className', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.isClass(0);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('getExactClassName throws with invalid batchId', function() {
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 1);
|
|
expect(function() {
|
|
batchTable.getExactClassName();
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.getExactClassName(1000);
|
|
}).toThrowDeveloperError();
|
|
expect(function() {
|
|
batchTable.getExactClassName(-1);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
function checkHierarchyStyling(tileset) {
|
|
// Check that a feature is colored from a generic batch table property.
|
|
tileset.style = new Cesium3DTileStyle({color : "${height} === 6.0 ? color('red') : color('green')"});
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
|
expect(rgba[0]).toBeGreaterThan(0); // Expect red
|
|
});
|
|
|
|
// Check that a feature is colored from a class property.
|
|
tileset.style = new Cesium3DTileStyle({color : "${roof_name} === 'roof2' ? color('red') : color('green')"});
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
|
expect(rgba[0]).toBeGreaterThan(0); // Expect red
|
|
});
|
|
|
|
// Check that a feature is colored from an inherited property.
|
|
tileset.style = new Cesium3DTileStyle({color : "${building_name} === 'building2' ? color('red') : color('green')"});
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
|
expect(rgba[0]).toBeGreaterThan(0); // Expect red
|
|
});
|
|
|
|
// Check isExactClass
|
|
tileset.style = new Cesium3DTileStyle({color : "isExactClass('roof') ? color('red') : color('green')"});
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
|
expect(rgba[0]).toBeGreaterThan(0); // Expect red
|
|
});
|
|
tileset.style = new Cesium3DTileStyle({color : "isExactClass('door') ? color('red') : color('green')"});
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
|
expect(rgba[1]).toBeGreaterThan(1); // Expect green
|
|
});
|
|
|
|
// Check isClass
|
|
tileset.style = new Cesium3DTileStyle({color : "isClass('roof') ? color('red') : color('green')"});
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
|
expect(rgba[0]).toBeGreaterThan(0); // Expect red
|
|
});
|
|
tileset.style = new Cesium3DTileStyle({color : "isClass('zone') ? color('red') : color('green')"});
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
|
expect(rgba[0]).toBeGreaterThan(0); // Expect red
|
|
});
|
|
|
|
// Check getExactClassName
|
|
tileset.style = new Cesium3DTileStyle({color : "getExactClassName() === 'roof' ? color('red') : color('green')"});
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
|
expect(rgba[0]).toBeGreaterThan(0); // Expect red
|
|
});
|
|
tileset.style = new Cesium3DTileStyle({color : "getExactClassName() === 'zone' ? color('red') : color('green')"});
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
|
expect(rgba[1]).toBeGreaterThan(0); // Expect green
|
|
});
|
|
}
|
|
|
|
function checkHierarchyStylingNoParents(tileset) {
|
|
// Check that a feature is colored from a generic batch table property.
|
|
tileset.style = new Cesium3DTileStyle({color : "${height} === 6.0 ? color('red') : color('green')"});
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
|
expect(rgba[0]).toBeGreaterThan(0); // Expect red
|
|
});
|
|
|
|
// Check that a feature is colored from a class property.
|
|
tileset.style = new Cesium3DTileStyle({color : "${roof_name} === 'roof2' ? color('red') : color('green')"});
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
|
expect(rgba[0]).toBeGreaterThan(0); // Expect red
|
|
});
|
|
|
|
// Check isExactClass
|
|
tileset.style = new Cesium3DTileStyle({color : "isExactClass('roof') ? color('red') : color('green')"});
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
|
expect(rgba[0]).toBeGreaterThan(0); // Expect red
|
|
});
|
|
|
|
// Check isClass
|
|
tileset.style = new Cesium3DTileStyle({color : "isClass('roof') ? color('red') : color('green')"});
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
|
expect(rgba[0]).toBeGreaterThan(0); // Expect red
|
|
});
|
|
|
|
// Check getExactClassName
|
|
tileset.style = new Cesium3DTileStyle({color : "getExactClassName() === 'roof' ? color('red') : color('green')"});
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
|
expect(rgba[0]).toBeGreaterThan(0); // Expect red
|
|
});
|
|
}
|
|
|
|
function checkHierarchyProperties(tileset, multipleParents) {
|
|
// Check isExactClass, isClass, and getExactClassName in Cesium3DTileFeature
|
|
var content = tileset.root.content;
|
|
var batchTable = content.batchTable;
|
|
var hierarchy = batchTable._batchTableHierarchy;
|
|
|
|
var doorFeature = content.getFeature(4);
|
|
var roofFeature = content.getFeature(8);
|
|
expect(doorFeature.isExactClass('door')).toBe(true);
|
|
expect(doorFeature.isExactClass('building')).toBe(false);
|
|
expect(doorFeature.isClass('door')).toBe(true);
|
|
expect(doorFeature.isClass('doorknob')).toBe(false);
|
|
expect(doorFeature.isClass('building')).toBe(true);
|
|
expect(doorFeature.getExactClassName()).toBe('door');
|
|
expect(doorFeature.hasProperty('door_name')).toBe(true);
|
|
expect(doorFeature.hasProperty('height')).toBe(true);
|
|
|
|
// Includes batch table properties and hierarchy properties from all inherited classes
|
|
var expectedPropertyNames = ['height', 'area', 'door_mass', 'door_width', 'door_name', 'building_area', 'building_name', 'zone_buildings', 'zone_name'];
|
|
|
|
// door0 has two parents - building0 and classifier_old
|
|
// building0 has two parents - zone0 and classifier_new
|
|
if (multipleParents) {
|
|
expectedPropertyNames.push('year', 'color', 'name', 'architect'); // classier_new
|
|
expectedPropertyNames.push('description', 'inspection'); // classifier_old
|
|
}
|
|
|
|
var propertyNames = doorFeature.getPropertyNames();
|
|
expect(expectedPropertyNames.sort()).toEqual(propertyNames.sort());
|
|
|
|
expect(doorFeature.getProperty('height')).toBe(5.0); // Gets generic property
|
|
expect(doorFeature.getProperty('door_name')).toBe('door0'); // Gets class property
|
|
expect(doorFeature.getProperty('building_name')).toBe('building0'); // Gets inherited property
|
|
|
|
// Sets generic property
|
|
doorFeature.setProperty('height', 10.0);
|
|
expect(doorFeature.getProperty('height')).toBe(10.0);
|
|
|
|
// Sets class property
|
|
doorFeature.setProperty('door_name', 'new_door');
|
|
expect(doorFeature.getProperty('door_name')).toBe('new_door');
|
|
expect(roofFeature.getProperty('door_name')).toBeUndefined();
|
|
|
|
// Throws error when setting inherited property
|
|
expect(function() {
|
|
doorFeature.setProperty('building_name', 'new_building');
|
|
}).toThrowDeveloperError();
|
|
|
|
// Check properties when there is no hierarchy
|
|
batchTable._batchTableHierarchy = undefined;
|
|
expect(doorFeature.isExactClass('door')).toBe(false);
|
|
expect(doorFeature.isClass('door')).toBe(false);
|
|
expect(doorFeature.getExactClassName()).toBeUndefined();
|
|
expect(doorFeature.hasProperty('door_name')).toBe(false);
|
|
expect(doorFeature.hasProperty('height')).toBe(true);
|
|
expect(doorFeature.getPropertyNames()).toEqual(['height', 'area']);
|
|
expect(doorFeature.getProperty('height')).toBe(10.0);
|
|
expect(doorFeature.getProperty('door_name')).toBeUndefined();
|
|
expect(doorFeature.getProperty('building_name')).toBeUndefined();
|
|
batchTable._batchTableHierarchy = hierarchy;
|
|
}
|
|
|
|
function checkHierarchyPropertiesNoParents(tileset) {
|
|
// Check isExactClass, isClass, and getExactClassName in Cesium3DTileFeature
|
|
var content = tileset.root.content;
|
|
var doorFeature = content.getFeature(4);
|
|
expect(doorFeature.isExactClass('door')).toBe(true);
|
|
expect(doorFeature.isExactClass('doorknob')).toBe(false);
|
|
expect(doorFeature.isClass('door')).toBe(true);
|
|
expect(doorFeature.isClass('doorknob')).toBe(false);
|
|
expect(doorFeature.getExactClassName()).toBe('door');
|
|
expect(doorFeature.hasProperty('door_name')).toBe(true);
|
|
expect(doorFeature.hasProperty('height')).toBe(true);
|
|
|
|
// Includes batch table properties and hierarchy properties from all inherited classes
|
|
var expectedPropertyNames = ['height', 'area', 'door_mass', 'door_width', 'door_name'];
|
|
|
|
var propertyNames = doorFeature.getPropertyNames();
|
|
expect(expectedPropertyNames.sort()).toEqual(propertyNames.sort());
|
|
|
|
expect(doorFeature.getProperty('height')).toBe(5.0); // Gets generic property
|
|
expect(doorFeature.getProperty('door_name')).toBe('door0'); // Gets class property
|
|
|
|
// Sets generic property
|
|
doorFeature.setProperty('height', 10.0);
|
|
expect(doorFeature.getProperty('height')).toBe(10.0);
|
|
|
|
// Sets class property
|
|
doorFeature.setProperty('door_name', 'new_door');
|
|
expect(doorFeature.getProperty('door_name')).toBe('new_door');
|
|
}
|
|
|
|
function checkBatchTableHierarchy(url, multipleParents) {
|
|
return Cesium3DTilesTester.loadTileset(scene, url).then(function(tileset) {
|
|
checkHierarchyStyling(tileset);
|
|
checkHierarchyProperties(tileset, multipleParents);
|
|
});
|
|
}
|
|
|
|
function checkBatchTableHierarchyNoParents(url) {
|
|
return Cesium3DTilesTester.loadTileset(scene, url).then(function(tileset) {
|
|
checkHierarchyStylingNoParents(tileset);
|
|
checkHierarchyPropertiesNoParents(tileset);
|
|
});
|
|
}
|
|
|
|
it('renders tileset with batch table hierarchy extension', function() {
|
|
return checkBatchTableHierarchy(batchTableHierarchyUrl, false);
|
|
});
|
|
|
|
it('renders tileset with batch table hierarchy using binary properties', function() {
|
|
return checkBatchTableHierarchy(batchTableHierarchyBinaryUrl, true);
|
|
});
|
|
|
|
it('renders tileset with batch table hierarchy with multiple parent classes', function() {
|
|
return checkBatchTableHierarchy(batchTableHierarchyMultipleParentsUrl, true);
|
|
});
|
|
|
|
it('renders tileset with batch table hierarchy with no parents', function() {
|
|
return checkBatchTableHierarchyNoParents(batchTableHierarchyNoParentsUrl);
|
|
});
|
|
|
|
it('renders tileset with legacy batch table hierarchy (pre-version 1.0)', function() {
|
|
return checkBatchTableHierarchy(batchTableHierarchyLegacyUrl, false);
|
|
});
|
|
|
|
it('warns about deprecated batch hierarchy (pre-version 1.0)', function() {
|
|
return checkBatchTableHierarchy(batchTableHierarchyLegacyUrl, false)
|
|
.then(function(tileset) {
|
|
expect(Cesium3DTileBatchTable._deprecationWarning).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
it('validates hierarchy with multiple parents', function() {
|
|
// building0
|
|
// / \
|
|
// door0 door1
|
|
// \ /
|
|
// window0
|
|
var batchTableJson = {
|
|
HIERARCHY : {
|
|
instancesLength : 4,
|
|
classIds : [0, 1, 1, 2],
|
|
parentCounts : [2, 1, 1, 0],
|
|
parentIds : [1, 2, 3, 3],
|
|
classes : [{
|
|
name : 'window',
|
|
length : 1,
|
|
instances : {
|
|
window_name : ['window0']
|
|
}
|
|
}, {
|
|
name : 'door',
|
|
length : 2,
|
|
instances : {
|
|
door_name : ['door0', 'door1']
|
|
}
|
|
}, {
|
|
name : 'building',
|
|
length : 1,
|
|
instances : {
|
|
building_name : ['building0']
|
|
}
|
|
}]
|
|
}
|
|
};
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 4, batchTableJson);
|
|
expect(batchTable.getPropertyNames(0).sort()).toEqual(['building_name', 'door_name', 'window_name']);
|
|
});
|
|
|
|
it('validates hierarchy with multiple parents (2)', function() {
|
|
// zone
|
|
// / | \
|
|
// building0 | \
|
|
// / \ | \
|
|
// door0 door1 /
|
|
// \ | /
|
|
// window0
|
|
var batchTableJson = {
|
|
HIERARCHY : {
|
|
instancesLength : 4,
|
|
classIds : [0, 1, 1, 2, 3],
|
|
parentCounts : [3, 1, 2, 1, 0],
|
|
parentIds : [1, 2, 4, 3, 3, 4, 4],
|
|
classes : [{
|
|
name : 'window',
|
|
length : 1,
|
|
instances : {
|
|
window_name : ['window0']
|
|
}
|
|
}, {
|
|
name : 'door',
|
|
length : 2,
|
|
instances : {
|
|
door_name : ['door0', 'door1']
|
|
}
|
|
}, {
|
|
name : 'building',
|
|
length : 1,
|
|
instances : {
|
|
building_name : ['building0']
|
|
}
|
|
}, {
|
|
name : 'zone',
|
|
length : 1,
|
|
instances : {
|
|
zone_name : ['zone0']
|
|
}
|
|
}]
|
|
}
|
|
};
|
|
var batchTable = new Cesium3DTileBatchTable(mockTileset, 5, batchTableJson);
|
|
expect(batchTable.getPropertyNames(0).sort()).toEqual(['building_name', 'door_name', 'window_name', 'zone_name']); // check window
|
|
expect(batchTable.hasProperty(1, 'zone_name')).toEqual(true); // check door0
|
|
expect(batchTable.hasProperty(2, 'zone_name')).toEqual(true); // check door1
|
|
});
|
|
|
|
//>>includeStart('debug', pragmas.debug);
|
|
// Circular dependencies are only caught in debug builds.
|
|
it('throws if hierarchy has a circular dependency', function() {
|
|
// window0 -> door0 -> building0 -> window0
|
|
var batchTableJson = {
|
|
HIERARCHY : {
|
|
instancesLength : 3,
|
|
classIds : [0, 1, 2],
|
|
parentIds : [1, 2, 0],
|
|
classes : [{
|
|
name : 'window',
|
|
length : 1,
|
|
instances : {
|
|
window_name : ['window0']
|
|
}
|
|
}, {
|
|
name : 'door',
|
|
length : 1,
|
|
instances : {
|
|
door_name : ['door0']
|
|
}
|
|
}, {
|
|
name : 'building',
|
|
length : 1,
|
|
instances : {
|
|
building_name : ['building0']
|
|
}
|
|
}]
|
|
}
|
|
};
|
|
expect(function() {
|
|
return new Cesium3DTileBatchTable(mockTileset, 3, batchTableJson);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws if hierarchy has a circular dependency (2)', function() {
|
|
// window0 -> door0 -> building0 -> window1 -> door0
|
|
var batchTableJson = {
|
|
HIERARCHY : {
|
|
instancesLength : 4,
|
|
classIds : [0, 1, 2, 0],
|
|
parentIds : [1, 2, 3, 1],
|
|
classes : [{
|
|
name : 'window',
|
|
length : 2,
|
|
instances : {
|
|
window_name : ['window0', 'window1']
|
|
}
|
|
}, {
|
|
name : 'door',
|
|
length : 1,
|
|
instances : {
|
|
door_name : ['door0']
|
|
}
|
|
}, {
|
|
name : 'building',
|
|
length : 1,
|
|
instances : {
|
|
building_name : ['building0']
|
|
}
|
|
}]
|
|
}
|
|
};
|
|
expect(function() {
|
|
return new Cesium3DTileBatchTable(mockTileset, 4, batchTableJson);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
//>>includeEnd('debug');
|
|
|
|
it('throws if an instance\'s parentId exceeds instancesLength', function() {
|
|
var batchTableJson = {
|
|
HIERARCHY : {
|
|
instancesLength : 2,
|
|
classIds : [0, 1],
|
|
parentIds : [1, 2],
|
|
classes : [{
|
|
name : 'window',
|
|
length : 1,
|
|
instances : {
|
|
window_name : ['window0']
|
|
}
|
|
}, {
|
|
name : 'door',
|
|
length : 1,
|
|
instances : {
|
|
door_name : ['door0']
|
|
}
|
|
}]
|
|
}
|
|
};
|
|
expect(function() {
|
|
return new Cesium3DTileBatchTable(mockTileset, 2, batchTableJson);
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('destroys', function() {
|
|
return Cesium3DTilesTester.loadTileset(scene, withoutBatchTableUrl).then(function(tileset) {
|
|
var content = tileset.root.content;
|
|
var batchTable = content.batchTable;
|
|
expect(batchTable.isDestroyed()).toEqual(false);
|
|
scene.primitives.remove(tileset);
|
|
expect(batchTable.isDestroyed()).toEqual(true);
|
|
});
|
|
});
|
|
|
|
}, 'WebGL');
|