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.
478 lines
15 KiB
478 lines
15 KiB
define([
|
|
'exports',
|
|
'./Transforms-7cd3197b',
|
|
'./ComponentDatatype-17b06483',
|
|
'./when-229515d6',
|
|
'./RuntimeError-ffe03243',
|
|
'./Matrix2-f2da41d4',
|
|
'./GeometryAttribute-80036e07',
|
|
'./GeometryAttributes-b253752a',
|
|
'./GeometryPipeline-5b3fba53',
|
|
'./IndexDatatype-b10faa0b',
|
|
'./WebMercatorProjection-d69cec15',
|
|
], function (e, t, r, n, i, o, a, s, d, p, u) {
|
|
'use strict';
|
|
function f(e, t, r) {
|
|
(e = n.defaultValue(e, 0)),
|
|
(t = n.defaultValue(t, 0)),
|
|
(r = n.defaultValue(r, 0)),
|
|
(this.value = new Float32Array([e, t, r]));
|
|
}
|
|
function c(e, t) {
|
|
var n = e.attributes,
|
|
i = n.position,
|
|
o = i.values.length / i.componentsPerAttribute;
|
|
n.batchId = new a.GeometryAttribute({
|
|
componentDatatype: r.ComponentDatatype.FLOAT,
|
|
componentsPerAttribute: 1,
|
|
values: new Float32Array(o),
|
|
});
|
|
for (var s = n.batchId.values, d = 0; d < o; ++d) s[d] = t;
|
|
}
|
|
function m(e) {
|
|
var i,
|
|
a,
|
|
s = e.instances,
|
|
p = e.projection,
|
|
u = e.elementIndexUintSupported,
|
|
f = e.scene3DOnly,
|
|
m = e.vertexCacheOptimize,
|
|
l = e.compressVertices,
|
|
h = e.modelMatrix,
|
|
g = s.length;
|
|
for (i = 0; i < g; ++i)
|
|
if (n.defined(s[i].geometry)) {
|
|
s[i].geometry.primitiveType;
|
|
break;
|
|
}
|
|
if (
|
|
((function (e, t, r) {
|
|
var i,
|
|
a = !r,
|
|
s = e.length;
|
|
if (!a && s > 1) {
|
|
var p = e[0].modelMatrix;
|
|
for (i = 1; i < s; ++i)
|
|
if (!o.Matrix4.equals(p, e[i].modelMatrix)) {
|
|
a = !0;
|
|
break;
|
|
}
|
|
}
|
|
if (a)
|
|
for (i = 0; i < s; ++i)
|
|
n.defined(e[i].geometry) && d.GeometryPipeline.transformToWorldCoordinates(e[i]);
|
|
else o.Matrix4.multiplyTransformation(t, e[0].modelMatrix, t);
|
|
})(s, h, f),
|
|
!f)
|
|
)
|
|
for (i = 0; i < g; ++i) n.defined(s[i].geometry) && d.GeometryPipeline.splitLongitude(s[i]);
|
|
if (
|
|
((function (e) {
|
|
for (var t = e.length, r = 0; r < t; ++r) {
|
|
var i = e[r];
|
|
n.defined(i.geometry)
|
|
? c(i.geometry, r)
|
|
: n.defined(i.westHemisphereGeometry) &&
|
|
n.defined(i.eastHemisphereGeometry) &&
|
|
(c(i.westHemisphereGeometry, r), c(i.eastHemisphereGeometry, r));
|
|
}
|
|
})(s),
|
|
m)
|
|
)
|
|
for (i = 0; i < g; ++i) {
|
|
var y = s[i];
|
|
n.defined(y.geometry)
|
|
? (d.GeometryPipeline.reorderForPostVertexCache(y.geometry),
|
|
d.GeometryPipeline.reorderForPreVertexCache(y.geometry))
|
|
: n.defined(y.westHemisphereGeometry) &&
|
|
n.defined(y.eastHemisphereGeometry) &&
|
|
(d.GeometryPipeline.reorderForPostVertexCache(y.westHemisphereGeometry),
|
|
d.GeometryPipeline.reorderForPreVertexCache(y.westHemisphereGeometry),
|
|
d.GeometryPipeline.reorderForPostVertexCache(y.eastHemisphereGeometry),
|
|
d.GeometryPipeline.reorderForPreVertexCache(y.eastHemisphereGeometry));
|
|
}
|
|
var b = d.GeometryPipeline.combineInstances(s);
|
|
for (g = b.length, i = 0; i < g; ++i) {
|
|
var v,
|
|
x = (a = b[i]).attributes;
|
|
if (f)
|
|
for (v in x)
|
|
x.hasOwnProperty(v) &&
|
|
x[v].componentDatatype === r.ComponentDatatype.DOUBLE &&
|
|
d.GeometryPipeline.encodeAttribute(a, v, v + '3DHigh', v + '3DLow');
|
|
else
|
|
for (v in x)
|
|
if (x.hasOwnProperty(v) && x[v].componentDatatype === r.ComponentDatatype.DOUBLE) {
|
|
var G = v + '3D',
|
|
S = v + '2D';
|
|
d.GeometryPipeline.projectTo2D(a, v, G, S, p),
|
|
n.defined(a.boundingSphere) &&
|
|
'position' === v &&
|
|
(a.boundingSphereCV = t.BoundingSphere.fromVertices(
|
|
a.attributes.position2D.values
|
|
)),
|
|
d.GeometryPipeline.encodeAttribute(a, G, G + 'High', G + 'Low'),
|
|
d.GeometryPipeline.encodeAttribute(a, S, S + 'High', S + 'Low');
|
|
}
|
|
l && d.GeometryPipeline.compressVertices(a);
|
|
}
|
|
if (!u) {
|
|
var P = [];
|
|
for (g = b.length, i = 0; i < g; ++i)
|
|
(a = b[i]), (P = P.concat(d.GeometryPipeline.fitToUnsignedShortIndices(a)));
|
|
b = P;
|
|
}
|
|
return b;
|
|
}
|
|
function l(e, t, r, i) {
|
|
var o,
|
|
a,
|
|
s,
|
|
d = i.length - 1;
|
|
if (d >= 0) {
|
|
var p = i[d];
|
|
(o = p.offset + p.count), (a = r[(s = p.index)].indices.length);
|
|
} else (o = 0), (a = r[(s = 0)].indices.length);
|
|
for (var u = e.length, f = 0; f < u; ++f) {
|
|
var c = e[f][t];
|
|
if (n.defined(c)) {
|
|
var m = c.indices.length;
|
|
o + m > a && ((o = 0), (a = r[++s].indices.length)),
|
|
i.push({ index: s, offset: o, count: m }),
|
|
(o += m);
|
|
}
|
|
}
|
|
}
|
|
Object.defineProperties(f.prototype, {
|
|
componentDatatype: {
|
|
get: function () {
|
|
return r.ComponentDatatype.FLOAT;
|
|
},
|
|
},
|
|
componentsPerAttribute: {
|
|
get: function () {
|
|
return 3;
|
|
},
|
|
},
|
|
normalize: {
|
|
get: function () {
|
|
return !1;
|
|
},
|
|
},
|
|
}),
|
|
(f.fromCartesian3 = function (e) {
|
|
return new f(e.x, e.y, e.z);
|
|
}),
|
|
(f.toValue = function (e, t) {
|
|
return (
|
|
n.defined(t) || (t = new Float32Array([e.x, e.y, e.z])),
|
|
(t[0] = e.x),
|
|
(t[1] = e.y),
|
|
(t[2] = e.z),
|
|
t
|
|
);
|
|
});
|
|
var h = {};
|
|
function g(e, t) {
|
|
var r = e.attributes;
|
|
for (var i in r)
|
|
if (r.hasOwnProperty(i)) {
|
|
var o = r[i];
|
|
n.defined(o) && n.defined(o.values) && t.push(o.values.buffer);
|
|
}
|
|
n.defined(e.indices) && t.push(e.indices.buffer);
|
|
}
|
|
function y(e, t) {
|
|
var r = e.length,
|
|
i = new Float64Array(1 + 19 * r),
|
|
a = 0;
|
|
i[a++] = r;
|
|
for (var s = 0; s < r; s++) {
|
|
var d = e[s];
|
|
if (
|
|
(o.Matrix4.pack(d.modelMatrix, i, a),
|
|
(a += o.Matrix4.packedLength),
|
|
n.defined(d.attributes) && n.defined(d.attributes.offset))
|
|
) {
|
|
var p = d.attributes.offset.value;
|
|
(i[a] = p[0]), (i[a + 1] = p[1]), (i[a + 2] = p[2]);
|
|
}
|
|
a += 3;
|
|
}
|
|
return t.push(i.buffer), i;
|
|
}
|
|
function b(e) {
|
|
var r = e.length,
|
|
i = 1 + (t.BoundingSphere.packedLength + 1) * r,
|
|
o = new Float32Array(i),
|
|
a = 0;
|
|
o[a++] = r;
|
|
for (var s = 0; s < r; ++s) {
|
|
var d = e[s];
|
|
n.defined(d) ? ((o[a++] = 1), t.BoundingSphere.pack(e[s], o, a)) : (o[a++] = 0),
|
|
(a += t.BoundingSphere.packedLength);
|
|
}
|
|
return o;
|
|
}
|
|
function v(e) {
|
|
for (var r = new Array(e[0]), n = 0, i = 1; i < e.length; )
|
|
1 === e[i++] && (r[n] = t.BoundingSphere.unpack(e, i)),
|
|
++n,
|
|
(i += t.BoundingSphere.packedLength);
|
|
return r;
|
|
}
|
|
(h.combineGeometry = function (e) {
|
|
var r,
|
|
i,
|
|
o,
|
|
a,
|
|
s = e.instances,
|
|
p = s.length,
|
|
u = !1;
|
|
p > 0 &&
|
|
((r = m(e)).length > 0 &&
|
|
((i = d.GeometryPipeline.createAttributeLocations(r[0])),
|
|
e.createPickOffsets &&
|
|
(o = (function (e, t) {
|
|
var r = [];
|
|
return (
|
|
l(e, 'geometry', t, r),
|
|
l(e, 'westHemisphereGeometry', t, r),
|
|
l(e, 'eastHemisphereGeometry', t, r),
|
|
r
|
|
);
|
|
})(s, r))),
|
|
n.defined(s[0].attributes) &&
|
|
n.defined(s[0].attributes.offset) &&
|
|
((a = new Array(p)), (u = !0)));
|
|
for (var f = new Array(p), c = new Array(p), h = 0; h < p; ++h) {
|
|
var g = s[h],
|
|
y = g.geometry;
|
|
n.defined(y) &&
|
|
((f[h] = y.boundingSphere),
|
|
(c[h] = y.boundingSphereCV),
|
|
u && (a[h] = g.geometry.offsetAttribute));
|
|
var b = g.eastHemisphereGeometry,
|
|
v = g.westHemisphereGeometry;
|
|
n.defined(b) &&
|
|
n.defined(v) &&
|
|
(n.defined(b.boundingSphere) &&
|
|
n.defined(v.boundingSphere) &&
|
|
(f[h] = t.BoundingSphere.union(b.boundingSphere, v.boundingSphere)),
|
|
n.defined(b.boundingSphereCV) &&
|
|
n.defined(v.boundingSphereCV) &&
|
|
(c[h] = t.BoundingSphere.union(b.boundingSphereCV, v.boundingSphereCV)));
|
|
}
|
|
return {
|
|
geometries: r,
|
|
modelMatrix: e.modelMatrix,
|
|
attributeLocations: i,
|
|
pickOffsets: o,
|
|
offsetInstanceExtend: a,
|
|
boundingSpheres: f,
|
|
boundingSpheresCV: c,
|
|
};
|
|
}),
|
|
(h.packCreateGeometryResults = function (e, r) {
|
|
var i = new Float64Array(
|
|
(function (e) {
|
|
for (var r = 1, i = e.length, o = 0; o < i; o++) {
|
|
var a = e[o];
|
|
if ((++r, n.defined(a))) {
|
|
var s = a.attributes;
|
|
for (var d in ((r +=
|
|
7 +
|
|
2 * t.BoundingSphere.packedLength +
|
|
(n.defined(a.indices) ? a.indices.length : 0)),
|
|
s))
|
|
s.hasOwnProperty(d) && n.defined(s[d]) && (r += 5 + s[d].values.length);
|
|
}
|
|
}
|
|
return r;
|
|
})(e)
|
|
),
|
|
o = [],
|
|
a = {},
|
|
s = e.length,
|
|
d = 0;
|
|
i[d++] = s;
|
|
for (var p = 0; p < s; p++) {
|
|
var u = e[p],
|
|
f = n.defined(u);
|
|
if (((i[d++] = f ? 1 : 0), f)) {
|
|
(i[d++] = u.primitiveType),
|
|
(i[d++] = u.geometryType),
|
|
(i[d++] = n.defaultValue(u.offsetAttribute, -1));
|
|
var c = n.defined(u.boundingSphere) ? 1 : 0;
|
|
(i[d++] = c),
|
|
c && t.BoundingSphere.pack(u.boundingSphere, i, d),
|
|
(d += t.BoundingSphere.packedLength);
|
|
var m = n.defined(u.boundingSphereCV) ? 1 : 0;
|
|
(i[d++] = m),
|
|
m && t.BoundingSphere.pack(u.boundingSphereCV, i, d),
|
|
(d += t.BoundingSphere.packedLength);
|
|
var l = u.attributes,
|
|
h = [];
|
|
for (var g in l)
|
|
l.hasOwnProperty(g) &&
|
|
n.defined(l[g]) &&
|
|
(h.push(g), n.defined(a[g]) || ((a[g] = o.length), o.push(g)));
|
|
i[d++] = h.length;
|
|
for (var y = 0; y < h.length; y++) {
|
|
var b = h[y],
|
|
v = l[b];
|
|
(i[d++] = a[b]),
|
|
(i[d++] = v.componentDatatype),
|
|
(i[d++] = v.componentsPerAttribute),
|
|
(i[d++] = v.normalize ? 1 : 0),
|
|
(i[d++] = v.values.length),
|
|
i.set(v.values, d),
|
|
(d += v.values.length);
|
|
}
|
|
var x = n.defined(u.indices) ? u.indices.length : 0;
|
|
(i[d++] = x), x > 0 && (i.set(u.indices, d), (d += x));
|
|
}
|
|
}
|
|
return r.push(i.buffer), { stringTable: o, packedData: i };
|
|
}),
|
|
(h.unpackCreateGeometryResults = function (e) {
|
|
for (
|
|
var n, i = e.stringTable, o = e.packedData, d = new Array(o[0]), u = 0, f = 1;
|
|
f < o.length;
|
|
|
|
) {
|
|
if (1 === o[f++]) {
|
|
var c,
|
|
m,
|
|
l,
|
|
h,
|
|
g,
|
|
y = o[f++],
|
|
b = o[f++],
|
|
v = o[f++];
|
|
-1 === v && (v = void 0),
|
|
1 === o[f++] && (c = t.BoundingSphere.unpack(o, f)),
|
|
(f += t.BoundingSphere.packedLength),
|
|
1 === o[f++] && (m = t.BoundingSphere.unpack(o, f)),
|
|
(f += t.BoundingSphere.packedLength);
|
|
var x,
|
|
G = new s.GeometryAttributes(),
|
|
S = o[f++];
|
|
for (n = 0; n < S; n++) {
|
|
var P = i[o[f++]],
|
|
k = o[f++];
|
|
g = o[f++];
|
|
var C = 0 !== o[f++];
|
|
(l = o[f++]), (h = r.ComponentDatatype.createTypedArray(k, l));
|
|
for (var w = 0; w < l; w++) h[w] = o[f++];
|
|
G[P] = new a.GeometryAttribute({
|
|
componentDatatype: k,
|
|
componentsPerAttribute: g,
|
|
normalize: C,
|
|
values: h,
|
|
});
|
|
}
|
|
if ((l = o[f++]) > 0) {
|
|
var A = h.length / g;
|
|
for (x = p.IndexDatatype.createTypedArray(A, l), n = 0; n < l; n++) x[n] = o[f++];
|
|
}
|
|
d[u++] = new a.Geometry({
|
|
primitiveType: y,
|
|
geometryType: b,
|
|
boundingSphere: c,
|
|
boundingSphereCV: m,
|
|
indices: x,
|
|
attributes: G,
|
|
offsetAttribute: v,
|
|
});
|
|
} else d[u++] = void 0;
|
|
}
|
|
return d;
|
|
}),
|
|
(h.packCombineGeometryParameters = function (e, r) {
|
|
for (var n = e.createGeometryResults, i = n.length, o = 0; o < i; o++)
|
|
r.push(n[o].packedData.buffer);
|
|
return {
|
|
createGeometryResults: e.createGeometryResults,
|
|
packedInstances: y(e.instances, r),
|
|
ellipsoid: e.ellipsoid,
|
|
isGeographic: e.projection instanceof t.GeographicProjection,
|
|
elementIndexUintSupported: e.elementIndexUintSupported,
|
|
scene3DOnly: e.scene3DOnly,
|
|
vertexCacheOptimize: e.vertexCacheOptimize,
|
|
compressVertices: e.compressVertices,
|
|
modelMatrix: e.modelMatrix,
|
|
createPickOffsets: e.createPickOffsets,
|
|
};
|
|
}),
|
|
(h.unpackCombineGeometryParameters = function (e) {
|
|
for (
|
|
var r = (function (e) {
|
|
for (var t = e, r = new Array(t[0]), i = 0, a = 1; a < t.length; ) {
|
|
var s,
|
|
d = o.Matrix4.unpack(t, a);
|
|
(a += o.Matrix4.packedLength),
|
|
n.defined(t[a]) && (s = { offset: new f(t[a], t[a + 1], t[a + 2]) }),
|
|
(a += 3),
|
|
(r[i++] = { modelMatrix: d, attributes: s });
|
|
}
|
|
return r;
|
|
})(e.packedInstances),
|
|
i = e.createGeometryResults,
|
|
a = i.length,
|
|
s = 0,
|
|
d = 0;
|
|
d < a;
|
|
d++
|
|
)
|
|
for (var p = h.unpackCreateGeometryResults(i[d]), c = p.length, m = 0; m < c; m++) {
|
|
var l = p[m];
|
|
(r[s].geometry = l), ++s;
|
|
}
|
|
var g = o.Ellipsoid.clone(e.ellipsoid);
|
|
return {
|
|
instances: r,
|
|
ellipsoid: g,
|
|
projection: e.isGeographic ? new t.GeographicProjection(g) : new u.WebMercatorProjection(g),
|
|
elementIndexUintSupported: e.elementIndexUintSupported,
|
|
scene3DOnly: e.scene3DOnly,
|
|
vertexCacheOptimize: e.vertexCacheOptimize,
|
|
compressVertices: e.compressVertices,
|
|
modelMatrix: o.Matrix4.clone(e.modelMatrix),
|
|
createPickOffsets: e.createPickOffsets,
|
|
};
|
|
}),
|
|
(h.packCombineGeometryResults = function (e, t) {
|
|
n.defined(e.geometries) &&
|
|
(function (e, t) {
|
|
for (var r = e.length, n = 0; n < r; ++n) g(e[n], t);
|
|
})(e.geometries, t);
|
|
var r = b(e.boundingSpheres),
|
|
i = b(e.boundingSpheresCV);
|
|
return (
|
|
t.push(r.buffer, i.buffer),
|
|
{
|
|
geometries: e.geometries,
|
|
attributeLocations: e.attributeLocations,
|
|
modelMatrix: e.modelMatrix,
|
|
pickOffsets: e.pickOffsets,
|
|
offsetInstanceExtend: e.offsetInstanceExtend,
|
|
boundingSpheres: r,
|
|
boundingSpheresCV: i,
|
|
}
|
|
);
|
|
}),
|
|
(h.unpackCombineGeometryResults = function (e) {
|
|
return {
|
|
geometries: e.geometries,
|
|
attributeLocations: e.attributeLocations,
|
|
modelMatrix: e.modelMatrix,
|
|
pickOffsets: e.pickOffsets,
|
|
offsetInstanceExtend: e.offsetInstanceExtend,
|
|
boundingSpheres: v(e.boundingSpheres),
|
|
boundingSpheresCV: v(e.boundingSpheresCV),
|
|
};
|
|
}),
|
|
(e.PrimitivePipeline = h);
|
|
});
|