44:["$","title",null,{"children":"Line tesselation | Anand Thakker | Observable"}] 4c:T411,{ const u_ratio = 1; const tesselated = tesselate(line, {u_ratio, width: lineWidth, gapwidth: 0}, {join, cap, miterLimit, roundLimit}); const x = d => d[0]; const y = d => d[1]; const extent = {x: d3.extent(tesselated.vertices, x), y: d3.extent(tesselated.vertices, y)} const dotSize = (extent.x[1] - extent.x[0]) / 128; const padding = (extent.x[1] - extent.x[0]) * 0.1; const viewbox = [ extent.x[0] - padding, extent.y[0] - padding, extent.x[1] - extent.x[0] + padding * 2, extent.y[1] - extent.y[0] + padding * 2 ]; const dot = (x, y, color = "black") => svg``; const triangle = (t) => svg``; return svg`` }4d:Tb57,function createLineShader(uniforms) { // the distance over which the line edge fades out. // Retina devices need a smaller distance to avoid aliasing. const ANTIALIASING = 1.0 / DEVICE_PIXEL_RATIO / 2.0 // floor(127 / 2) == 63.0 // the maximum allowed miter limit is 2.0 at the moment. the extrude normal is // stored in a byte (-128..127). we scale regular normals up to length 63, but // there are also "special" normals that have a bigger length (of up to 126 in // this case). // #define scale 63.0 const scale = 0.015873016 const { u_ratio, u_gl_units_to_pixels, gapwidth, width } = uniforms; return function transformVertex(attributes) { let v_normal, v_width2, v_gamma_scale, v_linesofar; const {a_pos_normal, a_data} = attributes; const a_extrude = a_data.slice(0, 2).map(x => x - 128); // a_data.xy - 128.0 const a_direction = a_data[2] % 4 - 1; // mod(a_data.z, 4.0) - 1.0; v_linesofar = (Math.floor(a_data[2] / 4) + a_data[3] * 64) * 2; // (floor(a_data.z / 4.0) + a_data.w * 64.0) * 2.0; const pos = a_pos_normal.slice(0, 2); // x is 1 if it's a round cap, 0 otherwise // y is 1 if the normal points up, and -1 if it points down const normal = a_pos_normal.slice(2); v_normal = normal; // these transformations used to be applied in the JS and native code bases. // moved them into the shader for clarity and simplicity. const halfgapwidth = gapwidth / 2.0; const halfwidth = width / 2.0; const inset = halfgapwidth + (halfgapwidth > 0.0 ? ANTIALIASING : 0.0); const outset = halfgapwidth + halfwidth * (halfgapwidth > 0.0 ? 2.0 : 1.0) + ANTIALIASING; // Scale the extrusion vector down to a normal and then up by the line width // of this vertex. const dist = a_extrude.map(c => c * outset * scale); // dist = outset * a_extrude * scale // vec4 projected_extrude = u_matrix * vec4(dist / u_ratio, 0.0, 0.0); const projected_extrude = glm.vec4.fromValues(dist[0] / u_ratio, dist[1] / u_ratio, 0, 0); // projected_extrude.transformMat4(projected_extrude, projected_extrude, u_matrix); // gl_Position = u_matrix * vec4(pos / u_ratio, 0.0, 1.0) + projected_extrude; const gl_Position = glm.vec4.fromValues(pos[0] / u_ratio, pos[1] / u_ratio, 0, 1); // gl_Position.transformMat4(gl_Position, gl_Position, u_matrix); glm.vec4.add(gl_Position, gl_Position, projected_extrude); // calculate how much the perspective view squishes or stretches the extrude // float extrude_length_without_perspective = length(dist); // float extrude_length_with_perspective = length(projected_extrude.xy / gl_Position.w * u_gl_units_to_pixels); // v_gamma_scale = extrude_length_without_perspective / extrude_length_with_perspective; // v_width2 = vec2(outset, inset); return [gl_Position[0], gl_Position[1]]; } }4e:T407f,class LineBucket { constructor() { this.layoutVertexArray = []; this.indexArray = []; this.overscaling = 1; } addLine(vertices, feature, join, cap, miterLimit, roundLimit) { let lineDistances = null; if (!!feature.properties && feature.properties.hasOwnProperty('mapbox_clip_start') && feature.properties.hasOwnProperty('mapbox_clip_end')) { lineDistances = { start: feature.properties.mapbox_clip_start, end: feature.properties.mapbox_clip_end, tileTotal: undefined }; } const isPolygon = mvt.VectorTileFeature.types[feature.type] === 'Polygon'; // If the line has duplicate vertices at the ends, adjust start/length to remove them. let len = vertices.length; while (len >= 2 && vertices[len - 1].equals(vertices[len - 2])) { len--; } let first = 0; while (first < len - 1 && vertices[first].equals(vertices[first + 1])) { first++; } // Ignore invalid geometry. if (len < (isPolygon ? 3 : 2)) return; if (lineDistances) { lineDistances.tileTotal = calculateFullDistance(vertices, first, len); } if (join === 'bevel') miterLimit = 1.05; const sharpCornerOffset = SHARP_CORNER_OFFSET * (EXTENT / (512 * this.overscaling)); const firstVertex = vertices[first]; const segment = {vertexLength: 0} // this.segments.prepareSegment(len * 10, this.layoutVertexArray, this.indexArray); this.distance = 0; const beginCap = cap, endCap = isPolygon ? 'butt' : cap; let startOfLine = true; let currentVertex; let prevVertex = undefined; let nextVertex = undefined; let prevNormal = undefined; let nextNormal = undefined; let offsetA; let offsetB; // the last three vertices added this.e1 = this.e2 = this.e3 = -1; if (isPolygon) { currentVertex = vertices[len - 2]; nextNormal = firstVertex.sub(currentVertex)._unit()._perp(); } for (let i = first; i < len; i++) { nextVertex = isPolygon && i === len - 1 ? vertices[first + 1] : // if the line is closed, we treat the last vertex like the first vertices[i + 1]; // just the next vertex // if two consecutive vertices exist, skip the current one if (nextVertex && vertices[i].equals(nextVertex)) continue; if (nextNormal) prevNormal = nextNormal; if (currentVertex) prevVertex = currentVertex; currentVertex = vertices[i]; // Calculate the normal towards the next vertex in this line. In case // there is no next vertex, pretend that the line is continuing straight, // meaning that we are just using the previous normal. nextNormal = nextVertex ? nextVertex.sub(currentVertex)._unit()._perp() : prevNormal; // If we still don't have a previous normal, this is the beginning of a // non-closed line, so we're doing a straight "join". prevNormal = prevNormal || nextNormal; // Determine the normal of the join extrusion. It is the angle bisector // of the segments between the previous line and the next line. // In the case of 180° angles, the prev and next normals cancel each other out: // prevNormal + nextNormal = (0, 0), its magnitude is 0, so the unit vector would be // undefined. In that case, we're keeping the joinNormal at (0, 0), so that the cosHalfAngle // below will also become 0 and miterLength will become Infinity. let joinNormal = prevNormal.add(nextNormal); if (joinNormal.x !== 0 || joinNormal.y !== 0) { joinNormal._unit(); } /* joinNormal prevNormal * ↖ ↑ * .________. prevVertex * | * nextNormal ← | currentVertex * | * nextVertex ! * */ // Calculate the length of the miter (the ratio of the miter to the width). // Find the cosine of the angle between the next and join normals // using dot product. The inverse of that is the miter length. const cosHalfAngle = joinNormal.x * nextNormal.x + joinNormal.y * nextNormal.y; const miterLength = cosHalfAngle !== 0 ? 1 / cosHalfAngle : Infinity; const isSharpCorner = cosHalfAngle < COS_HALF_SHARP_CORNER && prevVertex && nextVertex; if (isSharpCorner && i > first) { const prevSegmentLength = currentVertex.dist(prevVertex); if (prevSegmentLength > 2 * sharpCornerOffset) { const newPrevVertex = currentVertex.sub(currentVertex.sub(prevVertex)._mult(sharpCornerOffset / prevSegmentLength)._round()); this.distance += newPrevVertex.dist(prevVertex); this.addCurrentVertex(newPrevVertex, this.distance, prevNormal.mult(1), 0, 0, false, segment, lineDistances); prevVertex = newPrevVertex; } } // The join if a middle vertex, otherwise the cap. const middleVertex = prevVertex && nextVertex; let currentJoin = middleVertex ? join : nextVertex ? beginCap : endCap; if (middleVertex && currentJoin === 'round') { if (miterLength < roundLimit) { currentJoin = 'miter'; } else if (miterLength <= 2) { currentJoin = 'fakeround'; } } if (currentJoin === 'miter' && miterLength > miterLimit) { currentJoin = 'bevel'; } if (currentJoin === 'bevel') { // The maximum extrude length is 128 / 63 = 2 times the width of the line // so if miterLength >= 2 we need to draw a different type of bevel here. if (miterLength > 2) currentJoin = 'flipbevel'; // If the miterLength is really small and the line bevel wouldn't be visible, // just draw a miter join to save a triangle. if (miterLength < miterLimit) currentJoin = 'miter'; } // Calculate how far along the line the currentVertex is if (prevVertex) this.distance += currentVertex.dist(prevVertex); if (currentJoin === 'miter') { joinNormal._mult(miterLength); this.addCurrentVertex(currentVertex, this.distance, joinNormal, 0, 0, false, segment, lineDistances); } else if (currentJoin === 'flipbevel') { // miter is too big, flip the direction to make a beveled join if (miterLength > 100) { // Almost parallel lines joinNormal = nextNormal.clone().mult(-1); } else { const direction = prevNormal.x * nextNormal.y - prevNormal.y * nextNormal.x > 0 ? -1 : 1; const bevelLength = miterLength * prevNormal.add(nextNormal).mag() / prevNormal.sub(nextNormal).mag(); joinNormal._perp()._mult(bevelLength * direction); } this.addCurrentVertex(currentVertex, this.distance, joinNormal, 0, 0, false, segment, lineDistances); this.addCurrentVertex(currentVertex, this.distance, joinNormal.mult(-1), 0, 0, false, segment, lineDistances); } else if (currentJoin === 'bevel' || currentJoin === 'fakeround') { const lineTurnsLeft = (prevNormal.x * nextNormal.y - prevNormal.y * nextNormal.x) > 0; const offset = -Math.sqrt(miterLength * miterLength - 1); if (lineTurnsLeft) { offsetB = 0; offsetA = offset; } else { offsetA = 0; offsetB = offset; } // Close previous segment with a bevel if (!startOfLine) { this.addCurrentVertex(currentVertex, this.distance, prevNormal, offsetA, offsetB, false, segment, lineDistances); } if (currentJoin === 'fakeround') { // The join angle is sharp enough that a round join would be visible. // Bevel joins fill the gap between segments with a single pie slice triangle. // Create a round join by adding multiple pie slices. The join isn't actually round, but // it looks like it is at the sizes we render lines at. // Add more triangles for sharper angles. // This math is just a good enough approximation. It isn't "correct". const n = Math.floor((0.5 - (cosHalfAngle - 0.5)) * 8); let approxFractionalJoinNormal; for (let m = 0; m < n; m++) { approxFractionalJoinNormal = nextNormal.mult((m + 1) / (n + 1))._add(prevNormal)._unit(); this.addPieSliceVertex(currentVertex, this.distance, approxFractionalJoinNormal, lineTurnsLeft, segment, lineDistances); } this.addPieSliceVertex(currentVertex, this.distance, joinNormal, lineTurnsLeft, segment, lineDistances); for (let k = n - 1; k >= 0; k--) { approxFractionalJoinNormal = prevNormal.mult((k + 1) / (n + 1))._add(nextNormal)._unit(); this.addPieSliceVertex(currentVertex, this.distance, approxFractionalJoinNormal, lineTurnsLeft, segment, lineDistances); } } // Start next segment if (nextVertex) { this.addCurrentVertex(currentVertex, this.distance, nextNormal, -offsetA, -offsetB, false, segment, lineDistances); } } else if (currentJoin === 'butt') { if (!startOfLine) { // Close previous segment with a butt this.addCurrentVertex(currentVertex, this.distance, prevNormal, 0, 0, false, segment, lineDistances); } // Start next segment with a butt if (nextVertex) { this.addCurrentVertex(currentVertex, this.distance, nextNormal, 0, 0, false, segment, lineDistances); } } else if (currentJoin === 'square') { if (!startOfLine) { // Close previous segment with a square cap this.addCurrentVertex(currentVertex, this.distance, prevNormal, 1, 1, false, segment, lineDistances); // The segment is done. Unset vertices to disconnect segments. this.e1 = this.e2 = -1; } // Start next segment if (nextVertex) { this.addCurrentVertex(currentVertex, this.distance, nextNormal, -1, -1, false, segment, lineDistances); } } else if (currentJoin === 'round') { if (!startOfLine) { // Close previous segment with butt this.addCurrentVertex(currentVertex, this.distance, prevNormal, 0, 0, false, segment, lineDistances); // Add round cap or linejoin at end of segment this.addCurrentVertex(currentVertex, this.distance, prevNormal, 1, 1, true, segment, lineDistances); // The segment is done. Unset vertices to disconnect segments. this.e1 = this.e2 = -1; } // Start next segment with a butt if (nextVertex) { // Add round cap before first segment this.addCurrentVertex(currentVertex, this.distance, nextNormal, -1, -1, true, segment, lineDistances); this.addCurrentVertex(currentVertex, this.distance, nextNormal, 0, 0, false, segment, lineDistances); } } if (isSharpCorner && i < len - 1) { const nextSegmentLength = currentVertex.dist(nextVertex); if (nextSegmentLength > 2 * sharpCornerOffset) { const newCurrentVertex = currentVertex.add(nextVertex.sub(currentVertex)._mult(sharpCornerOffset / nextSegmentLength)._round()); this.distance += newCurrentVertex.dist(currentVertex); this.addCurrentVertex(newCurrentVertex, this.distance, nextNormal.mult(1), 0, 0, false, segment, lineDistances); currentVertex = newCurrentVertex; } } startOfLine = false; } } addCurrentVertex(currentVertex, distance, normal, endLeft, endRight, round, segment, distancesForScaling) { let extrude; const layoutVertexArray = this.layoutVertexArray; const indexArray = this.indexArray; if (distancesForScaling) { // For gradient lines, scale distance from tile units to [0, 2^15) distance = scaleDistance(distance, distancesForScaling); } extrude = normal.clone(); if (endLeft) extrude._sub(normal.perp()._mult(endLeft)); addLineVertex(layoutVertexArray, currentVertex, extrude, round, false, endLeft, distance); this.e3 = segment.vertexLength++; if (this.e1 >= 0 && this.e2 >= 0) { indexArray.push([this.e1, this.e2, this.e3]); segment.primitiveLength++; } this.e1 = this.e2; this.e2 = this.e3; extrude = normal.mult(-1); if (endRight) extrude._sub(normal.perp()._mult(endRight)); addLineVertex(layoutVertexArray, currentVertex, extrude, round, true, -endRight, distance); this.e3 = segment.vertexLength++; if (this.e1 >= 0 && this.e2 >= 0) { indexArray.push([this.e1, this.e2, this.e3]); segment.primitiveLength++; } this.e1 = this.e2; this.e2 = this.e3; // There is a maximum "distance along the line" that we can store in the buffers. // When we get close to the distance, reset it to zero and add the vertex again with // a distance of zero. The max distance is determined by the number of bits we allocate // to `linesofar`. if (distance > MAX_LINE_DISTANCE / 2 && !distancesForScaling) { this.distance = 0; this.addCurrentVertex(currentVertex, this.distance, normal, endLeft, endRight, round, segment); } } /** * Add a single new vertex and a triangle using two previous vertices. * This adds a pie slice triangle near a join to simulate round joins * * @param currentVertex the line vertex to add buffer vertices for * @param distance the distance from the beginning of the line to the vertex * @param extrude the offset of the new vertex from the currentVertex * @param lineTurnsLeft whether the line is turning left or right at this angle * @private */ addPieSliceVertex(currentVertex, distance, extrude, lineTurnsLeft, segment, distancesForScaling) { extrude = extrude.mult(lineTurnsLeft ? -1 : 1); const layoutVertexArray = this.layoutVertexArray; const indexArray = this.indexArray; if (distancesForScaling) distance = scaleDistance(distance, distancesForScaling); addLineVertex(layoutVertexArray, currentVertex, extrude, false, lineTurnsLeft, 0, distance); this.e3 = segment.vertexLength++; if (this.e1 >= 0 && this.e2 >= 0) { indexArray.push([this.e1, this.e2, this.e3]); segment.primitiveLength++; } if (lineTurnsLeft) { this.e2 = this.e3; } else { this.e1 = this.e3; } } }4f:T404,function addLineVertex(layoutVertexBuffer, point, extrude, round, up, dir, linesofar) { layoutVertexBuffer.push({ a_pos_normal: [ point.x, point.y, round ? 1 : 0, up ? 1 : -1 ], a_data: [ // add 128 to store a byte in an unsigned byte Math.round(EXTRUDE_SCALE * extrude.x) + 128, Math.round(EXTRUDE_SCALE * extrude.y) + 128, // Encode the -1/0/1 direction value into the first two bits of .z of a_data. // Combine it with the lower 6 bits of `linesofar` (shifted by 2 bites to make // room for the direction value). The upper 8 bits of `linesofar` are placed in // the `w` component. `linesofar` is scaled down by `LINE_DISTANCE_SCALE` so that // we can store longer distances while sacrificing precision. ((dir === 0 ? 0 : (dir < 0 ? -1 : 1)) + 1) | (((linesofar * LINE_DISTANCE_SCALE) & 0x3F) << 2), (linesofar * LINE_DISTANCE_SCALE) >> 6 ] }); }50:[] 48:{"id":"cc91a2abedace946","slug":"line-tesselation","title":"Line tesselation","thumbnail":"a98b9a643bed31756f81d16510a6c5e29d73bb9759cc484b67d6dbcc1c59778d","access_level":"public","create_time":"$D2018-04-26T06:35:45.693Z","update_time":"$D2018-04-26T13:25:32.700Z","view_time":null,"first_public_time":"$D2018-04-26T08:49:31.603Z","has_unpublished_edits":null,"fork":false,"stars":6,"starred":false,"owner":{"type":"team","id":"4dafab78a0ba3c55","login":"anandthakker","name":"Anand Thakker","avatar_url":"https://avatars-next.observableusercontent.com/a797ebd766058f350bfa8bfc73d818d72c58831289f057450e42f73243402cdd","tier":"starter_2024","bio":"","followed_by_you":false,"follows_you":false},"version":218,"publish_version":218,"role":null,"authored":false,"authors":[{"type":"individual","id":"62e1d83104678cb6","login":"anandthakker","name":"Anand Thakker","avatar_url":"https://avatars-next.observableusercontent.com/a797ebd766058f350bfa8bfc73d818d72c58831289f057450e42f73243402cdd","tier":null,"bio":"","followed_by_you":false,"follows_you":false}],"members":[{"type":"individual","id":"62e1d83104678cb6","login":"anandthakker","name":"Anand Thakker","avatar_url":"https://avatars-next.observableusercontent.com/a797ebd766058f350bfa8bfc73d818d72c58831289f057450e42f73243402cdd","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"lapsed":null,"subscribed":null,"forks":1,"collection":null,"type":"notebook","body":{"titling":"auto","title":"Line tesselation","cells":[{"id":0,"value":"md`# Line tesselation`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":111,"value":"line = [\n [0, 0],\n [600, 0],\n [300, 150],\n [600, 600],\n [0, 600]\n]","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":182,"value":"viewof join = html``","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":184,"value":"viewof cap = html``","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":188,"value":"miterLimit = 2","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":190,"value":"roundLimit = 1.05","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":200,"value":"viewof lineWidth = html``","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":113,"value":"$4c","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":84,"value":"function tesselate(vertices, uniforms, {join, cap, miterLimit, roundLimit}) {\n const shader = createLineShader(uniforms);\n const b = new LineBucket();\n b.addLine(vertices.map(([x, y]) => new Point(x, y)), {}, join, cap, miterLimit, roundLimit)\n const tesselatedVertices = b.layoutVertexArray.map(shader);\n return {\n vertices: tesselatedVertices,\n triangles: b.indexArray.map(triangle => triangle.map(i => tesselatedVertices[i]))\n }\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":49,"value":"$4d","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":5,"value":"$4e","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":45,"value":"$4f","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":16,"value":"/**\n * Calculate the total distance, in tile units, of this tiled line feature\n *\n * @param {Array} vertices the full geometry of this tiled line feature\n * @param {number} first the index in the vertices array representing the first vertex we should consider\n * @param {number} len the count of vertices we should consider from `first`\n *\n * @private\n */\nfunction calculateFullDistance(vertices, first, len) {\n let currentVertex, nextVertex;\n let total = 0;\n for (let i = first; i < len - 1; i++) {\n currentVertex = vertices[i];\n nextVertex = vertices[i + 1];\n total += currentVertex.dist(nextVertex);\n }\n return total;\n}\n\n","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":43,"value":"/**\n * Knowing the ratio of the full linestring covered by this tiled feature, as well\n * as the total distance (in tile units) of this tiled feature, and the distance\n * (in tile units) of the current vertex, we can determine the relative distance\n * of this vertex along the full linestring feature and scale it to [0, 2^15)\n *\n * @param {number} tileDistance the distance from the beginning of the tiled line to this vertex\n * @param {Object} stats\n * @param {number} stats.start the ratio (0-1) along a full original linestring feature of the start of this tiled line feature\n * @param {number} stats.end the ratio (0-1) along a full original linestring feature of the end of this tiled line feature\n * @param {number} stats.tileTotal the total distance, in tile units, of this tiled line feature\n *\n * @private\n */\nfunction scaleDistance(tileDistance, stats) {\n return ((tileDistance / stats.tileTotal) * (stats.end - stats.start) + stats.start) * (MAX_LINE_DISTANCE - 1);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":10,"value":"/*\n * Sharp corners cause dashed lines to tilt because the distance along the line\n * is the same at both the inner and outer corners. To improve the appearance of\n * dashed lines we add extra points near sharp corners so that a smaller part\n * of the line is tilted.\n *\n * COS_HALF_SHARP_CORNER controls how sharp a corner has to be for us to add an\n * extra vertex. The default is 75 degrees.\n *\n * The newly created vertices are placed SHARP_CORNER_OFFSET pixels from the corner.\n */\nCOS_HALF_SHARP_CORNER = Math.cos(75 / 2 * (Math.PI / 180))","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":12,"value":"SHARP_CORNER_OFFSET = 15","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":28,"value":"EXTENT = 8192","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":37,"value":"MAX_LINE_DISTANCE = Math.pow(2, LINE_DISTANCE_BUFFER_BITS - 1) / LINE_DISTANCE_SCALE","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":39,"value":"LINE_DISTANCE_SCALE = 1 / 2","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":41,"value":"LINE_DISTANCE_BUFFER_BITS = 15","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":47,"value":"// NOTE ON EXTRUDE SCALE:\n// scale the extrusion vector so that the normal length is this value.\n// contains the \"texture\" normals (-1..1). this is distinct from the extrude\n// normals for line joins, because the x-value remains 0 for the texture\n// normal array, while the extrude normal actually moves the vertex to create\n// the acute/bevelled line join.\nEXTRUDE_SCALE = 63","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":63,"value":"DEVICE_PIXEL_RATIO = 2","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":19,"value":"Point = require('https://wzrd.in/standalone/@mapbox%2Fpoint-geometry@latest')","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":30,"value":"mvt = require('https://wzrd.in/standalone/@mapbox%2Fvector-tile')","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":50,"value":"glm = require('https://wzrd.in/standalone/gl-matrix@latest')","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":116,"value":"d3 = require('d3')","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W50","stdlib":"1"}} 24:null