@vcmap/ui 5.0.0-rc.18 → 5.0.0-rc.20

package/dist/assets/cesium/Workers/createWallGeometry.js

@@ -1,25 +1,623 @@
-/**
- * @license
- * Cesium - https://github.com/CesiumGS/cesium
- * Version 1.97.1
- *
- * Copyright 2011-2022 Cesium Contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * Columbus View (Pat. Pend.)
- *
- * Portions licensed separately.
- * See https://github.com/CesiumGS/cesium/blob/main/LICENSE.md for full licensing details.
- */
-define(["./defaultValue-0c475b81","./Matrix2-eefef8eb","./Transforms-d2e5867e","./ComponentDatatype-0200bf8c","./GeometryAttribute-8458a8fd","./GeometryAttributes-ac0f8485","./IndexDatatype-e713bfd2","./VertexFormat-5ec0d9ff","./WallGeometryLibrary-1a33e416","./RuntimeError-5baf5c66","./_commonjsHelpers-bc29abbc","./combine-7533016d","./WebGLConstants-5b50ced1","./arrayRemoveDuplicates-f13aceb1","./PolylinePipeline-0f23dd84","./EllipsoidGeodesic-8bfefbff","./EllipsoidRhumbLine-03528f73","./IntersectionTests-eb4db8e0","./Plane-b0299683"],(function(e,t,n,i,a,o,r,s,l,m,u,c,p,d,f,y,g,h,b){"use strict";const C=new t.Cartesian3,x=new t.Cartesian3,A=new t.Cartesian3,_=new t.Cartesian3,E=new t.Cartesian3,w=new t.Cartesian3,F=new t.Cartesian3;function v(n){const a=(n=e.defaultValue(n,e.defaultValue.EMPTY_OBJECT)).positions,o=n.maximumHeights,r=n.minimumHeights,l=e.defaultValue(n.vertexFormat,s.VertexFormat.DEFAULT),m=e.defaultValue(n.granularity,i.CesiumMath.RADIANS_PER_DEGREE),u=e.defaultValue(n.ellipsoid,t.Ellipsoid.WGS84);this._positions=a,this._minimumHeights=r,this._maximumHeights=o,this._vertexFormat=s.VertexFormat.clone(l),this._granularity=m,this._ellipsoid=t.Ellipsoid.clone(u),this._workerName="createWallGeometry";let c=1+a.length*t.Cartesian3.packedLength+2;e.defined(r)&&(c+=r.length),e.defined(o)&&(c+=o.length),this.packedLength=c+t.Ellipsoid.packedLength+s.VertexFormat.packedLength+1}v.pack=function(n,i,a){let o;a=e.defaultValue(a,0);const r=n._positions;let l=r.length;for(i[a++]=l,o=0;o<l;++o,a+=t.Cartesian3.packedLength)t.Cartesian3.pack(r[o],i,a);const m=n._minimumHeights;if(l=e.defined(m)?m.length:0,i[a++]=l,e.defined(m))for(o=0;o<l;++o)i[a++]=m[o];const u=n._maximumHeights;if(l=e.defined(u)?u.length:0,i[a++]=l,e.defined(u))for(o=0;o<l;++o)i[a++]=u[o];return t.Ellipsoid.pack(n._ellipsoid,i,a),a+=t.Ellipsoid.packedLength,s.VertexFormat.pack(n._vertexFormat,i,a),i[a+=s.VertexFormat.packedLength]=n._granularity,i};const L=t.Ellipsoid.clone(t.Ellipsoid.UNIT_SPHERE),H=new s.VertexFormat,V={positions:void 0,minimumHeights:void 0,maximumHeights:void 0,ellipsoid:L,vertexFormat:H,granularity:void 0};return v.unpack=function(n,i,a){let o;i=e.defaultValue(i,0);let r=n[i++];const l=new Array(r);for(o=0;o<r;++o,i+=t.Cartesian3.packedLength)l[o]=t.Cartesian3.unpack(n,i);let m,u;if(r=n[i++],r>0)for(m=new Array(r),o=0;o<r;++o)m[o]=n[i++];if(r=n[i++],r>0)for(u=new Array(r),o=0;o<r;++o)u[o]=n[i++];const c=t.Ellipsoid.unpack(n,i,L);i+=t.Ellipsoid.packedLength;const p=s.VertexFormat.unpack(n,i,H),d=n[i+=s.VertexFormat.packedLength];return e.defined(a)?(a._positions=l,a._minimumHeights=m,a._maximumHeights=u,a._ellipsoid=t.Ellipsoid.clone(c,a._ellipsoid),a._vertexFormat=s.VertexFormat.clone(p,a._vertexFormat),a._granularity=d,a):(V.positions=l,V.minimumHeights=m,V.maximumHeights=u,V.granularity=d,new v(V))},v.fromConstantHeights=function(t){const n=(t=e.defaultValue(t,e.defaultValue.EMPTY_OBJECT)).positions;let i,a;const o=t.minimumHeight,r=t.maximumHeight,s=e.defined(o),l=e.defined(r);if(s||l){const e=n.length;i=s?new Array(e):void 0,a=l?new Array(e):void 0;for(let t=0;t<e;++t)s&&(i[t]=o),l&&(a[t]=r)}return new v({positions:n,maximumHeights:a,minimumHeights:i,ellipsoid:t.ellipsoid,vertexFormat:t.vertexFormat})},v.createGeometry=function(s){const m=s._positions,u=s._minimumHeights,c=s._maximumHeights,p=s._vertexFormat,d=s._granularity,f=s._ellipsoid,y=l.WallGeometryLibrary.computePositions(f,m,c,u,d,!0);if(!e.defined(y))return;const g=y.bottomPositions,h=y.topPositions,b=y.numCorners;let v=h.length,L=2*v;const H=p.position?new Float64Array(L):void 0,V=p.normal?new Float32Array(L):void 0,k=p.tangent?new Float32Array(L):void 0,G=p.bitangent?new Float32Array(L):void 0,D=p.st?new Float32Array(L/3*2):void 0;let P,T=0,z=0,O=0,R=0,S=0,I=F,N=w,M=E,W=!0;v/=3;let B=0;const U=1/(v-b-1);for(P=0;P<v;++P){const e=3*P,n=t.Cartesian3.fromArray(h,e,C),a=t.Cartesian3.fromArray(g,e,x);if(p.position&&(H[T++]=a.x,H[T++]=a.y,H[T++]=a.z,H[T++]=n.x,H[T++]=n.y,H[T++]=n.z),p.st&&(D[S++]=B,D[S++]=0,D[S++]=B,D[S++]=1),p.normal||p.tangent||p.bitangent){let a=t.Cartesian3.clone(t.Cartesian3.ZERO,_);const o=t.Cartesian3.subtract(n,f.geodeticSurfaceNormal(n,x),x);if(P+1<v&&(a=t.Cartesian3.fromArray(h,e+3,_)),W){const e=t.Cartesian3.subtract(a,n,A),i=t.Cartesian3.subtract(o,n,C);I=t.Cartesian3.normalize(t.Cartesian3.cross(i,e,I),I),W=!1}t.Cartesian3.equalsEpsilon(n,a,i.CesiumMath.EPSILON10)?W=!0:(B+=U,p.tangent&&(N=t.Cartesian3.normalize(t.Cartesian3.subtract(a,n,N),N)),p.bitangent&&(M=t.Cartesian3.normalize(t.Cartesian3.cross(I,N,M),M))),p.normal&&(V[z++]=I.x,V[z++]=I.y,V[z++]=I.z,V[z++]=I.x,V[z++]=I.y,V[z++]=I.z),p.tangent&&(k[R++]=N.x,k[R++]=N.y,k[R++]=N.z,k[R++]=N.x,k[R++]=N.y,k[R++]=N.z),p.bitangent&&(G[O++]=M.x,G[O++]=M.y,G[O++]=M.z,G[O++]=M.x,G[O++]=M.y,G[O++]=M.z)}}const q=new o.GeometryAttributes;p.position&&(q.position=new a.GeometryAttribute({componentDatatype:i.ComponentDatatype.DOUBLE,componentsPerAttribute:3,values:H})),p.normal&&(q.normal=new a.GeometryAttribute({componentDatatype:i.ComponentDatatype.FLOAT,componentsPerAttribute:3,values:V})),p.tangent&&(q.tangent=new a.GeometryAttribute({componentDatatype:i.ComponentDatatype.FLOAT,componentsPerAttribute:3,values:k})),p.bitangent&&(q.bitangent=new a.GeometryAttribute({componentDatatype:i.ComponentDatatype.FLOAT,componentsPerAttribute:3,values:G})),p.st&&(q.st=new a.GeometryAttribute({componentDatatype:i.ComponentDatatype.FLOAT,componentsPerAttribute:2,values:D}));const J=L/3;L-=6*(b+1);const Y=r.IndexDatatype.createTypedArray(J,L);let j=0;for(P=0;P<J-2;P+=2){const e=P,n=P+2,a=t.Cartesian3.fromArray(H,3*e,C),o=t.Cartesian3.fromArray(H,3*n,x);if(t.Cartesian3.equalsEpsilon(a,o,i.CesiumMath.EPSILON10))continue;const r=P+1,s=P+3;Y[j++]=r,Y[j++]=e,Y[j++]=s,Y[j++]=s,Y[j++]=e,Y[j++]=n}return new a.Geometry({attributes:q,indices:Y,primitiveType:a.PrimitiveType.TRIANGLES,boundingSphere:new n.BoundingSphere.fromVertices(H)})},function(n,i){return e.defined(i)&&(n=v.unpack(n,i)),n._ellipsoid=t.Ellipsoid.clone(n._ellipsoid),v.createGeometry(n)}}));
+define(['./defaultValue-0a909f67', './Matrix3-315394f6', './Transforms-40229881', './ComponentDatatype-f7b11d02', './Check-666ab1a0', './GeometryAttribute-7d6f1732', './GeometryAttributes-f06a2792', './IndexDatatype-a55ceaa1', './Math-2dbd6b93', './VertexFormat-6b480673', './WallGeometryLibrary-919eed92', './Matrix2-13178034', './RuntimeError-06c93819', './combine-ca22a614', './WebGLConstants-a8cc3e8c', './arrayRemoveDuplicates-c2038105', './PolylinePipeline-32f36d2a', './EllipsoidGeodesic-98c62a56', './EllipsoidRhumbLine-19756602', './IntersectionTests-f6e6bd8a', './Plane-900aa728'], (function (defaultValue, Matrix3, Transforms, ComponentDatatype, Check, GeometryAttribute, GeometryAttributes, IndexDatatype, Math, VertexFormat, WallGeometryLibrary, Matrix2, RuntimeError, combine, WebGLConstants, arrayRemoveDuplicates, PolylinePipeline, EllipsoidGeodesic, EllipsoidRhumbLine, IntersectionTests, Plane) { 'use strict';
+
+  const scratchCartesian3Position1 = new Matrix3.Cartesian3();
+  const scratchCartesian3Position2 = new Matrix3.Cartesian3();
+  const scratchCartesian3Position4 = new Matrix3.Cartesian3();
+  const scratchCartesian3Position5 = new Matrix3.Cartesian3();
+  const scratchBitangent = new Matrix3.Cartesian3();
+  const scratchTangent = new Matrix3.Cartesian3();
+  const scratchNormal = new Matrix3.Cartesian3();
+
+  /**
+   * A description of a wall, which is similar to a KML line string. A wall is defined by a series of points,
+   * which extrude down to the ground. Optionally, they can extrude downwards to a specified height.
+   *
+   * @alias WallGeometry
+   * @constructor
+   *
+   * @param {Object} options Object with the following properties:
+   * @param {Cartesian3[]} options.positions An array of Cartesian objects, which are the points of the wall.
+   * @param {Number} [options.granularity=CesiumMath.RADIANS_PER_DEGREE] The distance, in radians, between each latitude and longitude. Determines the number of positions in the buffer.
+   * @param {Number[]} [options.maximumHeights] An array parallel to <code>positions</code> that give the maximum height of the
+   *        wall at <code>positions</code>. If undefined, the height of each position in used.
+   * @param {Number[]} [options.minimumHeights] An array parallel to <code>positions</code> that give the minimum height of the
+   *        wall at <code>positions</code>. If undefined, the height at each position is 0.0.
+   * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid for coordinate manipulation
+   * @param {VertexFormat} [options.vertexFormat=VertexFormat.DEFAULT] The vertex attributes to be computed.
+   *
+   * @exception {DeveloperError} positions length must be greater than or equal to 2.
+   * @exception {DeveloperError} positions and maximumHeights must have the same length.
+   * @exception {DeveloperError} positions and minimumHeights must have the same length.
+   *
+   * @see WallGeometry#createGeometry
+   * @see WallGeometry#fromConstantHeight
+   *
+   * @demo {@link https://sandcastle.cesium.com/index.html?src=Wall.html|Cesium Sandcastle Wall Demo}
+   *
+   * @example
+   * // create a wall that spans from ground level to 10000 meters
+   * const wall = new Cesium.WallGeometry({
+   *   positions : Cesium.Cartesian3.fromDegreesArrayHeights([
+   *     19.0, 47.0, 10000.0,
+   *     19.0, 48.0, 10000.0,
+   *     20.0, 48.0, 10000.0,
+   *     20.0, 47.0, 10000.0,
+   *     19.0, 47.0, 10000.0
+   *   ])
+   * });
+   * const geometry = Cesium.WallGeometry.createGeometry(wall);
+   */
+  function WallGeometry(options) {
+    options = defaultValue.defaultValue(options, defaultValue.defaultValue.EMPTY_OBJECT);
+
+    const wallPositions = options.positions;
+    const maximumHeights = options.maximumHeights;
+    const minimumHeights = options.minimumHeights;
+
+    //>>includeStart('debug', pragmas.debug);
+    if (!defaultValue.defined(wallPositions)) {
+      throw new Check.DeveloperError("options.positions is required.");
+    }
+    if (
+      defaultValue.defined(maximumHeights) &&
+      maximumHeights.length !== wallPositions.length
+    ) {
+      throw new Check.DeveloperError(
+        "options.positions and options.maximumHeights must have the same length."
+      );
+    }
+    if (
+      defaultValue.defined(minimumHeights) &&
+      minimumHeights.length !== wallPositions.length
+    ) {
+      throw new Check.DeveloperError(
+        "options.positions and options.minimumHeights must have the same length."
+      );
+    }
+    //>>includeEnd('debug');
+
+    const vertexFormat = defaultValue.defaultValue(options.vertexFormat, VertexFormat.VertexFormat.DEFAULT);
+    const granularity = defaultValue.defaultValue(
+      options.granularity,
+      Math.CesiumMath.RADIANS_PER_DEGREE
+    );
+    const ellipsoid = defaultValue.defaultValue(options.ellipsoid, Matrix3.Ellipsoid.WGS84);
+
+    this._positions = wallPositions;
+    this._minimumHeights = minimumHeights;
+    this._maximumHeights = maximumHeights;
+    this._vertexFormat = VertexFormat.VertexFormat.clone(vertexFormat);
+    this._granularity = granularity;
+    this._ellipsoid = Matrix3.Ellipsoid.clone(ellipsoid);
+    this._workerName = "createWallGeometry";
+
+    let numComponents = 1 + wallPositions.length * Matrix3.Cartesian3.packedLength + 2;
+    if (defaultValue.defined(minimumHeights)) {
+      numComponents += minimumHeights.length;
+    }
+    if (defaultValue.defined(maximumHeights)) {
+      numComponents += maximumHeights.length;
+    }
+
+    /**
+     * The number of elements used to pack the object into an array.
+     * @type {Number}
+     */
+    this.packedLength =
+      numComponents + Matrix3.Ellipsoid.packedLength + VertexFormat.VertexFormat.packedLength + 1;
+  }
+
+  /**
+   * Stores the provided instance into the provided array.
+   *
+   * @param {WallGeometry} value The value to pack.
+   * @param {Number[]} array The array to pack into.
+   * @param {Number} [startingIndex=0] The index into the array at which to start packing the elements.
+   *
+   * @returns {Number[]} The array that was packed into
+   */
+  WallGeometry.pack = function (value, array, startingIndex) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defaultValue.defined(value)) {
+      throw new Check.DeveloperError("value is required");
+    }
+    if (!defaultValue.defined(array)) {
+      throw new Check.DeveloperError("array is required");
+    }
+    //>>includeEnd('debug');
+
+    startingIndex = defaultValue.defaultValue(startingIndex, 0);
+
+    let i;
+
+    const positions = value._positions;
+    let length = positions.length;
+    array[startingIndex++] = length;
+
+    for (i = 0; i < length; ++i, startingIndex += Matrix3.Cartesian3.packedLength) {
+      Matrix3.Cartesian3.pack(positions[i], array, startingIndex);
+    }
+
+    const minimumHeights = value._minimumHeights;
+    length = defaultValue.defined(minimumHeights) ? minimumHeights.length : 0;
+    array[startingIndex++] = length;
+
+    if (defaultValue.defined(minimumHeights)) {
+      for (i = 0; i < length; ++i) {
+        array[startingIndex++] = minimumHeights[i];
+      }
+    }
+
+    const maximumHeights = value._maximumHeights;
+    length = defaultValue.defined(maximumHeights) ? maximumHeights.length : 0;
+    array[startingIndex++] = length;
+
+    if (defaultValue.defined(maximumHeights)) {
+      for (i = 0; i < length; ++i) {
+        array[startingIndex++] = maximumHeights[i];
+      }
+    }
+
+    Matrix3.Ellipsoid.pack(value._ellipsoid, array, startingIndex);
+    startingIndex += Matrix3.Ellipsoid.packedLength;
+
+    VertexFormat.VertexFormat.pack(value._vertexFormat, array, startingIndex);
+    startingIndex += VertexFormat.VertexFormat.packedLength;
+
+    array[startingIndex] = value._granularity;
+
+    return array;
+  };
+
+  const scratchEllipsoid = Matrix3.Ellipsoid.clone(Matrix3.Ellipsoid.UNIT_SPHERE);
+  const scratchVertexFormat = new VertexFormat.VertexFormat();
+  const scratchOptions = {
+    positions: undefined,
+    minimumHeights: undefined,
+    maximumHeights: undefined,
+    ellipsoid: scratchEllipsoid,
+    vertexFormat: scratchVertexFormat,
+    granularity: undefined,
+  };
+
+  /**
+   * Retrieves an instance from a packed array.
+   *
+   * @param {Number[]} array The packed array.
+   * @param {Number} [startingIndex=0] The starting index of the element to be unpacked.
+   * @param {WallGeometry} [result] The object into which to store the result.
+   * @returns {WallGeometry} The modified result parameter or a new WallGeometry instance if one was not provided.
+   */
+  WallGeometry.unpack = function (array, startingIndex, result) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defaultValue.defined(array)) {
+      throw new Check.DeveloperError("array is required");
+    }
+    //>>includeEnd('debug');
+
+    startingIndex = defaultValue.defaultValue(startingIndex, 0);
+
+    let i;
+
+    let length = array[startingIndex++];
+    const positions = new Array(length);
+
+    for (i = 0; i < length; ++i, startingIndex += Matrix3.Cartesian3.packedLength) {
+      positions[i] = Matrix3.Cartesian3.unpack(array, startingIndex);
+    }
+
+    length = array[startingIndex++];
+    let minimumHeights;
+
+    if (length > 0) {
+      minimumHeights = new Array(length);
+      for (i = 0; i < length; ++i) {
+        minimumHeights[i] = array[startingIndex++];
+      }
+    }
+
+    length = array[startingIndex++];
+    let maximumHeights;
+
+    if (length > 0) {
+      maximumHeights = new Array(length);
+      for (i = 0; i < length; ++i) {
+        maximumHeights[i] = array[startingIndex++];
+      }
+    }
+
+    const ellipsoid = Matrix3.Ellipsoid.unpack(array, startingIndex, scratchEllipsoid);
+    startingIndex += Matrix3.Ellipsoid.packedLength;
+
+    const vertexFormat = VertexFormat.VertexFormat.unpack(
+      array,
+      startingIndex,
+      scratchVertexFormat
+    );
+    startingIndex += VertexFormat.VertexFormat.packedLength;
+
+    const granularity = array[startingIndex];
+
+    if (!defaultValue.defined(result)) {
+      scratchOptions.positions = positions;
+      scratchOptions.minimumHeights = minimumHeights;
+      scratchOptions.maximumHeights = maximumHeights;
+      scratchOptions.granularity = granularity;
+      return new WallGeometry(scratchOptions);
+    }
+
+    result._positions = positions;
+    result._minimumHeights = minimumHeights;
+    result._maximumHeights = maximumHeights;
+    result._ellipsoid = Matrix3.Ellipsoid.clone(ellipsoid, result._ellipsoid);
+    result._vertexFormat = VertexFormat.VertexFormat.clone(vertexFormat, result._vertexFormat);
+    result._granularity = granularity;
+
+    return result;
+  };
+
+  /**
+   * A description of a wall, which is similar to a KML line string. A wall is defined by a series of points,
+   * which extrude down to the ground. Optionally, they can extrude downwards to a specified height.
+   *
+   * @param {Object} options Object with the following properties:
+   * @param {Cartesian3[]} options.positions An array of Cartesian objects, which are the points of the wall.
+   * @param {Number} [options.maximumHeight] A constant that defines the maximum height of the
+   *        wall at <code>positions</code>. If undefined, the height of each position in used.
+   * @param {Number} [options.minimumHeight] A constant that defines the minimum height of the
+   *        wall at <code>positions</code>. If undefined, the height at each position is 0.0.
+   * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid for coordinate manipulation
+   * @param {VertexFormat} [options.vertexFormat=VertexFormat.DEFAULT] The vertex attributes to be computed.
+   * @returns {WallGeometry}
+   *
+   *
+   * @example
+   * // create a wall that spans from 10000 meters to 20000 meters
+   * const wall = Cesium.WallGeometry.fromConstantHeights({
+   *   positions : Cesium.Cartesian3.fromDegreesArray([
+   *     19.0, 47.0,
+   *     19.0, 48.0,
+   *     20.0, 48.0,
+   *     20.0, 47.0,
+   *     19.0, 47.0,
+   *   ]),
+   *   minimumHeight : 20000.0,
+   *   maximumHeight : 10000.0
+   * });
+   * const geometry = Cesium.WallGeometry.createGeometry(wall);
+   *
+   * @see WallGeometry#createGeometry
+   */
+  WallGeometry.fromConstantHeights = function (options) {
+    options = defaultValue.defaultValue(options, defaultValue.defaultValue.EMPTY_OBJECT);
+    const positions = options.positions;
+
+    //>>includeStart('debug', pragmas.debug);
+    if (!defaultValue.defined(positions)) {
+      throw new Check.DeveloperError("options.positions is required.");
+    }
+    //>>includeEnd('debug');
+
+    let minHeights;
+    let maxHeights;
+
+    const min = options.minimumHeight;
+    const max = options.maximumHeight;
+
+    const doMin = defaultValue.defined(min);
+    const doMax = defaultValue.defined(max);
+    if (doMin || doMax) {
+      const length = positions.length;
+      minHeights = doMin ? new Array(length) : undefined;
+      maxHeights = doMax ? new Array(length) : undefined;
+
+      for (let i = 0; i < length; ++i) {
+        if (doMin) {
+          minHeights[i] = min;
+        }
+
+        if (doMax) {
+          maxHeights[i] = max;
+        }
+      }
+    }
+
+    const newOptions = {
+      positions: positions,
+      maximumHeights: maxHeights,
+      minimumHeights: minHeights,
+      ellipsoid: options.ellipsoid,
+      vertexFormat: options.vertexFormat,
+    };
+    return new WallGeometry(newOptions);
+  };
+
+  /**
+   * Computes the geometric representation of a wall, including its vertices, indices, and a bounding sphere.
+   *
+   * @param {WallGeometry} wallGeometry A description of the wall.
+   * @returns {Geometry|undefined} The computed vertices and indices.
+   */
+  WallGeometry.createGeometry = function (wallGeometry) {
+    const wallPositions = wallGeometry._positions;
+    const minimumHeights = wallGeometry._minimumHeights;
+    const maximumHeights = wallGeometry._maximumHeights;
+    const vertexFormat = wallGeometry._vertexFormat;
+    const granularity = wallGeometry._granularity;
+    const ellipsoid = wallGeometry._ellipsoid;
+
+    const pos = WallGeometryLibrary.WallGeometryLibrary.computePositions(
+      ellipsoid,
+      wallPositions,
+      maximumHeights,
+      minimumHeights,
+      granularity,
+      true
+    );
+    if (!defaultValue.defined(pos)) {
+      return;
+    }
+
+    const bottomPositions = pos.bottomPositions;
+    const topPositions = pos.topPositions;
+    const numCorners = pos.numCorners;
+
+    let length = topPositions.length;
+    let size = length * 2;
+
+    const positions = vertexFormat.position ? new Float64Array(size) : undefined;
+    const normals = vertexFormat.normal ? new Float32Array(size) : undefined;
+    const tangents = vertexFormat.tangent ? new Float32Array(size) : undefined;
+    const bitangents = vertexFormat.bitangent
+      ? new Float32Array(size)
+      : undefined;
+    const textureCoordinates = vertexFormat.st
+      ? new Float32Array((size / 3) * 2)
+      : undefined;
+
+    let positionIndex = 0;
+    let normalIndex = 0;
+    let bitangentIndex = 0;
+    let tangentIndex = 0;
+    let stIndex = 0;
+
+    // add lower and upper points one after the other, lower
+    // points being even and upper points being odd
+    let normal = scratchNormal;
+    let tangent = scratchTangent;
+    let bitangent = scratchBitangent;
+    let recomputeNormal = true;
+    length /= 3;
+    let i;
+    let s = 0;
+    const ds = 1 / (length - numCorners - 1);
+    for (i = 0; i < length; ++i) {
+      const i3 = i * 3;
+      const topPosition = Matrix3.Cartesian3.fromArray(
+        topPositions,
+        i3,
+        scratchCartesian3Position1
+      );
+      const bottomPosition = Matrix3.Cartesian3.fromArray(
+        bottomPositions,
+        i3,
+        scratchCartesian3Position2
+      );
+      if (vertexFormat.position) {
+        // insert the lower point
+        positions[positionIndex++] = bottomPosition.x;
+        positions[positionIndex++] = bottomPosition.y;
+        positions[positionIndex++] = bottomPosition.z;
+
+        // insert the upper point
+        positions[positionIndex++] = topPosition.x;
+        positions[positionIndex++] = topPosition.y;
+        positions[positionIndex++] = topPosition.z;
+      }
+
+      if (vertexFormat.st) {
+        textureCoordinates[stIndex++] = s;
+        textureCoordinates[stIndex++] = 0.0;
+
+        textureCoordinates[stIndex++] = s;
+        textureCoordinates[stIndex++] = 1.0;
+      }
+
+      if (vertexFormat.normal || vertexFormat.tangent || vertexFormat.bitangent) {
+        let nextTop = Matrix3.Cartesian3.clone(
+          Matrix3.Cartesian3.ZERO,
+          scratchCartesian3Position5
+        );
+        const groundPosition = Matrix3.Cartesian3.subtract(
+          topPosition,
+          ellipsoid.geodeticSurfaceNormal(
+            topPosition,
+            scratchCartesian3Position2
+          ),
+          scratchCartesian3Position2
+        );
+        if (i + 1 < length) {
+          nextTop = Matrix3.Cartesian3.fromArray(
+            topPositions,
+            i3 + 3,
+            scratchCartesian3Position5
+          );
+        }
+
+        if (recomputeNormal) {
+          const scalednextPosition = Matrix3.Cartesian3.subtract(
+            nextTop,
+            topPosition,
+            scratchCartesian3Position4
+          );
+          const scaledGroundPosition = Matrix3.Cartesian3.subtract(
+            groundPosition,
+            topPosition,
+            scratchCartesian3Position1
+          );
+          normal = Matrix3.Cartesian3.normalize(
+            Matrix3.Cartesian3.cross(scaledGroundPosition, scalednextPosition, normal),
+            normal
+          );
+          recomputeNormal = false;
+        }
+
+        if (
+          Matrix3.Cartesian3.equalsEpsilon(topPosition, nextTop, Math.CesiumMath.EPSILON10)
+        ) {
+          recomputeNormal = true;
+        } else {
+          s += ds;
+          if (vertexFormat.tangent) {
+            tangent = Matrix3.Cartesian3.normalize(
+              Matrix3.Cartesian3.subtract(nextTop, topPosition, tangent),
+              tangent
+            );
+          }
+          if (vertexFormat.bitangent) {
+            bitangent = Matrix3.Cartesian3.normalize(
+              Matrix3.Cartesian3.cross(normal, tangent, bitangent),
+              bitangent
+            );
+          }
+        }
+
+        if (vertexFormat.normal) {
+          normals[normalIndex++] = normal.x;
+          normals[normalIndex++] = normal.y;
+          normals[normalIndex++] = normal.z;
+
+          normals[normalIndex++] = normal.x;
+          normals[normalIndex++] = normal.y;
+          normals[normalIndex++] = normal.z;
+        }
+
+        if (vertexFormat.tangent) {
+          tangents[tangentIndex++] = tangent.x;
+          tangents[tangentIndex++] = tangent.y;
+          tangents[tangentIndex++] = tangent.z;
+
+          tangents[tangentIndex++] = tangent.x;
+          tangents[tangentIndex++] = tangent.y;
+          tangents[tangentIndex++] = tangent.z;
+        }
+
+        if (vertexFormat.bitangent) {
+          bitangents[bitangentIndex++] = bitangent.x;
+          bitangents[bitangentIndex++] = bitangent.y;
+          bitangents[bitangentIndex++] = bitangent.z;
+
+          bitangents[bitangentIndex++] = bitangent.x;
+          bitangents[bitangentIndex++] = bitangent.y;
+          bitangents[bitangentIndex++] = bitangent.z;
+        }
+      }
+    }
+
+    const attributes = new GeometryAttributes.GeometryAttributes();
+
+    if (vertexFormat.position) {
+      attributes.position = new GeometryAttribute.GeometryAttribute({
+        componentDatatype: ComponentDatatype.ComponentDatatype.DOUBLE,
+        componentsPerAttribute: 3,
+        values: positions,
+      });
+    }
+
+    if (vertexFormat.normal) {
+      attributes.normal = new GeometryAttribute.GeometryAttribute({
+        componentDatatype: ComponentDatatype.ComponentDatatype.FLOAT,
+        componentsPerAttribute: 3,
+        values: normals,
+      });
+    }
+
+    if (vertexFormat.tangent) {
+      attributes.tangent = new GeometryAttribute.GeometryAttribute({
+        componentDatatype: ComponentDatatype.ComponentDatatype.FLOAT,
+        componentsPerAttribute: 3,
+        values: tangents,
+      });
+    }
+
+    if (vertexFormat.bitangent) {
+      attributes.bitangent = new GeometryAttribute.GeometryAttribute({
+        componentDatatype: ComponentDatatype.ComponentDatatype.FLOAT,
+        componentsPerAttribute: 3,
+        values: bitangents,
+      });
+    }
+
+    if (vertexFormat.st) {
+      attributes.st = new GeometryAttribute.GeometryAttribute({
+        componentDatatype: ComponentDatatype.ComponentDatatype.FLOAT,
+        componentsPerAttribute: 2,
+        values: textureCoordinates,
+      });
+    }
+
+    // prepare the side walls, two triangles for each wall
+    //
+    //    A (i+1)  B (i+3) E
+    //    +--------+-------+
+    //    |      / |      /|    triangles:  A C B
+    //    |     /  |     / |                B C D
+    //    |    /   |    /  |
+    //    |   /    |   /   |
+    //    |  /     |  /    |
+    //    | /      | /     |
+    //    +--------+-------+
+    //    C (i)    D (i+2) F
+    //
+
+    const numVertices = size / 3;
+    size -= 6 * (numCorners + 1);
+    const indices = IndexDatatype.IndexDatatype.createTypedArray(numVertices, size);
+
+    let edgeIndex = 0;
+    for (i = 0; i < numVertices - 2; i += 2) {
+      const LL = i;
+      const LR = i + 2;
+      const pl = Matrix3.Cartesian3.fromArray(
+        positions,
+        LL * 3,
+        scratchCartesian3Position1
+      );
+      const pr = Matrix3.Cartesian3.fromArray(
+        positions,
+        LR * 3,
+        scratchCartesian3Position2
+      );
+      if (Matrix3.Cartesian3.equalsEpsilon(pl, pr, Math.CesiumMath.EPSILON10)) {
+        continue;
+      }
+      const UL = i + 1;
+      const UR = i + 3;
+
+      indices[edgeIndex++] = UL;
+      indices[edgeIndex++] = LL;
+      indices[edgeIndex++] = UR;
+      indices[edgeIndex++] = UR;
+      indices[edgeIndex++] = LL;
+      indices[edgeIndex++] = LR;
+    }
+
+    return new GeometryAttribute.Geometry({
+      attributes: attributes,
+      indices: indices,
+      primitiveType: GeometryAttribute.PrimitiveType.TRIANGLES,
+      boundingSphere: new Transforms.BoundingSphere.fromVertices(positions),
+    });
+  };
+
+  function createWallGeometry(wallGeometry, offset) {
+    if (defaultValue.defined(offset)) {
+      wallGeometry = WallGeometry.unpack(wallGeometry, offset);
+    }
+    wallGeometry._ellipsoid = Matrix3.Ellipsoid.clone(wallGeometry._ellipsoid);
+    return WallGeometry.createGeometry(wallGeometry);
+  }
+
+  return createWallGeometry;
+
+}));