You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
144 lines
4.9 KiB
144 lines
4.9 KiB
define([
|
|
'./when-229515d6',
|
|
'./Matrix2-f2da41d4',
|
|
'./arrayRemoveDuplicates-bb548aa3',
|
|
'./BoundingRectangle-18e42324',
|
|
'./Transforms-7cd3197b',
|
|
'./ComponentDatatype-17b06483',
|
|
'./PolylineVolumeGeometryLibrary-4af6d4dc',
|
|
'./RuntimeError-ffe03243',
|
|
'./GeometryAttribute-80036e07',
|
|
'./GeometryAttributes-b253752a',
|
|
'./IndexDatatype-b10faa0b',
|
|
'./PolygonPipeline-5582b1ec',
|
|
'./combine-8ce3f24b',
|
|
'./WebGLConstants-4e26b85a',
|
|
'./EllipsoidTangentPlane-b27cd2f7',
|
|
'./AxisAlignedBoundingBox-1feb0c48',
|
|
'./IntersectionTests-1b8a3cb9',
|
|
'./Plane-0421a8be',
|
|
'./PolylinePipeline-a3ba6f24',
|
|
'./EllipsoidGeodesic-43ba18de',
|
|
'./EllipsoidRhumbLine-afd6cd20',
|
|
], function (e, i, n, a, t, r, o, l, s, p, d, u, c, y, g, h, f, m, b, v, E) {
|
|
'use strict';
|
|
function P(n) {
|
|
var a = (n = e.defaultValue(n, e.defaultValue.EMPTY_OBJECT)).polylinePositions,
|
|
t = n.shapePositions;
|
|
(this._positions = a),
|
|
(this._shape = t),
|
|
(this._ellipsoid = i.Ellipsoid.clone(e.defaultValue(n.ellipsoid, i.Ellipsoid.WGS84))),
|
|
(this._cornerType = e.defaultValue(n.cornerType, o.CornerType.ROUNDED)),
|
|
(this._granularity = e.defaultValue(n.granularity, r.CesiumMath.RADIANS_PER_DEGREE)),
|
|
(this._workerName = 'createPolylineVolumeOutlineGeometry');
|
|
var l = 1 + a.length * i.Cartesian3.packedLength;
|
|
(l += 1 + t.length * i.Cartesian2.packedLength),
|
|
(this.packedLength = l + i.Ellipsoid.packedLength + 2);
|
|
}
|
|
P.pack = function (n, a, t) {
|
|
var r;
|
|
t = e.defaultValue(t, 0);
|
|
var o = n._positions,
|
|
l = o.length;
|
|
for (a[t++] = l, r = 0; r < l; ++r, t += i.Cartesian3.packedLength)
|
|
i.Cartesian3.pack(o[r], a, t);
|
|
var s = n._shape;
|
|
for (l = s.length, a[t++] = l, r = 0; r < l; ++r, t += i.Cartesian2.packedLength)
|
|
i.Cartesian2.pack(s[r], a, t);
|
|
return (
|
|
i.Ellipsoid.pack(n._ellipsoid, a, t),
|
|
(t += i.Ellipsoid.packedLength),
|
|
(a[t++] = n._cornerType),
|
|
(a[t] = n._granularity),
|
|
a
|
|
);
|
|
};
|
|
var _ = i.Ellipsoid.clone(i.Ellipsoid.UNIT_SPHERE),
|
|
k = {
|
|
polylinePositions: void 0,
|
|
shapePositions: void 0,
|
|
ellipsoid: _,
|
|
height: void 0,
|
|
cornerType: void 0,
|
|
granularity: void 0,
|
|
};
|
|
P.unpack = function (n, a, t) {
|
|
var r;
|
|
a = e.defaultValue(a, 0);
|
|
var o = n[a++],
|
|
l = new Array(o);
|
|
for (r = 0; r < o; ++r, a += i.Cartesian3.packedLength) l[r] = i.Cartesian3.unpack(n, a);
|
|
o = n[a++];
|
|
var s = new Array(o);
|
|
for (r = 0; r < o; ++r, a += i.Cartesian2.packedLength) s[r] = i.Cartesian2.unpack(n, a);
|
|
var p = i.Ellipsoid.unpack(n, a, _);
|
|
a += i.Ellipsoid.packedLength;
|
|
var d = n[a++],
|
|
u = n[a];
|
|
return e.defined(t)
|
|
? ((t._positions = l),
|
|
(t._shape = s),
|
|
(t._ellipsoid = i.Ellipsoid.clone(p, t._ellipsoid)),
|
|
(t._cornerType = d),
|
|
(t._granularity = u),
|
|
t)
|
|
: ((k.polylinePositions = l),
|
|
(k.shapePositions = s),
|
|
(k.cornerType = d),
|
|
(k.granularity = u),
|
|
new P(k));
|
|
};
|
|
var C = new a.BoundingRectangle();
|
|
return (
|
|
(P.createGeometry = function (e) {
|
|
var l = e._positions,
|
|
c = n.arrayRemoveDuplicates(l, i.Cartesian3.equalsEpsilon),
|
|
y = e._shape;
|
|
if (
|
|
((y = o.PolylineVolumeGeometryLibrary.removeDuplicatesFromShape(y)),
|
|
!(c.length < 2 || y.length < 3))
|
|
) {
|
|
u.PolygonPipeline.computeWindingOrder2D(y) === u.WindingOrder.CLOCKWISE && y.reverse();
|
|
var g = a.BoundingRectangle.fromPoints(y, C);
|
|
return (function (e, i) {
|
|
var n = new p.GeometryAttributes();
|
|
n.position = new s.GeometryAttribute({
|
|
componentDatatype: r.ComponentDatatype.DOUBLE,
|
|
componentsPerAttribute: 3,
|
|
values: e,
|
|
});
|
|
var a,
|
|
o,
|
|
l = i.length,
|
|
u = n.position.values.length / 3,
|
|
c = e.length / 3 / l,
|
|
y = d.IndexDatatype.createTypedArray(u, 2 * l * (c + 1)),
|
|
g = 0,
|
|
h = (a = 0) * l;
|
|
for (o = 0; o < l - 1; o++) (y[g++] = o + h), (y[g++] = o + h + 1);
|
|
for (y[g++] = l - 1 + h, y[g++] = h, h = (a = c - 1) * l, o = 0; o < l - 1; o++)
|
|
(y[g++] = o + h), (y[g++] = o + h + 1);
|
|
for (y[g++] = l - 1 + h, y[g++] = h, a = 0; a < c - 1; a++) {
|
|
var f = l * a,
|
|
m = f + l;
|
|
for (o = 0; o < l; o++) (y[g++] = o + f), (y[g++] = o + m);
|
|
}
|
|
return new s.Geometry({
|
|
attributes: n,
|
|
indices: d.IndexDatatype.createTypedArray(u, y),
|
|
boundingSphere: t.BoundingSphere.fromVertices(e),
|
|
primitiveType: s.PrimitiveType.LINES,
|
|
});
|
|
})(o.PolylineVolumeGeometryLibrary.computePositions(c, y, g, e, !1), y);
|
|
}
|
|
}),
|
|
function (n, a) {
|
|
return (
|
|
e.defined(a) && (n = P.unpack(n, a)),
|
|
(n._ellipsoid = i.Ellipsoid.clone(n._ellipsoid)),
|
|
P.createGeometry(n)
|
|
);
|
|
}
|
|
);
|
|
});
|