440 lines
17 KiB
JavaScript
440 lines
17 KiB
JavaScript
defineSuite([
|
|
'DataSources/PolygonGeometryUpdater',
|
|
'Core/ApproximateTerrainHeights',
|
|
'Core/Cartesian3',
|
|
'Core/Color',
|
|
'Core/Ellipsoid',
|
|
'Core/GeometryOffsetAttribute',
|
|
'Core/JulianDate',
|
|
'Core/Math',
|
|
'Core/CoplanarPolygonGeometry',
|
|
'Core/CoplanarPolygonOutlineGeometry',
|
|
'Core/PolygonGeometry',
|
|
'Core/PolygonOutlineGeometry',
|
|
'Core/PolygonHierarchy',
|
|
'Core/TimeIntervalCollection',
|
|
'DataSources/ConstantProperty',
|
|
'DataSources/Entity',
|
|
'DataSources/PolygonGraphics',
|
|
'DataSources/PropertyArray',
|
|
'DataSources/SampledPositionProperty',
|
|
'DataSources/SampledProperty',
|
|
'Scene/GroundPrimitive',
|
|
'Scene/HeightReference',
|
|
'Scene/PrimitiveCollection',
|
|
'Specs/createDynamicGeometryUpdaterSpecs',
|
|
'Specs/createDynamicProperty',
|
|
'Specs/createGeometryUpdaterGroundGeometrySpecs',
|
|
'Specs/createGeometryUpdaterSpecs',
|
|
'Specs/createScene'
|
|
], function(
|
|
PolygonGeometryUpdater,
|
|
ApproximateTerrainHeights,
|
|
Cartesian3,
|
|
Color,
|
|
Ellipsoid,
|
|
GeometryOffsetAttribute,
|
|
JulianDate,
|
|
CesiumMath,
|
|
CoplanarPolygonGeometry,
|
|
CoplanarPolygonOutlineGeometry,
|
|
PolygonGeometry,
|
|
PolygonOutlineGeometry,
|
|
PolygonHierarchy,
|
|
TimeIntervalCollection,
|
|
ConstantProperty,
|
|
Entity,
|
|
PolygonGraphics,
|
|
PropertyArray,
|
|
SampledPositionProperty,
|
|
SampledProperty,
|
|
GroundPrimitive,
|
|
HeightReference,
|
|
PrimitiveCollection,
|
|
createDynamicGeometryUpdaterSpecs,
|
|
createDynamicProperty,
|
|
createGeometryUpdaterGroundGeometrySpecs,
|
|
createGeometryUpdaterSpecs,
|
|
createScene) {
|
|
'use strict';
|
|
|
|
var scene;
|
|
var time;
|
|
var groundPrimitiveSupported;
|
|
|
|
beforeAll(function() {
|
|
scene = createScene();
|
|
time = JulianDate.now();
|
|
groundPrimitiveSupported = GroundPrimitive.isSupported(scene);
|
|
return ApproximateTerrainHeights.initialize();
|
|
});
|
|
|
|
afterAll(function() {
|
|
scene.destroyForSpecs();
|
|
|
|
ApproximateTerrainHeights._initPromise = undefined;
|
|
ApproximateTerrainHeights._terrainHeights = undefined;
|
|
});
|
|
|
|
function createBasicPolygon() {
|
|
var polygon = new PolygonGraphics();
|
|
polygon.hierarchy = new ConstantProperty(new PolygonHierarchy(Cartesian3.fromRadiansArray([
|
|
-1, -1,
|
|
1, -1,
|
|
1, 1,
|
|
-1, 1
|
|
])));
|
|
polygon.height = new ConstantProperty(0);
|
|
var entity = new Entity();
|
|
entity.polygon = polygon;
|
|
return entity;
|
|
}
|
|
|
|
function createVerticalPolygon() {
|
|
var polygon = new PolygonGraphics();
|
|
polygon.hierarchy = new ConstantProperty(new PolygonHierarchy(Cartesian3.fromDegreesArrayHeights([
|
|
-1.0, 1.0, 0.0,
|
|
-2.0, 1.0, 0.0,
|
|
-2.0, 1.0, 0.0
|
|
])));
|
|
polygon.perPositionHeight = true;
|
|
var entity = new Entity();
|
|
entity.polygon = polygon;
|
|
return entity;
|
|
}
|
|
|
|
function createDynamicPolygon() {
|
|
var entity = createBasicPolygon();
|
|
entity.polygon.extrudedHeight = createDynamicProperty(2);
|
|
return entity;
|
|
}
|
|
|
|
function createBasicPolygonWithoutHeight() {
|
|
var polygon = new PolygonGraphics();
|
|
polygon.hierarchy = new ConstantProperty(new PolygonHierarchy(Cartesian3.fromRadiansArray([
|
|
0, 0,
|
|
1, 0,
|
|
1, 1,
|
|
0, 1
|
|
])));
|
|
var entity = new Entity();
|
|
entity.polygon = polygon;
|
|
return entity;
|
|
}
|
|
|
|
function createDynamicPolygonWithoutHeight() {
|
|
var entity = createBasicPolygonWithoutHeight();
|
|
entity.polygon.granularity = createDynamicProperty(1);
|
|
return entity;
|
|
}
|
|
|
|
it('Properly computes isClosed', function() {
|
|
var entity = createBasicPolygon();
|
|
entity.polygon.perPositionHeight = true;
|
|
var updater = new PolygonGeometryUpdater(entity, scene);
|
|
expect(updater.isClosed).toBe(false); //open because of perPositionHeights
|
|
|
|
entity.polygon.perPositionHeight = false;
|
|
updater._onEntityPropertyChanged(entity, 'polygon');
|
|
expect(updater.isClosed).toBe(true); //close because polygon is on the ground
|
|
|
|
entity.polygon.height = 1000;
|
|
updater._onEntityPropertyChanged(entity, 'polygon');
|
|
expect(updater.isClosed).toBe(false); //open because polygon is at a height
|
|
|
|
entity.polygon.extrudedHeight = 1000;
|
|
updater._onEntityPropertyChanged(entity, 'polygon');
|
|
expect(updater.isClosed).toBe(false); //open because height === extrudedHeight so it's not extruded
|
|
|
|
entity.polygon.extrudedHeight = 100;
|
|
updater._onEntityPropertyChanged(entity, 'polygon');
|
|
expect(updater.isClosed).toBe(true); //closed because polygon is extruded
|
|
|
|
entity.polygon.closeTop = false;
|
|
updater._onEntityPropertyChanged(entity, 'polygon');
|
|
expect(updater.isClosed).toBe(false); //open because top cap isn't included
|
|
|
|
entity.polygon.closeTop = true;
|
|
entity.polygon.closeBottom = false;
|
|
updater._onEntityPropertyChanged(entity, 'polygon');
|
|
expect(updater.isClosed).toBe(false); //open because bottom cap isn't included
|
|
});
|
|
|
|
it('A time-varying positions causes geometry to be dynamic', function() {
|
|
var entity = createBasicPolygon();
|
|
var updater = new PolygonGeometryUpdater(entity, scene);
|
|
var point1 = new SampledPositionProperty();
|
|
point1.addSample(time, new Cartesian3());
|
|
var point2 = new SampledPositionProperty();
|
|
point2.addSample(time, new Cartesian3());
|
|
var point3 = new SampledPositionProperty();
|
|
point3.addSample(time, new Cartesian3());
|
|
|
|
entity.polygon.hierarchy = new PropertyArray();
|
|
entity.polygon.hierarchy.setValue([point1, point2, point3]);
|
|
updater._onEntityPropertyChanged(entity, 'polygon');
|
|
|
|
expect(updater.isDynamic).toBe(true);
|
|
});
|
|
|
|
it('A time-varying height causes geometry to be dynamic', function() {
|
|
var entity = createBasicPolygon();
|
|
var updater = new PolygonGeometryUpdater(entity, scene);
|
|
entity.polygon.height = new SampledProperty(Number);
|
|
entity.polygon.height.addSample(time, 1);
|
|
updater._onEntityPropertyChanged(entity, 'polygon');
|
|
|
|
expect(updater.isDynamic).toBe(true);
|
|
});
|
|
|
|
it('A time-varying extrudedHeight causes geometry to be dynamic', function() {
|
|
var entity = createBasicPolygon();
|
|
var updater = new PolygonGeometryUpdater(entity, scene);
|
|
entity.polygon.extrudedHeight = new SampledProperty(Number);
|
|
entity.polygon.extrudedHeight.addSample(time, 1);
|
|
updater._onEntityPropertyChanged(entity, 'polygon');
|
|
|
|
expect(updater.isDynamic).toBe(true);
|
|
});
|
|
|
|
it('A time-varying granularity causes geometry to be dynamic', function() {
|
|
var entity = createBasicPolygon();
|
|
var updater = new PolygonGeometryUpdater(entity, scene);
|
|
entity.polygon.granularity = new SampledProperty(Number);
|
|
entity.polygon.granularity.addSample(time, 1);
|
|
updater._onEntityPropertyChanged(entity, 'polygon');
|
|
|
|
expect(updater.isDynamic).toBe(true);
|
|
});
|
|
|
|
it('A time-varying stRotation causes geometry to be dynamic', function() {
|
|
var entity = createBasicPolygon();
|
|
var updater = new PolygonGeometryUpdater(entity, scene);
|
|
entity.polygon.stRotation = new SampledProperty(Number);
|
|
entity.polygon.stRotation.addSample(time, 1);
|
|
updater._onEntityPropertyChanged(entity, 'polygon');
|
|
|
|
expect(updater.isDynamic).toBe(true);
|
|
});
|
|
|
|
it('A time-varying perPositionHeight causes geometry to be dynamic', function() {
|
|
var entity = createBasicPolygon();
|
|
var updater = new PolygonGeometryUpdater(entity, scene);
|
|
entity.polygon.perPositionHeight = new SampledProperty(Number);
|
|
entity.polygon.perPositionHeight.addSample(time, 1);
|
|
updater._onEntityPropertyChanged(entity, 'polygon');
|
|
|
|
expect(updater.isDynamic).toBe(true);
|
|
});
|
|
|
|
it('Creates geometry with expected properties', function() {
|
|
var options = {
|
|
height : 431,
|
|
extrudedHeight : 123,
|
|
granularity : 0.97,
|
|
stRotation : 12,
|
|
perPositionHeight : false,
|
|
closeTop: true,
|
|
closeBottom: false
|
|
};
|
|
|
|
var entity = createBasicPolygon();
|
|
|
|
var polygon = entity.polygon;
|
|
polygon.outline = true;
|
|
polygon.perPositionHeight = new ConstantProperty(options.perPositionHeight);
|
|
polygon.closeTop = new ConstantProperty(options.closeTop);
|
|
polygon.closeBottom = new ConstantProperty(options.closeBottom);
|
|
polygon.stRotation = new ConstantProperty(options.stRotation);
|
|
polygon.height = new ConstantProperty(options.height);
|
|
polygon.extrudedHeight = new ConstantProperty(options.extrudedHeight);
|
|
polygon.granularity = new ConstantProperty(options.granularity);
|
|
|
|
var updater = new PolygonGeometryUpdater(entity, scene);
|
|
|
|
var instance;
|
|
var geometry;
|
|
instance = updater.createFillGeometryInstance(time);
|
|
geometry = instance.geometry;
|
|
expect(geometry).toBeInstanceOf(PolygonGeometry);
|
|
expect(geometry._stRotation).toEqual(options.stRotation);
|
|
expect(geometry._height).toEqual(options.height);
|
|
expect(geometry._granularity).toEqual(options.granularity);
|
|
expect(geometry._extrudedHeight).toEqual(options.extrudedHeight);
|
|
expect(geometry._closeTop).toEqual(options.closeTop);
|
|
expect(geometry._closeBottom).toEqual(options.closeBottom);
|
|
expect(geometry._offsetAttribute).toBeUndefined();
|
|
|
|
instance = updater.createOutlineGeometryInstance(time);
|
|
geometry = instance.geometry;
|
|
expect(geometry).toBeInstanceOf(PolygonOutlineGeometry);
|
|
expect(geometry._height).toEqual(options.height);
|
|
expect(geometry._granularity).toEqual(options.granularity);
|
|
expect(geometry._extrudedHeight).toEqual(options.extrudedHeight);
|
|
expect(geometry._perPositionHeight).toEqual(options.perPositionHeight);
|
|
expect(geometry._offsetAttribute).toBeUndefined();
|
|
});
|
|
|
|
it('Creates coplanar polygon', function() {
|
|
var stRotation = 12;
|
|
|
|
var entity = createVerticalPolygon();
|
|
|
|
var polygon = entity.polygon;
|
|
polygon.outline = true;
|
|
polygon.stRotation = new ConstantProperty(stRotation);
|
|
|
|
var updater = new PolygonGeometryUpdater(entity, scene);
|
|
|
|
var instance;
|
|
var geometry;
|
|
instance = updater.createFillGeometryInstance(time);
|
|
geometry = instance.geometry;
|
|
expect(geometry).toBeInstanceOf(CoplanarPolygonGeometry);
|
|
expect(geometry._stRotation).toEqual(stRotation);
|
|
|
|
instance = updater.createOutlineGeometryInstance(time);
|
|
geometry = instance.geometry;
|
|
expect(geometry).toBeInstanceOf(CoplanarPolygonOutlineGeometry);
|
|
});
|
|
|
|
it('Checks that a polygon with per position heights isn\'t on terrain', function() {
|
|
var entity = createBasicPolygon();
|
|
entity.polygon.height = undefined;
|
|
entity.polygon.perPositionHeight = new ConstantProperty(true);
|
|
|
|
var updater = new PolygonGeometryUpdater(entity, scene);
|
|
|
|
expect(updater.onTerrain).toBe(false);
|
|
});
|
|
|
|
it('Checks that a polygon without per position heights is on terrain', function() {
|
|
var entity = createBasicPolygon();
|
|
entity.polygon.height = undefined;
|
|
entity.polygon.perPositionHeight = new ConstantProperty(false);
|
|
|
|
var updater = new PolygonGeometryUpdater(entity, scene);
|
|
|
|
if (groundPrimitiveSupported) {
|
|
expect(updater.onTerrain).toBe(true);
|
|
} else {
|
|
expect(updater.onTerrain).toBe(false);
|
|
}
|
|
});
|
|
|
|
it('Checks that a polygon without per position heights does not use a height reference', function() {
|
|
var entity = createBasicPolygon();
|
|
var graphics = entity.polygon;
|
|
graphics.perPositionHeight = new ConstantProperty(true);
|
|
graphics.outline = true;
|
|
graphics.outlineColor = Color.BLACK;
|
|
graphics.height = undefined;
|
|
graphics.extrudedHeight = undefined;
|
|
var updater = new PolygonGeometryUpdater(entity, scene);
|
|
|
|
var instance;
|
|
|
|
graphics.heightReference = new ConstantProperty(HeightReference.RELATIVE_TO_GROUND);
|
|
graphics.extrudedHeightReference = new ConstantProperty(HeightReference.RELATIVE_TO_GROUND);
|
|
updater._onEntityPropertyChanged(entity, 'polygon');
|
|
instance = updater.createFillGeometryInstance(time);
|
|
expect(instance.geometry._offsetAttribute).toBeUndefined();
|
|
instance = updater.createOutlineGeometryInstance(time);
|
|
expect(instance.geometry._offsetAttribute).toBeUndefined();
|
|
});
|
|
|
|
it('dynamic updater sets properties', function() {
|
|
var polygon = new PolygonGraphics();
|
|
polygon.hierarchy = createDynamicProperty(new PolygonHierarchy(Cartesian3.fromRadiansArray([
|
|
0, 0,
|
|
1, 0,
|
|
1, 1,
|
|
0, 1
|
|
])));
|
|
polygon.height = createDynamicProperty(3);
|
|
polygon.extrudedHeight = createDynamicProperty(2);
|
|
polygon.perPositionHeight = createDynamicProperty(false);
|
|
polygon.granularity = createDynamicProperty(2);
|
|
polygon.stRotation = createDynamicProperty(1);
|
|
polygon.closeTop = createDynamicProperty(false);
|
|
polygon.closeBottom = createDynamicProperty(false);
|
|
|
|
var entity = new Entity();
|
|
entity.polygon = polygon;
|
|
|
|
var updater = new PolygonGeometryUpdater(entity, scene);
|
|
var dynamicUpdater = updater.createDynamicUpdater(new PrimitiveCollection(), new PrimitiveCollection());
|
|
dynamicUpdater.update(time);
|
|
|
|
var options = dynamicUpdater._options;
|
|
expect(options.id).toEqual(entity);
|
|
expect(options.polygonHierarchy).toEqual(polygon.hierarchy.getValue());
|
|
expect(options.height).toEqual(polygon.height.getValue());
|
|
expect(options.extrudedHeight).toEqual(polygon.extrudedHeight.getValue());
|
|
expect(options.perPositionHeight).toEqual(polygon.perPositionHeight.getValue());
|
|
expect(options.granularity).toEqual(polygon.granularity.getValue());
|
|
expect(options.stRotation).toEqual(polygon.stRotation.getValue());
|
|
expect(options.closeTop).toEqual(polygon.closeTop.getValue());
|
|
expect(options.closeBottom).toEqual(polygon.closeBottom.getValue());
|
|
expect(options.offsetAttribute).toBeUndefined();
|
|
});
|
|
|
|
it('geometryChanged event is raised when expected', function() {
|
|
var entity = createBasicPolygon();
|
|
var updater = new PolygonGeometryUpdater(entity, scene);
|
|
var listener = jasmine.createSpy('listener');
|
|
updater.geometryChanged.addEventListener(listener);
|
|
|
|
entity.polygon.hierarchy = new ConstantProperty([]);
|
|
updater._onEntityPropertyChanged(entity, 'polygon');
|
|
expect(listener.calls.count()).toEqual(1);
|
|
|
|
entity.polygon.height = new ConstantProperty(82);
|
|
updater._onEntityPropertyChanged(entity, 'polygon');
|
|
expect(listener.calls.count()).toEqual(2);
|
|
|
|
entity.availability = new TimeIntervalCollection();
|
|
updater._onEntityPropertyChanged(entity, 'availability');
|
|
expect(listener.calls.count()).toEqual(3);
|
|
|
|
entity.polygon.hierarchy = undefined;
|
|
updater._onEntityPropertyChanged(entity, 'polygon');
|
|
expect(listener.calls.count()).toEqual(4);
|
|
|
|
//Since there's no valid geometry, changing another property should not raise the event.
|
|
entity.polygon.height = undefined;
|
|
updater._onEntityPropertyChanged(entity, 'polygon');
|
|
|
|
//Modifying an unrelated property should not have any effect.
|
|
entity.viewFrom = new ConstantProperty(Cartesian3.UNIT_X);
|
|
updater._onEntityPropertyChanged(entity, 'viewFrom');
|
|
expect(listener.calls.count()).toEqual(4);
|
|
});
|
|
|
|
it('perPositionHeight is true sets onTerrain to false', function() {
|
|
var entity = createBasicPolygonWithoutHeight();
|
|
entity.polygon.fill = true;
|
|
entity.polygon.perPositionHeight = true;
|
|
var updater = new PolygonGeometryUpdater(entity, scene);
|
|
expect(updater.onTerrain).toBe(false);
|
|
});
|
|
|
|
it('computes center', function() {
|
|
var entity = createBasicPolygon();
|
|
var updater = new PolygonGeometryUpdater(entity, scene);
|
|
var result = updater._computeCenter(time);
|
|
result = Ellipsoid.WGS84.scaleToGeodeticSurface(result, result);
|
|
expect(result).toEqualEpsilon(Cartesian3.fromDegrees(0.0, 0.0), CesiumMath.EPSILON10);
|
|
});
|
|
|
|
function getScene() {
|
|
return scene;
|
|
}
|
|
|
|
createGeometryUpdaterSpecs(PolygonGeometryUpdater, 'polygon', createBasicPolygon, getScene);
|
|
|
|
createDynamicGeometryUpdaterSpecs(PolygonGeometryUpdater, 'polygon', createDynamicPolygon, getScene);
|
|
|
|
createGeometryUpdaterGroundGeometrySpecs(PolygonGeometryUpdater, 'polygon', createBasicPolygonWithoutHeight, createDynamicPolygonWithoutHeight, getScene);
|
|
}, 'WebGL');
|