import codes

src/views/infrastructure/geometry/hexagon-pillar.ts

@@ -0,0 +1,281 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.
+ */
+import Vec3 from "@/utils/vec3";
+import Vec2 from "@/utils/vec2";
+
+class HexagonPillar {
+  static get(
+    pointyUp = true,
+    radius = 0.5,
+    cornerScale = 0.2,
+    cornerDiv = 3,
+    capSize = 0.2,
+    offsetHeight = 0.5
+  ): {
+    vertices: number[];
+    indices: number[];
+    texcoord: number[];
+    normals: number[];
+  } {
+    const rtn: {
+      vertices: number[];
+      indices: number[];
+      texcoord: number[];
+      normals: number[];
+    } = {
+      vertices: [],
+      indices: [],
+      texcoord: [],
+      normals: [],
+    };
+
+    let poly = createPolygon(radius, 6, pointyUp ? (30 * Math.PI) / 180 : 0); // Create Base Shape
+    poly = polyBevel(poly, cornerScale, cornerDiv); // Round the Shape Corners
+    // Base Layer
+    toVec3(rtn, poly);
+    const vertCnt = rtn.vertices.length / 3;
+    // Starting layer for Cap.
+    toVec3(rtn, poly, [0, offsetHeight, 0]);
+
+    // Extra Layers for Bevel
+    polyCapBevel(rtn, poly, cornerDiv, capSize, [0, offsetHeight, 0]);
+    const idxTip = rtn.vertices.length;
+
+    // Cap Center Point
+    rtn.vertices.push(0, capSize + offsetHeight, 0);
+    rtn.normals.push(0, 1, 0);
+
+    // Indices
+    const idx = idxTip / 3;
+    gridIndicesCol(rtn.indices, vertCnt, 2 + cornerDiv, 0, true, true);
+    fanIndices(rtn.indices, idx, idx - vertCnt, idx - 1, true);
+    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    return rtn;
+  }
+  static getVertices(pointyUp = true, radius = 0.5): { vertices: Vec3[] } {
+    const rtn = {
+      vertices: [],
+      normals: [],
+    };
+
+    const poly = createPolygon(radius, 6, pointyUp ? (30 * Math.PI) / 180 : 0); // Create Base Shape
+    toVec3(rtn, poly);
+    const vertices = [];
+    for (let i = 0; i < rtn.vertices.length / 3; i++) {
+      vertices.push(
+        new Vec3(
+          rtn.vertices[i * 3],
+          rtn.vertices[i * 3 + 1],
+          rtn.vertices[i * 3 + 2]
+        )
+      );
+    }
+    vertices.push(new Vec3(rtn.vertices[0], rtn.vertices[1], rtn.vertices[2]));
+    return { vertices };
+  }
+}
+// Create the basic 2d polygon shape
+function createPolygon(radius: number, sides = 6, offset = 0) {
+  const poly = [];
+  let i, rad;
+  for (i = 0; i < sides; i++) {
+    rad = Math.PI * 2 * (i / sides);
+    poly.push(Math.cos(rad + offset) * radius, Math.sin(rad + offset) * radius);
+  }
+  return poly;
+}
+// Bevel the corners of polygon
+function polyBevel(poly: number[], cornerScale = 0.2, cornerDiv = 3) {
+  const polyOut: number[] = [];
+  const len = poly.length / 2;
+  const a = new Vec2(); // 3 Points that forms a Polygon Corner
+  const b = new Vec2();
+  const c = new Vec2();
+
+  const va = new Vec2(); // Min/Max Points of the corner to bevel
+  const vb = new Vec2();
+
+  const norma = new Vec2(); // Inward Normals of the Corner Edges
+  const normb = new Vec2();
+  const pivot = new Vec2(); // Pivot point to create curved points
+  // eslint-disable-next-line
+  const v = new Vec2() as any;
+  let ii, i, j, k, radius;
+  for (j = 0; j < len; j++) {
+    i = mod(j - 1, len); // Previous Point
+    k = mod(j + 1, len); // Next Point
+
+    a.fromBuf(poly, i * 2); // Get the Point Positions out of flat buffer
+    b.fromBuf(poly, j * 2);
+    c.fromBuf(poly, k * 2);
+
+    va.fromLerp(a, b, 1.0 - cornerScale); // Get the two points to start and end curved corner
+    vb.fromLerp(b, c, cornerScale);
+    norma.fromSub(b, a).perpCCW().norm(); // Compute Inward normal of the two edges
+    normb.fromSub(c, b).perpCCW().norm();
+
+    raysIntersection(va, norma, vb, normb, pivot); // Point where the 2 normals converge.
+
+    radius = Vec2.len(va, pivot); // Get the Radius for the curved corner
+    va.pushTo(polyOut);
+
+    for (ii = 1; ii < cornerDiv; ii++) {
+      // Fill in the remaining points
+      v.fromLerp(va, vb, ii / cornerDiv) // Lerp between Start + end Points
+        .sub(pivot) // Localize it
+        .norm() // Normalize it
+        .scale(radius) // Scale it to the radius
+        .add(pivot) // Move it back to world space
+        .pushTo(polyOut);
+    }
+    vb.pushTo(polyOut);
+  }
+  return polyOut;
+}
+
+function mod(a: number, b: number): number {
+  const v = a % b;
+  return v < 0 ? b + v : v;
+}
+// Turn 2D Polygon Points into 3D Vertices
+function toVec3(
+  geo: { normals: number[]; vertices: number[] },
+  poly: number[],
+  offset?: Vec3 | number[]
+) {
+  const v = new Vec3();
+  // eslint-disable-next-line
+  let i: any;
+  offset = offset || [0, 0, 0];
+  for (i of Vec2.bufIter(poly)) {
+    v.fromVec2(i, true)
+      .add(offset)
+      .pushTo(geo.vertices)
+      .sub(offset)
+      .norm()
+      .pushTo(geo.normals);
+  }
+}
+// Create a Beveled cap for the extruded walls
+function polyCapBevel(
+  geo: { normals: number[]; vertices: number[] },
+  poly: number[],
+  cornerDiv: number,
+  capSize: number,
+  offset?: Vec3 | number[]
+) {
+  // eslint-disable-next-line
+  const v: any = new Vec2();
+  const lerp = [];
+  let pivot, top, pnt, i, vlen, tlen;
+
+  offset = offset || [0, 0, 0];
+  for (i = 0; i < poly.length; i += 2) {
+    v.fromBuf(poly, i);
+
+    vlen = v.len();
+    tlen = vlen - capSize;
+    pnt = new Vec3().fromVec2(v, true);
+    pivot = Vec3.scale(pnt, tlen / vlen);
+    top = Vec3.add(pivot, [0, capSize, 0]);
+
+    lerp.push({ pivot, top, pnt });
+  }
+  let t, itm;
+  pnt = new Vec3();
+  for (i = 1; i <= cornerDiv; i++) {
+    t = i / cornerDiv;
+    for (itm of lerp) {
+      pnt
+        .fromLerp(itm.pnt, itm.top, t)
+        .sub(itm.pivot)
+        .norm()
+        .pushTo(geo.normals)
+        .scale(capSize)
+        .add(itm.pivot)
+        .add(offset)
+        .pushTo(geo.vertices);
+    }
+  }
+}
+
+//https://stackoverflow.com/questions/2931573/determining-if-two-rays-intersect
+function raysIntersection(as: Vec2, ad: Vec2, bs: Vec2, bd: Vec2, out: Vec2) {
+  const dx = bs[0] - as[0];
+  const dy = bs[1] - as[1];
+  const det = bd[0] * ad[1] - bd[1] * ad[0];
+
+  if (det != 0) {
+    // near parallel line will yield noisy results
+    const u = (dy * bd[0] - dx * bd[1]) / det;
+    const v = (dy * ad[0] - dx * ad[1]) / det;
+
+    if (u >= 0 && v >= 0) {
+      out[0] = as[0] + ad[0] * u;
+      out[1] = as[1] + ad[1] * u;
+      return true;
+    }
+  }
+  return false;
+}
+/** Generate Indices of both a Looped or Unlooped Grid, Backslash Pattern, Loops on Columns */
+function gridIndicesCol(
+  out: number[],
+  row_size: number,
+  row_cnt: number,
+  start_idx = 0,
+  do_loop = false,
+  rev_quad = false
+) {
+  const row_stop = row_cnt - 1,
+    col_stop = do_loop ? row_size : row_size - 1;
+  let row_a, row_b, r, rr, rrr, a, b, c, d;
+  for (r = 0; r < row_stop; r++) {
+    // Figure out the starting Index for the Two Rows
+    // 2nd row might loop back to starting row when Looping.
+    row_a = start_idx + row_size * r;
+    row_b = start_idx + row_size * (r + 1);
+    for (rr = 0; rr < col_stop; rr++) {
+      // Defined the Vertex Index of a Quad
+      rrr = (rr + 1) % row_size;
+      a = row_a + rr;
+      b = row_a + rrr;
+      d = row_b + rr;
+      c = row_b + rrr;
+      if (!rev_quad) out.push(a, b, c, c, d, a);
+      // Counter ClockWise
+      else out.push(a, d, c, c, b, a);
+    }
+  }
+}
+function fanIndices(
+  out: number[],
+  midIdx: number,
+  edgeStart: number,
+  edgeEnd: number,
+  rev_quad = false
+) {
+  const len = edgeEnd - edgeStart + 1;
+  let i, ii;
+  for (i = 0; i < len; i++) {
+    ii = (i + 1) % len; // Next Point on the edge
+    if (!rev_quad) out.push(midIdx, edgeStart + i, edgeStart + ii);
+    // Counter ClockWise
+    else out.push(midIdx, edgeStart + ii, edgeStart + i);
+  }
+}
+export default HexagonPillar;