424 lines
16 KiB
JavaScript
424 lines
16 KiB
JavaScript
defineSuite([
|
|
'Core/EllipseGeometry',
|
|
'Core/arrayFill',
|
|
'Core/Cartesian3',
|
|
'Core/Ellipsoid',
|
|
'Core/GeometryOffsetAttribute',
|
|
'Core/Math',
|
|
'Core/Rectangle',
|
|
'Core/VertexFormat',
|
|
'Specs/createPackableSpecs'
|
|
], function(
|
|
EllipseGeometry,
|
|
arrayFill,
|
|
Cartesian3,
|
|
Ellipsoid,
|
|
GeometryOffsetAttribute,
|
|
CesiumMath,
|
|
Rectangle,
|
|
VertexFormat,
|
|
createPackableSpecs) {
|
|
'use strict';
|
|
|
|
it('throws without a center', function() {
|
|
expect(function() {
|
|
return new EllipseGeometry({
|
|
semiMajorAxis : 1.0,
|
|
semiMinorAxis : 1.0
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws without a semiMajorAxis', function() {
|
|
expect(function() {
|
|
return new EllipseGeometry({
|
|
center : Cartesian3.fromDegrees(0,0),
|
|
semiMinorAxis : 1.0
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws without a semiMinorAxis', function() {
|
|
expect(function() {
|
|
return new EllipseGeometry({
|
|
center : Cartesian3.fromDegrees(0,0),
|
|
semiMajorAxis : 1.0
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws with a negative granularity', function() {
|
|
expect(function() {
|
|
return new EllipseGeometry({
|
|
center : Cartesian3.fromDegrees(0,0),
|
|
semiMajorAxis : 1.0,
|
|
semiMinorAxis : 1.0,
|
|
granularity : -1.0
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('throws when semiMajorAxis is less than the semiMajorAxis', function() {
|
|
expect(function() {
|
|
return new EllipseGeometry({
|
|
center : Cartesian3.fromDegrees(0,0),
|
|
semiMajorAxis : 1.0,
|
|
semiMinorAxis : 2.0
|
|
});
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('computes positions', function() {
|
|
var m = EllipseGeometry.createGeometry(new EllipseGeometry({
|
|
vertexFormat : VertexFormat.POSITION_ONLY,
|
|
ellipsoid : Ellipsoid.WGS84,
|
|
center : Cartesian3.fromDegrees(0,0),
|
|
granularity : 0.1,
|
|
semiMajorAxis : 1.0,
|
|
semiMinorAxis : 1.0
|
|
}));
|
|
|
|
expect(m.attributes.position.values.length).toEqual(16 * 3); // rows of 1 + 4 + 6 + 4 + 1
|
|
expect(m.indices.length).toEqual(22 * 3); // rows of 3 + 8 + 8 + 3
|
|
expect(m.boundingSphere.radius).toEqual(1);
|
|
});
|
|
|
|
it('compute all vertex attributes', function() {
|
|
var m = EllipseGeometry.createGeometry(new EllipseGeometry({
|
|
vertexFormat : VertexFormat.ALL,
|
|
ellipsoid : Ellipsoid.WGS84,
|
|
center : Cartesian3.fromDegrees(0,0),
|
|
granularity : 0.1,
|
|
semiMajorAxis : 1.0,
|
|
semiMinorAxis : 1.0
|
|
}));
|
|
|
|
var numVertices = 16;
|
|
var numTriangles = 22;
|
|
expect(m.attributes.position.values.length).toEqual(numVertices * 3);
|
|
expect(m.attributes.st.values.length).toEqual(numVertices * 2);
|
|
expect(m.attributes.normal.values.length).toEqual(numVertices * 3);
|
|
expect(m.attributes.tangent.values.length).toEqual(numVertices * 3);
|
|
expect(m.attributes.bitangent.values.length).toEqual(numVertices * 3);
|
|
expect(m.indices.length).toEqual(numTriangles * 3);
|
|
});
|
|
|
|
it('compute texture coordinates with rotation', function() {
|
|
var m = EllipseGeometry.createGeometry(new EllipseGeometry({
|
|
vertexFormat : VertexFormat.POSITION_AND_ST,
|
|
ellipsoid : Ellipsoid.WGS84,
|
|
center : Cartesian3.fromDegrees(0,0),
|
|
granularity : 0.1,
|
|
semiMajorAxis : 1.0,
|
|
semiMinorAxis : 1.0,
|
|
stRotation : CesiumMath.PI_OVER_TWO
|
|
}));
|
|
|
|
var positions = m.attributes.position.values;
|
|
var st = m.attributes.st.values;
|
|
var length = st.length;
|
|
|
|
var numVertices = 16;
|
|
var numTriangles = 22;
|
|
expect(positions.length).toEqual(numVertices * 3);
|
|
expect(length).toEqual(numVertices * 2);
|
|
expect(m.indices.length).toEqual(numTriangles * 3);
|
|
|
|
expect(st[length - 2]).toEqualEpsilon(0.5, CesiumMath.EPSILON2);
|
|
expect(st[length - 1]).toEqualEpsilon(0.0, CesiumMath.EPSILON2);
|
|
});
|
|
|
|
it('computes positions extruded', function() {
|
|
var m = EllipseGeometry.createGeometry(new EllipseGeometry({
|
|
vertexFormat : VertexFormat.POSITION_ONLY,
|
|
ellipsoid : Ellipsoid.WGS84,
|
|
center : Cartesian3.fromDegrees(0,0),
|
|
granularity : 0.1,
|
|
semiMajorAxis : 1.0,
|
|
semiMinorAxis : 1.0,
|
|
extrudedHeight : 50000
|
|
}));
|
|
|
|
var numVertices = 48; // 16 top + 16 bottom + 8 top edge + 8 bottom edge
|
|
var numTriangles = 60; // 22 top fill + 22 bottom fill + 2 triangles * 8 sides
|
|
expect(m.attributes.position.values.length).toEqual(numVertices * 3);
|
|
expect(m.indices.length).toEqual(numTriangles * 3);
|
|
});
|
|
|
|
it('computes offset attribute', function() {
|
|
var m = EllipseGeometry.createGeometry(new EllipseGeometry({
|
|
vertexFormat : VertexFormat.POSITION_ONLY,
|
|
ellipsoid : Ellipsoid.WGS84,
|
|
center : Cartesian3.fromDegrees(0,0),
|
|
granularity : 0.1,
|
|
semiMajorAxis : 1.0,
|
|
semiMinorAxis : 1.0,
|
|
offsetAttribute: GeometryOffsetAttribute.TOP
|
|
}));
|
|
|
|
var numVertices = 16;
|
|
expect(m.attributes.position.values.length).toEqual(numVertices * 3);
|
|
|
|
var offset = m.attributes.applyOffset.values;
|
|
expect(offset.length).toEqual(numVertices);
|
|
var expected = new Array(offset.length);
|
|
expected = arrayFill(expected, 1);
|
|
expect(offset).toEqual(expected);
|
|
});
|
|
|
|
it('computes offset attribute extruded for top vertices', function() {
|
|
var m = EllipseGeometry.createGeometry(new EllipseGeometry({
|
|
vertexFormat : VertexFormat.POSITION_ONLY,
|
|
ellipsoid : Ellipsoid.WGS84,
|
|
center : Cartesian3.fromDegrees(0,0),
|
|
granularity : 0.1,
|
|
semiMajorAxis : 1.0,
|
|
semiMinorAxis : 1.0,
|
|
extrudedHeight : 50000,
|
|
offsetAttribute: GeometryOffsetAttribute.TOP
|
|
}));
|
|
|
|
var numVertices = 48;
|
|
expect(m.attributes.position.values.length).toEqual(numVertices * 3);
|
|
|
|
var offset = m.attributes.applyOffset.values;
|
|
expect(offset.length).toEqual(numVertices);
|
|
var expected = new Array(offset.length);
|
|
expected = arrayFill(expected, 0);
|
|
expected = arrayFill(expected, 1, 0, 16);
|
|
expected = arrayFill(expected, 1, 32, 40);
|
|
expect(offset).toEqual(expected);
|
|
});
|
|
|
|
it('computes offset attribute extruded for all vertices', function() {
|
|
var m = EllipseGeometry.createGeometry(new EllipseGeometry({
|
|
vertexFormat : VertexFormat.POSITION_ONLY,
|
|
ellipsoid : Ellipsoid.WGS84,
|
|
center : Cartesian3.fromDegrees(0,0),
|
|
granularity : 0.1,
|
|
semiMajorAxis : 1.0,
|
|
semiMinorAxis : 1.0,
|
|
extrudedHeight : 50000,
|
|
offsetAttribute: GeometryOffsetAttribute.ALL
|
|
}));
|
|
|
|
var numVertices = 48;
|
|
expect(m.attributes.position.values.length).toEqual(numVertices * 3);
|
|
|
|
var offset = m.attributes.applyOffset.values;
|
|
expect(offset.length).toEqual(numVertices);
|
|
var expected = new Array(offset.length);
|
|
expected = arrayFill(expected, 1);
|
|
expect(offset).toEqual(expected);
|
|
});
|
|
|
|
it('compute all vertex attributes extruded', function() {
|
|
var m = EllipseGeometry.createGeometry(new EllipseGeometry({
|
|
vertexFormat : VertexFormat.ALL,
|
|
ellipsoid : Ellipsoid.WGS84,
|
|
center : Cartesian3.fromDegrees(0,0),
|
|
granularity : 0.1,
|
|
semiMajorAxis : 1.0,
|
|
semiMinorAxis : 1.0,
|
|
extrudedHeight : 50000
|
|
}));
|
|
|
|
var numVertices = 48;
|
|
var numTriangles = 60;
|
|
expect(m.attributes.position.values.length).toEqual(numVertices * 3);
|
|
expect(m.attributes.st.values.length).toEqual(numVertices * 2);
|
|
expect(m.attributes.normal.values.length).toEqual(numVertices * 3);
|
|
expect(m.attributes.tangent.values.length).toEqual(numVertices * 3);
|
|
expect(m.attributes.bitangent.values.length).toEqual(numVertices * 3);
|
|
expect(m.indices.length).toEqual(numTriangles * 3);
|
|
});
|
|
|
|
it('undefined is returned if the minor axis is equal to or less than zero', function() {
|
|
var ellipse0 = new EllipseGeometry({
|
|
center : Cartesian3.fromDegrees(-75.59777, 40.03883),
|
|
semiMajorAxis : 300000.0,
|
|
semiMinorAxis : 0.0
|
|
});
|
|
var ellipse1 = new EllipseGeometry({
|
|
center : Cartesian3.fromDegrees(-75.59777, 40.03883),
|
|
semiMajorAxis : 0.0,
|
|
semiMinorAxis : -1.0
|
|
});
|
|
var ellipse2 = new EllipseGeometry({
|
|
center : Cartesian3.fromDegrees(-75.59777, 40.03883),
|
|
semiMajorAxis : 300000.0,
|
|
semiMinorAxis : -10.0
|
|
});
|
|
var ellipse3 = new EllipseGeometry({
|
|
center : Cartesian3.fromDegrees(-75.59777, 40.03883),
|
|
semiMajorAxis : -1.0,
|
|
semiMinorAxis : -2.0
|
|
});
|
|
|
|
var geometry0 = EllipseGeometry.createGeometry(ellipse0);
|
|
var geometry1 = EllipseGeometry.createGeometry(ellipse1);
|
|
var geometry2 = EllipseGeometry.createGeometry(ellipse2);
|
|
var geometry3 = EllipseGeometry.createGeometry(ellipse3);
|
|
|
|
expect(geometry0).toBeUndefined();
|
|
expect(geometry1).toBeUndefined();
|
|
expect(geometry2).toBeUndefined();
|
|
expect(geometry3).toBeUndefined();
|
|
});
|
|
|
|
it('createShadowVolume uses properties from geometry', function() {
|
|
var m = new EllipseGeometry({
|
|
center : Cartesian3.fromDegrees(-75.59777, 40.03883),
|
|
semiMajorAxis : 3000.0,
|
|
semiMinorAxis : 1500.0,
|
|
ellipsoid : Ellipsoid.WGS84,
|
|
rotation : CesiumMath.PI_OVER_TWO,
|
|
stRotation : CesiumMath.PI_OVER_FOUR,
|
|
granularity : 10000,
|
|
extrudedHeight : 0,
|
|
height : 100,
|
|
vertexFormat : VertexFormat.ALL
|
|
});
|
|
|
|
var minHeightFunc = function() {
|
|
return 100;
|
|
};
|
|
|
|
var maxHeightFunc = function() {
|
|
return 1000;
|
|
};
|
|
|
|
var sv = EllipseGeometry.createShadowVolume(m, minHeightFunc, maxHeightFunc);
|
|
|
|
expect(sv._center.equals(m._center)).toBe(true);
|
|
expect(sv._semiMajorAxis).toBe(m._semiMajorAxis);
|
|
expect(sv._semiMinorAxis).toBe(m._semiMinorAxis);
|
|
expect(sv._ellipsoid.equals(m._ellipsoid)).toBe(true);
|
|
expect(sv._rotation).toBe(m._rotation);
|
|
expect(sv._stRotation).toBe(m._stRotation);
|
|
expect(sv._granularity).toBe(m._granularity);
|
|
expect(sv._extrudedHeight).toBe(minHeightFunc());
|
|
expect(sv._height).toBe(maxHeightFunc());
|
|
|
|
expect(sv._vertexFormat.bitangent).toBe(VertexFormat.POSITION_ONLY.bitangent);
|
|
expect(sv._vertexFormat.color).toBe(VertexFormat.POSITION_ONLY.color);
|
|
expect(sv._vertexFormat.normal).toBe(VertexFormat.POSITION_ONLY.normal);
|
|
expect(sv._vertexFormat.position).toBe(VertexFormat.POSITION_ONLY.position);
|
|
expect(sv._vertexFormat.st).toBe(VertexFormat.POSITION_ONLY.st);
|
|
expect(sv._vertexFormat.tangent).toBe(VertexFormat.POSITION_ONLY.tangent);
|
|
});
|
|
|
|
it('computing rectangle property', function() {
|
|
var center = Cartesian3.fromDegrees(-75.59777, 40.03883);
|
|
var ellipse = new EllipseGeometry({
|
|
center : center,
|
|
semiMajorAxis : 2000.0,
|
|
semiMinorAxis : 1000.0
|
|
});
|
|
|
|
var r = ellipse.rectangle;
|
|
expect(r.north).toEqualEpsilon(0.6989665987920752, CesiumMath.EPSILON7);
|
|
expect(r.south).toEqualEpsilon(0.6986522252554146, CesiumMath.EPSILON7);
|
|
expect(r.east).toEqualEpsilon(-1.3190209903056758, CesiumMath.EPSILON7);
|
|
expect(r.west).toEqualEpsilon(-1.3198389970251112, CesiumMath.EPSILON7);
|
|
|
|
// Polar ellipse
|
|
center = Cartesian3.fromDegrees(0.0, 90);
|
|
ellipse = new EllipseGeometry({
|
|
center : center,
|
|
semiMajorAxis : 2000.0,
|
|
semiMinorAxis : 1000.0
|
|
});
|
|
|
|
r = ellipse.rectangle;
|
|
expect(r.north).toEqualEpsilon(CesiumMath.PI_OVER_TWO - CesiumMath.EPSILON7, CesiumMath.EPSILON7);
|
|
expect(r.south).toEqualEpsilon(1.570483806950967, CesiumMath.EPSILON7);
|
|
expect(r.east).toEqualEpsilon(CesiumMath.PI, CesiumMath.EPSILON7);
|
|
expect(r.west).toEqualEpsilon(-CesiumMath.PI, CesiumMath.EPSILON7);
|
|
});
|
|
|
|
it('computeRectangle', function() {
|
|
var options = {
|
|
center : Cartesian3.fromDegrees(-30, 33),
|
|
semiMajorAxis : 2000.0,
|
|
semiMinorAxis : 1000.0,
|
|
rotation: CesiumMath.PI_OVER_TWO,
|
|
granularity: 0.5,
|
|
ellipsoid: Ellipsoid.UNIT_SPHERE
|
|
};
|
|
var geometry = new EllipseGeometry(options);
|
|
|
|
var expected = geometry.rectangle;
|
|
var result = EllipseGeometry.computeRectangle(options);
|
|
|
|
expect(result).toEqual(expected);
|
|
});
|
|
|
|
it('computeRectangle with result parameter', function() {
|
|
var options = {
|
|
center : Cartesian3.fromDegrees(30, -33),
|
|
semiMajorAxis : 500.0,
|
|
semiMinorAxis : 200.0
|
|
};
|
|
var geometry = new EllipseGeometry(options);
|
|
|
|
var result = new Rectangle();
|
|
var expected = geometry.rectangle;
|
|
var returned = EllipseGeometry.computeRectangle(options, result);
|
|
|
|
expect(returned).toEqual(expected);
|
|
expect(returned).toBe(result);
|
|
});
|
|
|
|
it('computing textureCoordinateRotationPoints property', function() {
|
|
var center = Cartesian3.fromDegrees(0, 0);
|
|
var ellipse = new EllipseGeometry({
|
|
center : center,
|
|
semiMajorAxis : 2000.0,
|
|
semiMinorAxis : 1000.0,
|
|
stRotation : CesiumMath.toRadians(90)
|
|
});
|
|
|
|
// 90 degree rotation means (0, 1) should be the new min and (1, 1) (0, 0) are extents
|
|
var textureCoordinateRotationPoints = ellipse.textureCoordinateRotationPoints;
|
|
expect(textureCoordinateRotationPoints.length).toEqual(6);
|
|
expect(textureCoordinateRotationPoints[0]).toEqualEpsilon(0, CesiumMath.EPSILON7);
|
|
expect(textureCoordinateRotationPoints[1]).toEqualEpsilon(1, CesiumMath.EPSILON7);
|
|
expect(textureCoordinateRotationPoints[2]).toEqualEpsilon(1, CesiumMath.EPSILON7);
|
|
expect(textureCoordinateRotationPoints[3]).toEqualEpsilon(1, CesiumMath.EPSILON7);
|
|
expect(textureCoordinateRotationPoints[4]).toEqualEpsilon(0, CesiumMath.EPSILON7);
|
|
expect(textureCoordinateRotationPoints[5]).toEqualEpsilon(0, CesiumMath.EPSILON7);
|
|
|
|
ellipse = new EllipseGeometry({
|
|
center : center,
|
|
semiMajorAxis : 2000.0,
|
|
semiMinorAxis : 1000.0,
|
|
stRotation : CesiumMath.toRadians(0)
|
|
});
|
|
|
|
textureCoordinateRotationPoints = ellipse.textureCoordinateRotationPoints;
|
|
expect(textureCoordinateRotationPoints.length).toEqual(6);
|
|
expect(textureCoordinateRotationPoints[0]).toEqualEpsilon(0, CesiumMath.EPSILON7);
|
|
expect(textureCoordinateRotationPoints[1]).toEqualEpsilon(0, CesiumMath.EPSILON7);
|
|
expect(textureCoordinateRotationPoints[2]).toEqualEpsilon(0, CesiumMath.EPSILON7);
|
|
expect(textureCoordinateRotationPoints[3]).toEqualEpsilon(1, CesiumMath.EPSILON7);
|
|
expect(textureCoordinateRotationPoints[4]).toEqualEpsilon(1, CesiumMath.EPSILON7);
|
|
expect(textureCoordinateRotationPoints[5]).toEqualEpsilon(0, CesiumMath.EPSILON7);
|
|
});
|
|
|
|
var center = Cartesian3.fromDegrees(0,0);
|
|
var ellipsoid = Ellipsoid.WGS84;
|
|
var packableInstance = new EllipseGeometry({
|
|
vertexFormat : VertexFormat.POSITION_AND_ST,
|
|
ellipsoid : ellipsoid,
|
|
center : center,
|
|
granularity : 0.1,
|
|
semiMajorAxis : 1.0,
|
|
semiMinorAxis : 1.0,
|
|
stRotation : CesiumMath.PI_OVER_TWO
|
|
});
|
|
var packedInstance = [center.x, center.y, center.z, ellipsoid.radii.x, ellipsoid.radii.y, ellipsoid.radii.z, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, CesiumMath.PI_OVER_TWO, 0.0, 0.1, 0.0, 0.0, -1];
|
|
createPackableSpecs(EllipseGeometry, packableInstance, packedInstance);
|
|
|
|
});
|