@wcardinal/wcardinal-ui 0.467.1 → 0.468.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (84) hide show
  1. package/dist/types/wcardinal/ui/shape/e-shape-type.d.ts +1 -0
  2. package/dist/types/wcardinal/ui/shape/load/index.d.ts +1 -0
  3. package/dist/types/wcardinal/ui/shape/load/load-shape-triangle-rounded-legacy.d.ts +1 -0
  4. package/dist/types/wcardinal/ui/shape/variant/build-triangle-rounded-legacy.d.ts +10 -0
  5. package/dist/types/wcardinal/ui/shape/variant/build-triangle-rounded.d.ts +1 -10
  6. package/dist/types/wcardinal/ui/shape/variant/builder-triangle-rounded-legacy.d.ts +12 -0
  7. package/dist/types/wcardinal/ui/shape/variant/builder-triangle-rounded.d.ts +1 -12
  8. package/dist/types/wcardinal/ui/shape/variant/create-triangle-rounded-legacy-uploaded.d.ts +4 -0
  9. package/dist/types/wcardinal/ui/shape/variant/create-triangle-rounded-uploaded.d.ts +1 -4
  10. package/dist/types/wcardinal/ui/shape/variant/deserialize-triangle-rounded-legacy.d.ts +4 -0
  11. package/dist/types/wcardinal/ui/shape/variant/e-shape-circle-triangulated-impl.d.ts +2 -0
  12. package/dist/types/wcardinal/ui/shape/variant/e-shape-line-of-triangle-roundeds.d.ts +2 -2
  13. package/dist/types/wcardinal/ui/shape/variant/e-shape-rectangle-rounded-triangulated-impl.d.ts +18 -18
  14. package/dist/types/wcardinal/ui/shape/variant/e-shape-triangle-rounded-legacy.d.ts +7 -0
  15. package/dist/types/wcardinal/ui/shape/variant/e-shape-triangle-rounded-triangulated-impl.d.ts +42 -0
  16. package/dist/types/wcardinal/ui/shape/variant/e-shape-triangle-rounded-triangulated.d.ts +3 -0
  17. package/dist/types/wcardinal/ui/shape/variant/e-shape-triangle-rounded.d.ts +4 -0
  18. package/dist/types/wcardinal/ui/shape/variant/hit-test-triangle-rounded.d.ts +1 -0
  19. package/dist/types/wcardinal/ui/shape/variant/index.d.ts +7 -0
  20. package/dist/wcardinal/ui/shape/e-shape-type.js +1 -0
  21. package/dist/wcardinal/ui/shape/e-shape-type.js.map +1 -1
  22. package/dist/wcardinal/ui/shape/load/index.js +1 -0
  23. package/dist/wcardinal/ui/shape/load/index.js.map +1 -1
  24. package/dist/wcardinal/ui/shape/load/load-shape-all.js +2 -0
  25. package/dist/wcardinal/ui/shape/load/load-shape-all.js.map +1 -1
  26. package/dist/wcardinal/ui/shape/load/load-shape-triangle-rounded-legacy.js +17 -0
  27. package/dist/wcardinal/ui/shape/load/load-shape-triangle-rounded-legacy.js.map +1 -0
  28. package/dist/wcardinal/ui/shape/load/load-shape-triangle-rounded.js +2 -2
  29. package/dist/wcardinal/ui/shape/load/load-shape-triangle-rounded.js.map +1 -1
  30. package/dist/wcardinal/ui/shape/variant/build-rectangle-legacy.js +4 -0
  31. package/dist/wcardinal/ui/shape/variant/build-rectangle-legacy.js.map +1 -1
  32. package/dist/wcardinal/ui/shape/variant/build-rectangle-rounded-legacy.js +20 -19
  33. package/dist/wcardinal/ui/shape/variant/build-rectangle-rounded-legacy.js.map +1 -1
  34. package/dist/wcardinal/ui/shape/variant/build-triangle-legacy.js +4 -0
  35. package/dist/wcardinal/ui/shape/variant/build-triangle-legacy.js.map +1 -1
  36. package/dist/wcardinal/ui/shape/variant/build-triangle-rounded-legacy.js +538 -0
  37. package/dist/wcardinal/ui/shape/variant/build-triangle-rounded-legacy.js.map +1 -0
  38. package/dist/wcardinal/ui/shape/variant/build-triangle-rounded.js +5 -536
  39. package/dist/wcardinal/ui/shape/variant/build-triangle-rounded.js.map +1 -1
  40. package/dist/wcardinal/ui/shape/variant/builder-triangle-rounded-legacy.js +84 -0
  41. package/dist/wcardinal/ui/shape/variant/builder-triangle-rounded-legacy.js.map +1 -0
  42. package/dist/wcardinal/ui/shape/variant/builder-triangle-rounded.js +1 -79
  43. package/dist/wcardinal/ui/shape/variant/builder-triangle-rounded.js.map +1 -1
  44. package/dist/wcardinal/ui/shape/variant/create-triangle-rounded-legacy-uploaded.js +24 -0
  45. package/dist/wcardinal/ui/shape/variant/create-triangle-rounded-legacy-uploaded.js.map +1 -0
  46. package/dist/wcardinal/ui/shape/variant/create-triangle-rounded-uploaded.js +1 -19
  47. package/dist/wcardinal/ui/shape/variant/create-triangle-rounded-uploaded.js.map +1 -1
  48. package/dist/wcardinal/ui/shape/variant/deserialize-triangle-rounded-legacy.js +10 -0
  49. package/dist/wcardinal/ui/shape/variant/deserialize-triangle-rounded-legacy.js.map +1 -0
  50. package/dist/wcardinal/ui/shape/variant/e-shape-circle-triangulated-impl.js +134 -199
  51. package/dist/wcardinal/ui/shape/variant/e-shape-circle-triangulated-impl.js.map +1 -1
  52. package/dist/wcardinal/ui/shape/variant/e-shape-line-of-triangle-roundeds.js +2 -2
  53. package/dist/wcardinal/ui/shape/variant/e-shape-line-of-triangle-roundeds.js.map +1 -1
  54. package/dist/wcardinal/ui/shape/variant/e-shape-rectangle-rounded-triangulated-impl.js +62 -64
  55. package/dist/wcardinal/ui/shape/variant/e-shape-rectangle-rounded-triangulated-impl.js.map +1 -1
  56. package/dist/wcardinal/ui/shape/variant/e-shape-triangle-rounded-legacy.js +27 -0
  57. package/dist/wcardinal/ui/shape/variant/e-shape-triangle-rounded-legacy.js.map +1 -0
  58. package/dist/wcardinal/ui/shape/variant/e-shape-triangle-rounded-triangulated-impl.js +437 -0
  59. package/dist/wcardinal/ui/shape/variant/e-shape-triangle-rounded-triangulated-impl.js.map +1 -0
  60. package/dist/wcardinal/ui/shape/variant/e-shape-triangle-rounded-triangulated.js +6 -0
  61. package/dist/wcardinal/ui/shape/variant/e-shape-triangle-rounded-triangulated.js.map +1 -0
  62. package/dist/wcardinal/ui/shape/variant/e-shape-triangle-rounded.js +15 -2
  63. package/dist/wcardinal/ui/shape/variant/e-shape-triangle-rounded.js.map +1 -1
  64. package/dist/wcardinal/ui/shape/variant/hit-test-triangle-rounded.js +71 -11
  65. package/dist/wcardinal/ui/shape/variant/hit-test-triangle-rounded.js.map +1 -1
  66. package/dist/wcardinal/ui/shape/variant/index.js +7 -0
  67. package/dist/wcardinal/ui/shape/variant/index.js.map +1 -1
  68. package/dist/wcardinal-ui-theme-dark-en-us.js +1 -1
  69. package/dist/wcardinal-ui-theme-dark-en-us.min.js +1 -1
  70. package/dist/wcardinal-ui-theme-dark-ja-jp.js +1 -1
  71. package/dist/wcardinal-ui-theme-dark-ja-jp.min.js +1 -1
  72. package/dist/wcardinal-ui-theme-dark.js +1 -1
  73. package/dist/wcardinal-ui-theme-dark.min.js +1 -1
  74. package/dist/wcardinal-ui-theme-white-en-us.js +1 -1
  75. package/dist/wcardinal-ui-theme-white-en-us.min.js +1 -1
  76. package/dist/wcardinal-ui-theme-white-ja-jp.js +1 -1
  77. package/dist/wcardinal-ui-theme-white-ja-jp.min.js +1 -1
  78. package/dist/wcardinal-ui-theme-white.js +1 -1
  79. package/dist/wcardinal-ui-theme-white.min.js +1 -1
  80. package/dist/wcardinal-ui.cjs.js +891 -385
  81. package/dist/wcardinal-ui.js +891 -385
  82. package/dist/wcardinal-ui.min.js +2 -2
  83. package/dist/wcardinal-ui.min.js.map +1 -1
  84. package/package.json +1 -1
@@ -1,5 +1,5 @@
1
1
  /*!
2
- Winter Cardinal UI v0.467.1
2
+ Winter Cardinal UI v0.468.0
3
3
  Copyright (C) 2019-2026 Toshiba Corporation
4
4
  SPDX-License-Identifier: Apache-2.0
5
5
 
@@ -58,6 +58,7 @@
58
58
  RECTANGLE_LEGACY: 28,
59
59
  TRIANGLE_LEGACY: 29,
60
60
  RECTANGLE_ROUNDED_LEGACY: 30,
61
+ TRIANGLE_ROUNDED_LEGACY: 31,
61
62
  EXTENSION: 1000
62
63
  };
63
64
 
@@ -40628,7 +40629,7 @@
40628
40629
  boundary[3] = +ay;
40629
40630
  // # of vertices and # of indices
40630
40631
  var n = this._n >> 2;
40631
- var nv = 8 * n + 18;
40632
+ var nv = 12 * n + 10;
40632
40633
  var ni = 4 * n + 10;
40633
40634
  this._nvertices = nv;
40634
40635
  this._nindices = ni;
@@ -41258,7 +41259,7 @@
41258
41259
  * Preconditions:
41259
41260
  * * shape.stroke.side === EShapeStrokeSide.TOP_OR_RIGHT
41260
41261
  * * ay <= ax
41261
- * * 5 * N + 5 <= nv
41262
+ * * 6 * N + 3 <= nv
41262
41263
  * * 4 * N + 1 <= ni
41263
41264
  */
41264
41265
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateTopRight0 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -41269,7 +41270,7 @@
41269
41270
  * Preconditions:
41270
41271
  * * shape.stroke.side === EShapeStrokeSide.TOP_OR_RIGHT
41271
41272
  * * ax < ay
41272
- * * 5 * N + 5 <= nv
41273
+ * * 6 * N + 3 <= nv
41273
41274
  * * 4 * N + 1 <= ni
41274
41275
  */
41275
41276
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateTopRight1 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -41401,7 +41402,7 @@
41401
41402
  if (ctr) {
41402
41403
  var lo = lot + 2 * ax - r;
41403
41404
  this.writeFan(+ax - r, -ay + r, 0, -1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
41404
- iv += 2 * n - 1;
41405
+ iv += 3 * (n - 1);
41405
41406
  ii += 3 * (n - 1);
41406
41407
  }
41407
41408
  this.pad(iv, ii, nv, ni, fd);
@@ -41410,7 +41411,7 @@
41410
41411
  * Preconditions:
41411
41412
  * * shape.stroke.side === EShapeStrokeSide.BOTTOM_OR_LEFT
41412
41413
  * * ay <= ax
41413
- * * 5 * N + 5 <= nv
41414
+ * * 6 * N + 3 <= nv
41414
41415
  * * 4 * N + 1 <= ni
41415
41416
  */
41416
41417
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateBottomLeft0 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -41421,7 +41422,7 @@
41421
41422
  * Preconditions:
41422
41423
  * * shape.stroke.side === EShapeStrokeSide.BOTTOM_OR_LEFT
41423
41424
  * * ax < ay
41424
- * * 5 * N + 5 <= nv
41425
+ * * 6 * N + 3 <= nv
41425
41426
  * * 4 * N + 1 <= ni
41426
41427
  */
41427
41428
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateBottomLeft1 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -41555,7 +41556,7 @@
41555
41556
  if (cbl) {
41556
41557
  var lo = lob + 2 * ax - r;
41557
41558
  this.writeFan(-ax + r, +ay - r, 0, 1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
41558
- iv += 2 * n - 1;
41559
+ iv += 3 * (n - 1);
41559
41560
  ii += 3 * (n - 1);
41560
41561
  }
41561
41562
  this.pad(iv, ii, nv, ni, fd);
@@ -41572,7 +41573,7 @@
41572
41573
  * Preconditions:
41573
41574
  * * shape.stroke.side === EShapeStrokeSide.TOP_OR_LEFT
41574
41575
  * * ay <= ax
41575
- * * 5 * N + 5 <= nv
41576
+ * * 6 * N + 3 <= nv
41576
41577
  * * 4 * N + 1 <= ni
41577
41578
  */
41578
41579
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateTopLeft0 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -41583,7 +41584,7 @@
41583
41584
  * Preconditions:
41584
41585
  * * shape.stroke.side === EShapeStrokeSide.TOP_OR_LEFT
41585
41586
  * * ax < ay
41586
- * * 5 * N + 5 <= nv
41587
+ * * 6 * N + 3 <= nv
41587
41588
  * * 4 * N + 1 <= ni
41588
41589
  */
41589
41590
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateTopLeft1 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -41729,7 +41730,7 @@
41729
41730
  if (ctl) {
41730
41731
  var lo = lol + 2 * ay - r;
41731
41732
  this.writeFan(-ax + r, -ay + r, -1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
41732
- iv += 2 * n - 1;
41733
+ iv += 3 * (n - 1);
41733
41734
  ii += 3 * (n - 1);
41734
41735
  }
41735
41736
  this.pad(iv, ii, nv, ni, fd);
@@ -41738,7 +41739,7 @@
41738
41739
  * Preconditions:
41739
41740
  * * shape.stroke.side === EShapeStrokeSide.BOTTOM_OR_RIGHT
41740
41741
  * * ay <= ax
41741
- * * 5 * N + 5 <= nv
41742
+ * * 6 * N + 3 <= nv
41742
41743
  * * 4 * N + 1 <= ni
41743
41744
  */
41744
41745
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateBottomRight0 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -41749,7 +41750,7 @@
41749
41750
  * Preconditions:
41750
41751
  * * shape.stroke.side === EShapeStrokeSide.BOTTOM_OR_RIGHT
41751
41752
  * * ax < ay
41752
- * * 5 * N + 5 <= nv
41753
+ * * 6 * N + 3 <= nv
41753
41754
  * * 4 * N + 1 <= ni
41754
41755
  */
41755
41756
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateBottomRight1 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -41892,7 +41893,7 @@
41892
41893
  if (cbr) {
41893
41894
  var lo = lor + 2 * ay - r;
41894
41895
  this.writeFan(+ax - r, +ay - r, 1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
41895
- iv += 2 * n - 1;
41896
+ iv += 3 * (n - 1);
41896
41897
  ii += 3 * (n - 1);
41897
41898
  }
41898
41899
  this.pad(iv, ii, nv, ni, fd);
@@ -41901,7 +41902,7 @@
41901
41902
  * Preconditions:
41902
41903
  * * shape.stroke.side === EShapeStrokeSide.NOT_TOP
41903
41904
  * * ay <= ax
41904
- * * 6 * N + 12 <= nv
41905
+ * * 8 * N + 8 <= nv
41905
41906
  * * 4 * N + 6 <= ni
41906
41907
  */
41907
41908
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateNotTop0 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -41944,13 +41945,13 @@
41944
41945
  if (cbl) {
41945
41946
  var lo = lob + 2 * ax - r;
41946
41947
  this.writeFan(-ax + r, +ay - r, 0, 1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
41947
- iv += 2 * n - 1;
41948
+ iv += 3 * (n - 1);
41948
41949
  ii += 3 * (n - 1);
41949
41950
  }
41950
41951
  if (cbr) {
41951
41952
  var lo = lor + 2 * ay - r;
41952
41953
  this.writeFan(+ax - r, +ay - r, 1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
41953
- iv += 2 * n - 1;
41954
+ iv += 3 * (n - 1);
41954
41955
  ii += 3 * (n - 1);
41955
41956
  }
41956
41957
  this.pad(iv, ii, nv, ni, fd);
@@ -41959,7 +41960,7 @@
41959
41960
  * Preconditions:
41960
41961
  * * shape.stroke.side === EShapeStrokeSide.NOT_TOP
41961
41962
  * * ax < ay
41962
- * * 6 * N + 12 <= nv
41963
+ * * 8 * N + 8 <= nv
41963
41964
  * * 4 * N + 6 <= ni
41964
41965
  */
41965
41966
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateNotTop1 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -42000,13 +42001,13 @@
42000
42001
  if (cbl) {
42001
42002
  var lo = lob + 2 * ax - r;
42002
42003
  this.writeFan(-ax + r, +ay - r, 0, 1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42003
- iv += 2 * n - 1;
42004
+ iv += 3 * (n - 1);
42004
42005
  ii += 3 * (n - 1);
42005
42006
  }
42006
42007
  if (cbr) {
42007
42008
  var lo = lor + 2 * ay - r;
42008
42009
  this.writeFan(+ax - r, +ay - r, 1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42009
- iv += 2 * n - 1;
42010
+ iv += 3 * (n - 1);
42010
42011
  ii += 3 * (n - 1);
42011
42012
  }
42012
42013
  this.pad(iv, ii, nv, ni, fd);
@@ -42084,7 +42085,7 @@
42084
42085
  * Preconditions:
42085
42086
  * * shape.stroke.side === EShapeStrokeSide.NOT_BOTTOM
42086
42087
  * * ay <= ax
42087
- * * 6 * N + 12 <= nv
42088
+ * * 8 * N + 8 <= nv
42088
42089
  * * 4 * N + 6 <= ni
42089
42090
  */
42090
42091
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateNotBottom0 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -42133,13 +42134,13 @@
42133
42134
  if (ctl) {
42134
42135
  var lo = lol + 2 * ay - r;
42135
42136
  this.writeFan(-ax + r, -ay + r, -1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42136
- iv += 2 * n - 1;
42137
+ iv += 3 * (n - 1);
42137
42138
  ii += 3 * (n - 1);
42138
42139
  }
42139
42140
  if (ctr) {
42140
42141
  var lo = lot + 2 * ax - r;
42141
42142
  this.writeFan(+ax - r, -ay + r, 0, -1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42142
- iv += 2 * n - 1;
42143
+ iv += 3 * (n - 1);
42143
42144
  ii += 3 * (n - 1);
42144
42145
  }
42145
42146
  this.pad(iv, ii, nv, ni, fd);
@@ -42148,7 +42149,7 @@
42148
42149
  * Preconditions:
42149
42150
  * * shape.stroke.side === EShapeStrokeSide.NOT_BOTTOM
42150
42151
  * * ax < ay
42151
- * * 6 * N + 12 <= nv
42152
+ * * 8 * N + 8 <= nv
42152
42153
  * * 4 * N + 6 <= ni
42153
42154
  */
42154
42155
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateNotBottom1 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -42196,13 +42197,13 @@
42196
42197
  if (ctl) {
42197
42198
  var lo = lol + 2 * ay - r;
42198
42199
  this.writeFan(-ax + r, -ay + r, -1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42199
- iv += 2 * n - 1;
42200
+ iv += 3 * (n - 1);
42200
42201
  ii += 3 * (n - 1);
42201
42202
  }
42202
42203
  if (ctr) {
42203
42204
  var lo = lot + 2 * ax - r;
42204
42205
  this.writeFan(+ax - r, -ay + r, 0, -1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42205
- iv += 2 * n - 1;
42206
+ iv += 3 * (n - 1);
42206
42207
  ii += 3 * (n - 1);
42207
42208
  }
42208
42209
  this.pad(iv, ii, nv, ni, fd);
@@ -42277,7 +42278,7 @@
42277
42278
  * Preconditions:
42278
42279
  * * shape.stroke.side === EShapeStrokeSide.NOT_LEFT
42279
42280
  * * ay <= ax
42280
- * * 6 * N + 12 <= nv
42281
+ * * 8 * N + 8 <= nv
42281
42282
  * * 4 * N + 6 <= ni
42282
42283
  */
42283
42284
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateNotLeft0 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -42324,13 +42325,13 @@
42324
42325
  if (ctr) {
42325
42326
  var lo = lot + 2 * ax - r;
42326
42327
  this.writeFan(+ax - r, -ay + r, 0, -1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42327
- iv += 2 * n - 1;
42328
+ iv += 3 * (n - 1);
42328
42329
  ii += 3 * (n - 1);
42329
42330
  }
42330
42331
  if (cbr) {
42331
42332
  var lo = lor + 2 * ay - r;
42332
42333
  this.writeFan(+ax - r, +ay - r, 1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42333
- iv += 2 * n - 1;
42334
+ iv += 3 * (n - 1);
42334
42335
  ii += 3 * (n - 1);
42335
42336
  }
42336
42337
  this.pad(iv, ii, nv, ni, fd);
@@ -42339,7 +42340,7 @@
42339
42340
  * Preconditions:
42340
42341
  * * shape.stroke.side === EShapeStrokeSide.NOT_LEFT
42341
42342
  * * ax < ay
42342
- * * 6 * N + 12 <= nv
42343
+ * * 8 * N + 8 <= nv
42343
42344
  * * 4 * N + 6 <= ni
42344
42345
  */
42345
42346
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateNotLeft1 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -42387,13 +42388,13 @@
42387
42388
  if (ctr) {
42388
42389
  var lo = lot + 2 * ax - r;
42389
42390
  this.writeFan(+ax - r, -ay + r, 0, -1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42390
- iv += 2 * n - 1;
42391
+ iv += 3 * (n - 1);
42391
42392
  ii += 3 * (n - 1);
42392
42393
  }
42393
42394
  if (cbr) {
42394
42395
  var lo = lor + 2 * ay - r;
42395
42396
  this.writeFan(+ax - r, +ay - r, 1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42396
- iv += 2 * n - 1;
42397
+ iv += 3 * (n - 1);
42397
42398
  ii += 3 * (n - 1);
42398
42399
  }
42399
42400
  this.pad(iv, ii, nv, ni, fd);
@@ -42468,7 +42469,7 @@
42468
42469
  * Preconditions:
42469
42470
  * * shape.stroke.side === EShapeStrokeSide.NOT_RIGHT
42470
42471
  * * ay <= ax
42471
- * * 6 * N + 12 <= nv
42472
+ * * 8 * N + 8 <= nv
42472
42473
  * * 4 * N + 6 <= ni
42473
42474
  */
42474
42475
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateNotRight0 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -42509,13 +42510,13 @@
42509
42510
  if (ctl) {
42510
42511
  var lo = lol + 2 * ay - r;
42511
42512
  this.writeFan(-ax + r, -ay + r, -1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42512
- iv += 2 * n - 1;
42513
+ iv += 3 * (n - 1);
42513
42514
  ii += 3 * (n - 1);
42514
42515
  }
42515
42516
  if (cbl) {
42516
42517
  var lo = lob + 2 * ax - r;
42517
42518
  this.writeFan(-ax + r, +ay - r, 0, 1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42518
- iv += 2 * n - 1;
42519
+ iv += 3 * (n - 1);
42519
42520
  ii += 3 * (n - 1);
42520
42521
  }
42521
42522
  this.pad(iv, ii, nv, ni, fd);
@@ -42524,7 +42525,7 @@
42524
42525
  * Preconditions:
42525
42526
  * * shape.stroke.side === EShapeStrokeSide.NOT_RIGHT
42526
42527
  * * ax < ay
42527
- * * 6 * N + 12 <= nv
42528
+ * * 8 * N + 8 <= nv
42528
42529
  * * 4 * N + 6 <= ni
42529
42530
  */
42530
42531
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateNotRight1 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -42566,13 +42567,13 @@
42566
42567
  if (ctl) {
42567
42568
  var lo = lol + 2 * ay - r;
42568
42569
  this.writeFan(-ax + r, -ay + r, -1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42569
- iv += 2 * n - 1;
42570
+ iv += 3 * (n - 1);
42570
42571
  ii += 3 * (n - 1);
42571
42572
  }
42572
42573
  if (cbl) {
42573
42574
  var lo = lob + 2 * ax - r;
42574
42575
  this.writeFan(-ax + r, +ay - r, 0, 1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42575
- iv += 2 * n - 1;
42576
+ iv += 3 * (n - 1);
42576
42577
  ii += 3 * (n - 1);
42577
42578
  }
42578
42579
  this.pad(iv, ii, nv, ni, fd);
@@ -42647,7 +42648,7 @@
42647
42648
  * Preconditions:
42648
42649
  * * shape.stroke.side === EShapeStrokeSide.ALL or NONE
42649
42650
  * * ay <= ax
42650
- * * 8 * N + 18 <= nv
42651
+ * * 12 * N + 10 <= nv
42651
42652
  * * 4 * N + 10 <= ni
42652
42653
  */
42653
42654
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateAll0 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -42692,10 +42693,10 @@
42692
42693
  iv += 5;
42693
42694
  ii += 9;
42694
42695
  var rs = r + fs;
42695
- var l = 2 * ax + lot;
42696
+ var l = 2 * ax + lot - r;
42696
42697
  if (ctr) {
42697
42698
  this.writeFan(x4, y1, 0, -1, l, iv, ii, n, r, rs, fd, s, fx, fy);
42698
- iv += 2 * n - 1;
42699
+ iv += 3 * (n - 1);
42699
42700
  ii += 3 * (n - 1);
42700
42701
  l += 2 * ay + lc;
42701
42702
  }
@@ -42704,7 +42705,7 @@
42704
42705
  }
42705
42706
  if (cbr) {
42706
42707
  this.writeFan(x4, y4, 1, 0, l, iv, ii, n, r, rs, fd, s, fx, fy);
42707
- iv += 2 * n - 1;
42708
+ iv += 3 * (n - 1);
42708
42709
  ii += 3 * (n - 1);
42709
42710
  l += 2 * ax + lc;
42710
42711
  }
@@ -42713,7 +42714,7 @@
42713
42714
  }
42714
42715
  if (cbl) {
42715
42716
  this.writeFan(x1, y4, 0, 1, l, iv, ii, n, r, rs, fd, s, fx, fy);
42716
- iv += 2 * n - 1;
42717
+ iv += 3 * (n - 1);
42717
42718
  ii += 3 * (n - 1);
42718
42719
  l += 2 * ay + lc;
42719
42720
  }
@@ -42722,7 +42723,7 @@
42722
42723
  }
42723
42724
  if (ctl) {
42724
42725
  this.writeFan(x1, y1, -1, 0, l, iv, ii, n, r, rs, fd, s, fx, fy);
42725
- iv += 2 * n - 1;
42726
+ iv += 3 * (n - 1);
42726
42727
  ii += 3 * (n - 1);
42727
42728
  }
42728
42729
  this.pad(iv, ii, nv, ni, fd);
@@ -42731,7 +42732,7 @@
42731
42732
  * Preconditions:
42732
42733
  * * shape.stroke.side === EShapeStrokeSide.ALL or NONE
42733
42734
  * * ax < ay
42734
- * * 8 * N + 18 <= nv
42735
+ * * 12 * N + 10 <= nv
42735
42736
  * * 4 * N + 10 <= ni
42736
42737
  */
42737
42738
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateAll1 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -42776,10 +42777,10 @@
42776
42777
  this.writeHexaLeft(iv, ii, lol, cbl ? x1 : ol, cbl ? y4 : y5, ol, y4, ol, y1, ctl ? x1 : ol, ctl ? y1 : y0, 0, y2, 0, y3, fd, s, fx, fy, ax, ay);
42777
42778
  iv += 6;
42778
42779
  ii += 12;
42779
- var l = 2 * ax + lot;
42780
+ var l = 2 * ax + lot - r;
42780
42781
  if (ctr) {
42781
42782
  this.writeFan(x4, y1, 0, -1, l, iv, ii, n, r, rs, fd, s, fx, fy);
42782
- iv += 1 + 2 * (n - 1);
42783
+ iv += 3 * (n - 1);
42783
42784
  ii += 3 * (n - 1);
42784
42785
  l += 2 * ay + lc;
42785
42786
  }
@@ -42788,7 +42789,7 @@
42788
42789
  }
42789
42790
  if (cbr) {
42790
42791
  this.writeFan(x4, y4, 1, 0, l, iv, ii, n, r, rs, fd, s, fx, fy);
42791
- iv += 1 + 2 * (n - 1);
42792
+ iv += 3 * (n - 1);
42792
42793
  ii += 3 * (n - 1);
42793
42794
  l += 2 * ax + lc;
42794
42795
  }
@@ -42797,7 +42798,7 @@
42797
42798
  }
42798
42799
  if (cbl) {
42799
42800
  this.writeFan(x1, y4, 0, 1, l, iv, ii, n, r, rs, fd, s, fx, fy);
42800
- iv += 1 + 2 * (n - 1);
42801
+ iv += 3 * (n - 1);
42801
42802
  ii += 3 * (n - 1);
42802
42803
  l += 2 * ay + lc;
42803
42804
  }
@@ -42806,7 +42807,7 @@
42806
42807
  }
42807
42808
  if (ctl) {
42808
42809
  this.writeFan(x1, y1, -1, 0, l, iv, ii, n, r, rs, fd, s, fx, fy);
42809
- iv += 1 + 2 * (n - 1);
42810
+ iv += 3 * (n - 1);
42810
42811
  ii += 3 * (n - 1);
42811
42812
  }
42812
42813
  this.pad(iv, ii, nv, ni, fd);
@@ -43079,29 +43080,27 @@
43079
43080
  var dangle = (Math.PI * 0.5) / (n - 1);
43080
43081
  var c = Math.cos(dangle);
43081
43082
  var s = Math.sin(dangle);
43082
- var dl = 0.5 * r * dangle;
43083
+ var dl = r * dangle;
43084
+ // Rim vertices at radius rs sit dl / 2 * (rs / r) from the chord midpoint, so the length is exact at radius r.
43085
+ var dlm = 0.5 * dl * (rs / r - 1);
43086
+ var cc = 1 - r * fd;
43087
+ var indices = this._indices;
43083
43088
  var dx = rs * cos0;
43084
43089
  var dy = rs * sin0;
43085
- var iv0 = iv++;
43086
43090
  var l = lo;
43087
- this.writeVertex(iv0, cx + dx, cy + dy, fd, lo, scale, fx, fy);
43088
- var indices = this._indices;
43089
- var cc = 1 - r * fd;
43090
43091
  for (var i = 0; i < n - 1; ++i) {
43091
- var iv1 = iv++;
43092
- l += dl;
43093
- this.writeVertex(iv1, cx, cy, fd, l, cc, fx, fy);
43094
- var iv2 = iv++;
43095
- l += dl;
43096
43092
  var ndx = c * dx - s * dy;
43097
43093
  var ndy = s * dx + c * dy;
43098
- this.writeVertex(iv2, cx + ndx, cy + ndy, fd, l, scale, fx, fy);
43094
+ this.writeVertex(iv + 0, cx + dx, cy + dy, fd, l - dlm, scale, fx, fy);
43095
+ this.writeVertex(iv + 1, cx + ndx, cy + ndy, fd, l + dl + dlm, scale, fx, fy);
43096
+ this.writeVertex(iv + 2, cx, cy, fd, l + 0.5 * dl, cc, fx, fy);
43097
+ indices[ii++] = iv + 2;
43098
+ indices[ii++] = iv + 0;
43099
+ indices[ii++] = iv + 1;
43100
+ iv += 3;
43101
+ l += dl;
43099
43102
  dx = ndx;
43100
43103
  dy = ndy;
43101
- indices[ii++] = iv1;
43102
- indices[ii++] = iv0;
43103
- indices[ii++] = iv2;
43104
- iv0 = iv2;
43105
43104
  }
43106
43105
  };
43107
43106
  EShapeRectangleRoundedTriangulatedImpl.prototype.writeVertexTop = function (vertex, x, y, lengthOffset, fdistance, scale, fx, fy, ax, ay) {
@@ -43873,6 +43872,7 @@
43873
43872
  this._nvertices = 0;
43874
43873
  this._distances = [];
43875
43874
  this._lengths = [];
43875
+ this._lengthShifts = [];
43876
43876
  this._clippings = [];
43877
43877
  this._uvs = [];
43878
43878
  this._indices = [];
@@ -43999,7 +43999,7 @@
43999
43999
  boundary[2] = +ax;
44000
44000
  boundary[3] = +ay;
44001
44001
  // # of vertices and # of indices
44002
- var nv = 3 * n - 3;
44002
+ var nv = 4 * n - 4;
44003
44003
  var ni = 2 * n - 4;
44004
44004
  this._nvertices = nv;
44005
44005
  this._nindices = ni;
@@ -44064,83 +44064,56 @@
44064
44064
  var dangle = (2 * Math.PI) / n;
44065
44065
  var c = Math.cos(dangle);
44066
44066
  var s = Math.sin(dangle);
44067
- // First Edge
44068
- var x0 = 0;
44069
- var y0 = sizeY;
44070
- var u = -s;
44071
- var v = c;
44072
- var su = scale * u;
44073
- var sv = scale * v;
44074
- var x1 = u * sizeX;
44075
- var y1 = v * sizeY;
44076
- var dx = 0.5 * (x1 + x0) - 0;
44077
- var dy = 0.5 * (y1 + y0) - 0;
44078
- var fdistance = 1 / Math.sqrt(dx * dx + dy * dy);
44079
- var lx = x1 - x0;
44080
- var ly = y1 - y0;
44081
- var dl = Math.sqrt(lx * lx + ly * ly);
44082
- var l1 = dl;
44083
- var l2 = 0.5 * dl;
44084
- vertices[0] = 0;
44085
- vertices[1] = scale * sizeY;
44086
- vertices[2] = su * sizeX;
44087
- vertices[3] = sv * sizeY;
44088
- vertices[4] = 0;
44089
- vertices[5] = 0;
44090
- distances[0] = fdistance;
44091
- distances[1] = fdistance;
44092
- distances[2] = fdistance;
44093
- clippings[0] = scale;
44094
- clippings[1] = scale;
44095
- clippings[2] = 0;
44096
- lengths[0] = 0;
44097
- lengths[1] = l1;
44098
- lengths[2] = l2;
44099
- uvs[0] = 0.5;
44100
- uvs[1] = 0.5 * (scale + 1);
44101
- uvs[2] = 0.5 * (su + 1);
44102
- uvs[3] = 0.5 * (sv + 1);
44103
- uvs[4] = 0.5;
44104
- uvs[5] = 0.5;
44105
- indices[0] = 0;
44106
- indices[1] = 1;
44107
- indices[2] = 2;
44108
- // The Other Edges
44109
- var iv1 = 3;
44110
- var iv2 = 6;
44111
- var ii = 3;
44112
- for (var i = 2; i <= n; ++i) {
44113
- var un = c * u - s * v;
44114
- var vn = s * u + c * v;
44115
- u = un;
44116
- v = vn;
44117
- su = scale * u;
44118
- sv = scale * v;
44119
- l1 += dl;
44120
- l2 += dl;
44121
- vertices[iv2 + 0] = su * sizeX;
44122
- vertices[iv2 + 1] = sv * sizeY;
44123
- vertices[iv2 + 2] = 0;
44124
- vertices[iv2 + 3] = 0;
44125
- distances[iv1 + 0] = fdistance;
44126
- distances[iv1 + 1] = fdistance;
44127
- clippings[iv1 + 0] = scale;
44128
- clippings[iv1 + 1] = 0;
44129
- lengths[iv1 + 0] = l1;
44130
- lengths[iv1 + 1] = l2;
44131
- uvs[iv2 + 0] = 0.5 * (su + 1);
44132
- uvs[iv2 + 1] = 0.5 * (sv + 1);
44133
- uvs[iv2 + 2] = 0.5;
44134
- uvs[iv2 + 3] = 0.5;
44135
- indices[ii + 0] = iv1 - 2;
44136
- indices[ii + 1] = iv1;
44137
- indices[ii + 2] = iv1 + 1;
44138
- iv1 += 2;
44139
- iv2 += 4;
44067
+ // Edge length and apothem of the unscaled polygon
44068
+ var ex = -s * sizeX;
44069
+ var ey = (c - 1) * sizeY;
44070
+ var dl = Math.sqrt(ex * ex + ey * ey);
44071
+ var mx = 0.5 * ex;
44072
+ var my = 0.5 * (c + 1) * sizeY;
44073
+ var fdistance = 1 / Math.sqrt(mx * mx + my * my);
44074
+ // Half edge length at clipping = scale
44075
+ var hl = 0.5 * scale * dl;
44076
+ // Each triangle owns its vertices so that the lengths are exact at clipping = 1 on both sides.
44077
+ var u0 = 0;
44078
+ var v0 = scale;
44079
+ var iv = 0;
44080
+ var ii = 0;
44081
+ for (var i = 0; i < n; ++i) {
44082
+ var u1 = c * u0 - s * v0;
44083
+ var v1 = s * u0 + c * v0;
44084
+ var lm = (i + 0.5) * dl;
44085
+ var iv2 = iv << 1;
44086
+ vertices[iv2 + 0] = u0 * sizeX;
44087
+ vertices[iv2 + 1] = v0 * sizeY;
44088
+ vertices[iv2 + 2] = u1 * sizeX;
44089
+ vertices[iv2 + 3] = v1 * sizeY;
44090
+ vertices[iv2 + 4] = 0;
44091
+ vertices[iv2 + 5] = 0;
44092
+ distances[iv + 0] = fdistance;
44093
+ distances[iv + 1] = fdistance;
44094
+ distances[iv + 2] = fdistance;
44095
+ clippings[iv + 0] = scale;
44096
+ clippings[iv + 1] = scale;
44097
+ clippings[iv + 2] = 0;
44098
+ lengths[iv + 0] = lm - hl;
44099
+ lengths[iv + 1] = lm + hl;
44100
+ lengths[iv + 2] = lm;
44101
+ uvs[iv2 + 0] = 0.5 * (u0 + 1);
44102
+ uvs[iv2 + 1] = 0.5 * (v0 + 1);
44103
+ uvs[iv2 + 2] = 0.5 * (u1 + 1);
44104
+ uvs[iv2 + 3] = 0.5 * (v1 + 1);
44105
+ uvs[iv2 + 4] = 0.5;
44106
+ uvs[iv2 + 5] = 0.5;
44107
+ indices[ii + 0] = iv + 0;
44108
+ indices[ii + 1] = iv + 1;
44109
+ indices[ii + 2] = iv + 2;
44110
+ u0 = u1;
44111
+ v0 = v1;
44112
+ iv += 3;
44140
44113
  ii += 3;
44141
44114
  }
44142
44115
  // Degenerate triangles keep the buffer sizes consistent with elongated circles.
44143
- this.pad(iv1, ii, nv, ni, fdistance);
44116
+ this.pad(iv, ii, nv, ni, fdistance);
44144
44117
  };
44145
44118
  /**
44146
44119
  * Precondition: sizeX !== 0 && sizeY !== 0 && abs(sizeY) < abs(sizeX)
@@ -44155,8 +44128,10 @@
44155
44128
  var dangle = (2 * Math.PI) / n;
44156
44129
  var c = Math.cos(dangle);
44157
44130
  var s = Math.sin(dangle);
44158
- var fx = sizeX / sizeY;
44159
- var fy = sizeY / sizeX;
44131
+ var fx = 1 / sizeX;
44132
+ var fy = 1 / sizeY;
44133
+ var fxy = sizeX * fy;
44134
+ var fyx = sizeY * fx;
44160
44135
  var ileft = n >> 2;
44161
44136
  var iright = ileft * 3;
44162
44137
  var ppx = sizeX * s;
@@ -44165,20 +44140,12 @@
44165
44140
  var py = sizeY;
44166
44141
  var nx = -sizeX * s;
44167
44142
  var ny = sizeY * c;
44168
- var nnx = nx * c - ny * fx * s;
44169
- var nny = nx * fy * s + ny * c;
44143
+ var nnx = nx * c - ny * fxy * s;
44144
+ var nny = nx * fyx * s + ny * c;
44170
44145
  var sx = this.toSkeletonX(ppx, ppy, px, py, nx, ny);
44171
- vertices[0] = 0;
44172
- vertices[1] = sizeY;
44173
- clippings[0] = -1;
44174
- distances[0] = sx;
44175
- lengths[0] = 0;
44176
- uvs[0] = 0.5;
44177
- uvs[1] = 1;
44178
- var iv = 1;
44146
+ var iv = 0;
44179
44147
  var ii = 0;
44180
- var length = 0;
44181
- var current = 0;
44148
+ var l = 0;
44182
44149
  var maxDistance = 0;
44183
44150
  for (var i = 0; i < n; ++i) {
44184
44151
  var inext = (i + 1) % n;
@@ -44194,59 +44161,38 @@
44194
44161
  var dy = ny - py;
44195
44162
  var dl = Math.sqrt(dx * dx + dy * dy);
44196
44163
  var fl = 1 / dl;
44197
- var nlength = length + dl;
44198
- var iv1 = iv++;
44199
- var iv2 = iv1 << 1;
44200
- var niv1 = iv++;
44201
- var niv2 = niv1 << 1;
44202
- var ndistance = Math.abs(-dx * py - dy * (nsx - px)) * fl;
44203
- maxDistance = Math.max(maxDistance, ndistance);
44204
- vertices[iv2 + 0] = nx;
44205
- vertices[iv2 + 1] = ny;
44206
- clippings[iv1] = -1 - ndistance;
44207
- distances[iv1] = nsx;
44208
- lengths[iv1] = nlength;
44209
- uvs[iv2 + 0] = 0.5 * (nx / sizeX + 1);
44210
- uvs[iv2 + 1] = 0.5 * (ny / sizeY + 1);
44211
- vertices[niv2 + 0] = nsx;
44212
- vertices[niv2 + 1] = 0;
44213
- clippings[niv1] = ndistance;
44214
- distances[niv1] = 0;
44215
- lengths[niv1] = length + ((nsx - px) * dx - py * dy) * fl;
44216
- uvs[niv2] = 0.5 * (nsx / sizeX + 1);
44217
- uvs[niv2 + 1] = 0.5;
44218
- indices[ii++] = current;
44219
- indices[ii++] = iv1;
44220
- indices[ii++] = niv1;
44221
- distances[current] = sx;
44222
- if (sx === nsx) {
44223
- clippings[current] = -1 - ndistance;
44224
- }
44225
- else {
44226
- var mdistance = Math.abs(-dx * py - dy * (sx - px)) * fl;
44227
- maxDistance = Math.max(maxDistance, mdistance);
44228
- clippings[current] = -1 - mdistance;
44229
- var miv1 = iv++;
44230
- var miv2 = miv1 << 1;
44231
- vertices[miv2] = sx;
44232
- vertices[miv2 + 1] = 0;
44233
- clippings[miv1] = mdistance;
44234
- distances[miv1] = 0;
44235
- lengths[miv1] = length + ((sx - px) * dx - py * dy) * fl;
44236
- uvs[miv2] = 0.5 * (sx / sizeX + 1);
44237
- uvs[miv2 + 1] = 0.5;
44238
- indices[ii++] = current;
44239
- indices[ii++] = niv1;
44240
- indices[ii++] = miv1;
44241
- }
44242
- current = iv1;
44243
- length = nlength;
44164
+ var nl = l + dl;
44165
+ var nd = Math.abs(-dx * py - dy * (nsx - px)) * fl;
44166
+ var md = sx === nsx ? nd : Math.abs(-dx * py - dy * (sx - px)) * fl;
44167
+ maxDistance = Math.max(maxDistance, nd, md);
44168
+ // Each edge owns its vertices so that the lengths are exact at clipping = 1 on both sides.
44169
+ var iva = iv++;
44170
+ var ivb = iv++;
44171
+ var ivn = iv++;
44172
+ var ls0 = ((px - sx) * dx + py * dy) * fl;
44173
+ var ls1 = ((nx - nsx) * dx + ny * dy) * fl;
44174
+ var ls2 = ((nsx - px) * dx - py * dy) * fl;
44175
+ this.writeVertex(iva, px, py, fx, fy, sx, l, -1 - md, ls0);
44176
+ this.writeVertex(ivb, nx, ny, fx, fy, nsx, nl, -1 - nd, ls1);
44177
+ this.writeVertex(ivn, nsx, 0, fx, fy, 0, l + ls2, nd, 0);
44178
+ indices[ii++] = iva;
44179
+ indices[ii++] = ivb;
44180
+ indices[ii++] = ivn;
44181
+ if (sx !== nsx) {
44182
+ var ivm = iv++;
44183
+ var ls3 = ((sx - px) * dx - py * dy) * fl;
44184
+ this.writeVertex(ivm, sx, 0, fx, fy, 0, l + ls3, md, 0);
44185
+ indices[ii++] = iva;
44186
+ indices[ii++] = ivn;
44187
+ indices[ii++] = ivm;
44188
+ }
44189
+ l = nl;
44244
44190
  px = nx;
44245
44191
  py = ny;
44246
44192
  nx = nnx;
44247
44193
  ny = nny;
44248
- nnx = c * nx - s * ny * fx;
44249
- nny = s * nx * fy + c * ny;
44194
+ nnx = c * nx - s * ny * fxy;
44195
+ nny = s * nx * fyx + c * ny;
44250
44196
  sx = nsx;
44251
44197
  }
44252
44198
  var fdistance = 0;
@@ -44254,6 +44200,7 @@
44254
44200
  fdistance = 1 / maxDistance;
44255
44201
  }
44256
44202
  var shift = (scale - 1) * maxDistance;
44203
+ var lengthShifts = this._lengthShifts;
44257
44204
  for (var i = 0; i < iv; ++i) {
44258
44205
  var clipping = clippings[i];
44259
44206
  if (0 <= clipping) {
@@ -44266,6 +44213,7 @@
44266
44213
  var factor = shift / distance;
44267
44214
  var x = vertices[i2] + (vertices[i2] - distances[i]) * factor;
44268
44215
  var y = vertices[i2 + 1] * (1 + factor);
44216
+ lengths[i] += factor * lengthShifts[i];
44269
44217
  vertices[i2] = x;
44270
44218
  vertices[i2 + 1] = y;
44271
44219
  uvs[i2] = 0.5 * (x / sizeX + 1);
@@ -44302,8 +44250,10 @@
44302
44250
  var dangle = (2 * Math.PI) / n;
44303
44251
  var c = Math.cos(dangle);
44304
44252
  var s = Math.sin(dangle);
44305
- var fx = sizeX / sizeY;
44306
- var fy = sizeY / sizeX;
44253
+ var fx = 1 / sizeX;
44254
+ var fy = 1 / sizeY;
44255
+ var fxy = sizeX * fy;
44256
+ var fyx = sizeY * fx;
44307
44257
  var itop = 0;
44308
44258
  var ibottom = n >> 1;
44309
44259
  var ppx = sizeX * s;
@@ -44314,20 +44264,12 @@
44314
44264
  var py = sizeY;
44315
44265
  var nx = -sizeX * s;
44316
44266
  var ny = sizeY * c;
44317
- var nnx = c * nx - s * ny * fx;
44318
- var nny = s * nx * fy + c * ny;
44267
+ var nnx = c * nx - s * ny * fxy;
44268
+ var nny = s * nx * fyx + c * ny;
44319
44269
  var sy = this.toSkeletonY(pppx, pppy, ppx, ppy, px, py);
44320
- vertices[0] = 0;
44321
- vertices[1] = sizeY;
44322
- clippings[0] = -1;
44323
- distances[0] = sy;
44324
- lengths[0] = 0;
44325
- uvs[0] = 0.5;
44326
- uvs[1] = 1;
44327
- var iv = 1;
44270
+ var iv = 0;
44328
44271
  var ii = 0;
44329
- var length = 0;
44330
- var current = 0;
44272
+ var l = 0;
44331
44273
  var maxDistance = 0;
44332
44274
  for (var i = 0; i < n; ++i) {
44333
44275
  var inext = (i + 1) % n;
@@ -44343,59 +44285,38 @@
44343
44285
  var dy = ny - py;
44344
44286
  var dl = Math.sqrt(dx * dx + dy * dy);
44345
44287
  var fl = 1 / dl;
44346
- var nlength = length + dl;
44347
- var iv1 = iv++;
44348
- var iv2 = iv1 << 1;
44349
- var niv1 = iv++;
44350
- var niv2 = niv1 << 1;
44351
- var ndistance = Math.abs(dx * (nsy - py) + dy * px) * fl;
44352
- maxDistance = Math.max(maxDistance, ndistance);
44353
- vertices[iv2 + 0] = nx;
44354
- vertices[iv2 + 1] = ny;
44355
- clippings[iv1] = -1 - ndistance;
44356
- distances[iv1] = nsy;
44357
- lengths[iv1] = nlength;
44358
- uvs[iv2 + 0] = 0.5 * (nx / sizeX + 1);
44359
- uvs[iv2 + 1] = 0.5 * (ny / sizeY + 1);
44360
- vertices[niv2] = 0;
44361
- vertices[niv2 + 1] = nsy;
44362
- clippings[niv1] = ndistance;
44363
- distances[niv1] = 0;
44364
- lengths[niv1] = length + (-px * dx + (nsy - py) * dy) * fl;
44365
- uvs[niv2] = 0.5;
44366
- uvs[niv2 + 1] = 0.5 * (nsy / sizeY + 1);
44367
- indices[ii++] = current;
44368
- indices[ii++] = iv1;
44369
- indices[ii++] = niv1;
44370
- distances[current] = sy;
44371
- if (sy === nsy) {
44372
- clippings[current] = -1 - ndistance;
44373
- }
44374
- else {
44375
- var mdistance = Math.abs(dx * (sy - py) + dy * px) * fl;
44376
- maxDistance = Math.max(maxDistance, mdistance);
44377
- clippings[current] = -1 - mdistance;
44378
- var miv1 = iv++;
44379
- var miv2 = miv1 << 1;
44380
- vertices[miv2] = 0;
44381
- vertices[miv2 + 1] = sy;
44382
- clippings[miv1] = mdistance;
44383
- distances[miv1] = 0;
44384
- lengths[miv1] = length + (-px * dx + (sy - py) * dy) * fl;
44385
- uvs[miv2] = 0.5;
44386
- uvs[miv2 + 1] = 0.5 * (sy / sizeY + 1);
44387
- indices[ii++] = current;
44388
- indices[ii++] = niv1;
44389
- indices[ii++] = miv1;
44390
- }
44391
- current = iv1;
44392
- length = nlength;
44288
+ var nl = l + dl;
44289
+ var nd = Math.abs(dx * (nsy - py) + dy * px) * fl;
44290
+ var md = sy === nsy ? nd : Math.abs(dx * (sy - py) + dy * px) * fl;
44291
+ maxDistance = Math.max(maxDistance, nd, md);
44292
+ // Each edge owns its vertices so that the lengths are exact at clipping = 1 on both sides.
44293
+ var iva = iv++;
44294
+ var ivb = iv++;
44295
+ var ivn = iv++;
44296
+ var ls0 = (px * dx + (py - sy) * dy) * fl;
44297
+ var ls1 = (nx * dx + (ny - nsy) * dy) * fl;
44298
+ var ls2 = (-px * dx + (nsy - py) * dy) * fl;
44299
+ this.writeVertex(iva, px, py, fx, fy, sy, l, -1 - md, ls0);
44300
+ this.writeVertex(ivb, nx, ny, fx, fy, nsy, nl, -1 - nd, ls1);
44301
+ this.writeVertex(ivn, 0, nsy, fx, fy, 0, l + ls2, nd, 0);
44302
+ indices[ii++] = iva;
44303
+ indices[ii++] = ivb;
44304
+ indices[ii++] = ivn;
44305
+ if (sy !== nsy) {
44306
+ var ivm = iv++;
44307
+ var ls3 = (-px * dx + (sy - py) * dy) * fl;
44308
+ this.writeVertex(ivm, 0, sy, fx, fy, 0, l + ls3, md, 0);
44309
+ indices[ii++] = iva;
44310
+ indices[ii++] = ivn;
44311
+ indices[ii++] = ivm;
44312
+ }
44313
+ l = nl;
44393
44314
  px = nx;
44394
44315
  py = ny;
44395
44316
  nx = nnx;
44396
44317
  ny = nny;
44397
- nnx = c * nx - s * ny * fx;
44398
- nny = s * nx * fy + c * ny;
44318
+ nnx = c * nx - s * ny * fxy;
44319
+ nny = s * nx * fyx + c * ny;
44399
44320
  sy = nsy;
44400
44321
  }
44401
44322
  var fdistance = 0;
@@ -44403,6 +44324,7 @@
44403
44324
  fdistance = 1 / maxDistance;
44404
44325
  }
44405
44326
  var shift = (scale - 1) * maxDistance;
44327
+ var lengthShifts = this._lengthShifts;
44406
44328
  for (var i = 0; i < iv; ++i) {
44407
44329
  var clipping = clippings[i];
44408
44330
  if (0 <= clipping) {
@@ -44415,6 +44337,7 @@
44415
44337
  var factor = shift / distance;
44416
44338
  var x = vertices[i2] * (1 + factor);
44417
44339
  var y = vertices[i2 + 1] + (vertices[i2 + 1] - distances[i]) * factor;
44340
+ lengths[i] += factor * lengthShifts[i];
44418
44341
  vertices[i2] = x;
44419
44342
  vertices[i2 + 1] = y;
44420
44343
  uvs[i2] = 0.5 * (x / sizeX + 1);
@@ -44438,6 +44361,17 @@
44438
44361
  var by = pdy * fp + ndy * fn;
44439
44362
  return py - (px * by) / bx;
44440
44363
  };
44364
+ EShapeCircleTriangulatedImpl.prototype.writeVertex = function (iv, x, y, fx, fy, distance, length, clipping, lengthShift) {
44365
+ var iv2 = iv << 1;
44366
+ this._vertices[iv2] = x;
44367
+ this._vertices[iv2 + 1] = y;
44368
+ this._distances[iv] = distance;
44369
+ this._lengths[iv] = length;
44370
+ this._clippings[iv] = clipping;
44371
+ this._lengthShifts[iv] = lengthShift;
44372
+ this._uvs[iv2] = 0.5 * (x * fx + 1);
44373
+ this._uvs[iv2 + 1] = 0.5 * (y * fy + 1);
44374
+ };
44441
44375
  return EShapeCircleTriangulatedImpl;
44442
44376
  }());
44443
44377
 
@@ -45368,6 +45302,10 @@
45368
45302
  return BuilderLine;
45369
45303
  }(BuilderBase));
45370
45304
 
45305
+ /*
45306
+ * Copyright (C) 2019 Toshiba Corporation
45307
+ * SPDX-License-Identifier: Apache-2.0
45308
+ */
45371
45309
  var TRIANGLE_LEGACY_VERTEX_COUNT = 7;
45372
45310
  var TRIANGLE_LEGACY_INDEX_COUNT = 3;
45373
45311
  var TRIANGLE_LEGACY_WORLD_SIZE = [0, 0, 0];
@@ -45845,6 +45783,10 @@
45845
45783
  return BuilderNull;
45846
45784
  }());
45847
45785
 
45786
+ /*
45787
+ * Copyright (C) 2019 Toshiba Corporation
45788
+ * SPDX-License-Identifier: Apache-2.0
45789
+ */
45848
45790
  var RECTANGLE_LEGACY_VERTEX_COUNT = 16;
45849
45791
  var RECTANGLE_LEGACY_INDEX_COUNT = 8;
45850
45792
  var RECTANGLE_LEGACY_WORLD_SIZE = [0, 0];
@@ -50641,12 +50583,15 @@
50641
50583
  EShapeDeserializers[EShapeType.LINE_OF_CIRCLES] = deserializeLineOfCircles;
50642
50584
  };
50643
50585
 
50586
+ /*
50587
+ * Copyright (C) 2019 Toshiba Corporation
50588
+ * SPDX-License-Identifier: Apache-2.0
50589
+ */
50644
50590
  var RECTANGLE_ROUNDED_LEGACY_VERTEX_COUNT = 44;
50645
50591
  var RECTANGLE_ROUNDED_LEGACY_INDEX_COUNT = 24;
50646
50592
  var RECTANGLE_ROUNDED_LEGACY_WORLD_SIZE = [
50647
50593
  0, 0, 0, 0, 0
50648
50594
  ];
50649
- var RECTANGLE_ROUNDED_LEGACY_WORK_POINT = new pixi_js.Point();
50650
50595
  var buildRectangleRoundedLegacyIndex = function (indices, voffset, ioffset) {
50651
50596
  // c0 c1 c4 c5
50652
50597
  // |---| |---|
@@ -50760,22 +50705,21 @@
50760
50705
  var sy = sizeY * 0.5 + (0 <= sizeY ? +s : -s);
50761
50706
  var ax = Math.abs(sx);
50762
50707
  var ay = Math.abs(sy);
50763
- var a = radius * Math.min(ax, ay);
50764
- var rx = a / ax;
50765
- var ry = a / ay;
50766
- var work = RECTANGLE_ROUNDED_LEGACY_WORK_POINT;
50767
- work.set(originX - sx, originY - sy);
50768
- internalTransform.apply(work, work);
50769
- var b0x = work.x;
50770
- var b0y = work.y;
50771
- work.set(originX, originY - sy);
50772
- internalTransform.apply(work, work);
50773
- var b1x = work.x;
50774
- var b1y = work.y;
50775
- work.set(originX - sx, originY);
50776
- internalTransform.apply(work, work);
50777
- var b3x = work.x;
50778
- var b3y = work.y;
50708
+ var az = radius * Math.min(ax, ay);
50709
+ var rx = az / ax;
50710
+ var ry = az / ay;
50711
+ var a = internalTransform.a;
50712
+ var b = internalTransform.b;
50713
+ var c = internalTransform.c;
50714
+ var d = internalTransform.d;
50715
+ var tx = internalTransform.tx;
50716
+ var ty = internalTransform.ty;
50717
+ var b0x = a * (originX - sx) + c * (originY - sy) + tx;
50718
+ var b0y = b * (originX - sx) + d * (originY - sy) + ty;
50719
+ var b1x = a * originX + c * (originY - sy) + tx;
50720
+ var b1y = b * originX + d * (originY - sy) + ty;
50721
+ var b3x = a * (originX - sx) + c * originY + tx;
50722
+ var b3y = b * (originX - sx) + d * originY + ty;
50779
50723
  var d01x = b1x - b0x;
50780
50724
  var d01y = b1y - b0y;
50781
50725
  var d03x = b3x - b0x;
@@ -51001,7 +50945,7 @@
51001
50945
  // World size
51002
50946
  worldSize[0] = ax;
51003
50947
  worldSize[1] = ay;
51004
- worldSize[2] = a;
50948
+ worldSize[2] = az;
51005
50949
  worldSize[3] = rx;
51006
50950
  worldSize[4] = ry;
51007
50951
  };
@@ -52129,13 +52073,16 @@
52129
52073
  EShapeCapabilities.set(EShapeType.LINE_OF_RECTANGLES, EShapeCapability.PRIMITIVE | EShapeCapability.STROKE_SIDE);
52130
52074
  };
52131
52075
 
52132
- var TRIANGLE_ROUNDED_VERTEX_COUNT = 22;
52133
- var TRIANGLE_ROUNDED_INDEX_COUNT = 15;
52134
- var TRIANGLE_ROUNDED_WORLD_SIZE = [
52076
+ /*
52077
+ * Copyright (C) 2019 Toshiba Corporation
52078
+ * SPDX-License-Identifier: Apache-2.0
52079
+ */
52080
+ var TRIANGLE_ROUNDED_LEGACY_VERTEX_COUNT = 22;
52081
+ var TRIANGLE_ROUNDED_LEGACY_INDEX_COUNT = 15;
52082
+ var TRIANGLE_ROUNDED_LEGACY_WORLD_SIZE = [
52135
52083
  0, 0, 0, 0, 0
52136
52084
  ];
52137
- var TRIANGLE_ROUNDED_WORK_POINT = new pixi_js.Point();
52138
- var buildTriangleRoundedIndex = function (indices, voffset, ioffset) {
52085
+ var buildTriangleRoundedLegacyIndex = function (indices, voffset, ioffset) {
52139
52086
  // Top corner
52140
52087
  var ii = ioffset * 3 - 1;
52141
52088
  indices[++ii] = voffset + 0;
@@ -52189,7 +52136,7 @@
52189
52136
  indices[++ii] = voffset + 21;
52190
52137
  indices[++ii] = voffset + 13;
52191
52138
  };
52192
- var buildTriangleRoundedVertex = function (vertices, voffset, originX, originY, sizeX, sizeY, strokeAlign, strokeWidth, radius, internalTransform, worldSize) {
52139
+ var buildTriangleRoundedLegacyVertex = function (vertices, voffset, originX, originY, sizeX, sizeY, strokeAlign, strokeWidth, radius, internalTransform, worldSize) {
52193
52140
  // Calculate the transformed positions
52194
52141
  var s = strokeAlign * strokeWidth;
52195
52142
  var sx = sizeX * 0.5 + (0 <= sizeX ? +s : -s);
@@ -52199,23 +52146,24 @@
52199
52146
  var ry = (sw * radius) / (2 * sy);
52200
52147
  var rz = (0.5 * (sz - sw) * radius) / sz;
52201
52148
  var rx = (ry * sz) / (2 * sx);
52202
- var work = TRIANGLE_ROUNDED_WORK_POINT;
52203
- work.set(originX, originY - sy);
52204
- internalTransform.apply(work, work);
52205
- var x1 = work.x;
52206
- var y1 = work.y;
52207
- work.set(originX, originY);
52208
- internalTransform.apply(work, work);
52209
- var tx = work.x;
52210
- var ty = work.y;
52211
- work.set(originX + sx, originY);
52212
- internalTransform.apply(work, work);
52213
- var dx = tx - x1;
52214
- var dy = ty - y1;
52215
- var x4 = work.x + dx;
52216
- var y4 = work.y + dy;
52217
- var x7 = tx + (tx - work.x) + dx;
52218
- var y7 = ty + (ty - work.y) + dy;
52149
+ var a = internalTransform.a;
52150
+ var b = internalTransform.b;
52151
+ var c = internalTransform.c;
52152
+ var d = internalTransform.d;
52153
+ var tx = internalTransform.tx;
52154
+ var ty = internalTransform.ty;
52155
+ var x1 = a * originX + c * (originY - sy) + tx;
52156
+ var y1 = b * originX + d * (originY - sy) + ty;
52157
+ var ox = a * originX + c * originY + tx;
52158
+ var oy = b * originX + d * originY + ty;
52159
+ var dx = ox - x1;
52160
+ var dy = oy - y1;
52161
+ var wx = a * (originX + sx) + c * originY + tx;
52162
+ var wy = b * (originX + sx) + d * originY + ty;
52163
+ var x4 = wx + dx;
52164
+ var y4 = wy + dy;
52165
+ var x7 = ox + (ox - wx) + dx;
52166
+ var y7 = oy + (oy - wy) + dy;
52219
52167
  var dx14 = x4 - x1;
52220
52168
  var dy14 = y4 - y1;
52221
52169
  var x2 = x1 + rz * dx14;
@@ -52234,10 +52182,8 @@
52234
52182
  var y8 = y7 + ry * dy71;
52235
52183
  var x9 = x1 - rz * dx71;
52236
52184
  var y9 = y1 - rz * dy71;
52237
- work.set(originX, originY + sy - sw); // Incenter of a triangle
52238
- internalTransform.apply(work, work);
52239
- var x0 = work.x;
52240
- var y0 = work.y;
52185
+ var x0 = a * originX + c * (originY + sy - sw) + tx;
52186
+ var y0 = b * originX + d * (originY + sy - sw) + ty;
52241
52187
  var x10 = x1 + radius * (x0 - x1);
52242
52188
  var y10 = y1 + radius * (y0 - y1);
52243
52189
  var x11 = x4 + radius * (x0 - x4);
@@ -52245,8 +52191,8 @@
52245
52191
  var x12 = x7 + radius * (x0 - x7);
52246
52192
  var y12 = y7 + radius * (y0 - y7);
52247
52193
  // World size
52248
- var xb = tx + dx;
52249
- var yb = ty + dy;
52194
+ var xb = ox + dx;
52195
+ var yb = oy + dy;
52250
52196
  worldSize[0] = toLength(xb, yb, x0, y0);
52251
52197
  worldSize[1] = rx;
52252
52198
  worldSize[2] = ry;
@@ -52303,7 +52249,7 @@
52303
52249
  vertices[++iv] = x9;
52304
52250
  vertices[++iv] = y9;
52305
52251
  };
52306
- var buildTriangleRoundedStep = function (steps, voffset, strokeWidth, strokeStyle, corner, radius, worldSize) {
52252
+ var buildTriangleRoundedLegacyStep = function (steps, voffset, strokeWidth, strokeStyle, corner, radius, worldSize) {
52307
52253
  var scaleInvariant = toScaleInvariant(strokeStyle);
52308
52254
  var s = worldSize[0];
52309
52255
  var sr = radius * s;
@@ -52574,7 +52520,7 @@
52574
52520
  steps[++is] = c10;
52575
52521
  steps[++is] = 0;
52576
52522
  };
52577
- var buildTriangleRoundedUv = function (uvs, voffset, textureUvs, radius, worldSize) {
52523
+ var buildTriangleRoundedLegacyUv = function (uvs, voffset, textureUvs, radius, worldSize) {
52578
52524
  var x0 = textureUvs.x0;
52579
52525
  var x1 = textureUvs.x1;
52580
52526
  var x2 = textureUvs.x2;
@@ -52680,8 +52626,8 @@
52680
52626
  var ioffset = this.indexOffset;
52681
52627
  var pointCountReserved = this.pointCountReserved;
52682
52628
  if (0 < pointCountReserved) {
52683
- buildTriangleRoundedIndex(buffer.indices, voffset, ioffset);
52684
- copyIndex(buffer.indices, TRIANGLE_ROUNDED_VERTEX_COUNT, ioffset, TRIANGLE_ROUNDED_INDEX_COUNT, pointCountReserved);
52629
+ buildTriangleRoundedLegacyIndex(buffer.indices, voffset, ioffset);
52630
+ copyIndex(buffer.indices, TRIANGLE_ROUNDED_LEGACY_VERTEX_COUNT, ioffset, TRIANGLE_ROUNDED_LEGACY_INDEX_COUNT, pointCountReserved);
52685
52631
  }
52686
52632
  this.inited |= BuilderFlag.INDEX;
52687
52633
  };
@@ -52690,7 +52636,7 @@
52690
52636
  if (points instanceof EShapeLineOfAnyPointsImpl) {
52691
52637
  var buffer = this.buffer;
52692
52638
  this.updateVertexStepAndUv(buffer, shape, points);
52693
- this.updateLineOfAnyColor(buffer, shape, points, TRIANGLE_ROUNDED_VERTEX_COUNT);
52639
+ this.updateLineOfAnyColor(buffer, shape, points, TRIANGLE_ROUNDED_LEGACY_VERTEX_COUNT);
52694
52640
  }
52695
52641
  };
52696
52642
  BuilderLineOfTriangleRoundeds.prototype.updateVertexStepAndUv = function (buffer, shape, points) {
@@ -52768,17 +52714,17 @@
52768
52714
  var pointSizeX = pointSize.getX(0);
52769
52715
  var pointSizeY = pointSize.getY(0);
52770
52716
  // Vertices
52771
- buildTriangleRoundedVertex(vertices, voffset, 0, 0, pointSizeX, pointSizeY, strokeAlign, strokeWidth, radius, internalTransform, TRIANGLE_ROUNDED_WORLD_SIZE);
52772
- copyVertex(vertices, internalTransform, voffset, TRIANGLE_ROUNDED_VERTEX_COUNT, pointCount, pointsValues, pointOffset);
52717
+ buildTriangleRoundedLegacyVertex(vertices, voffset, 0, 0, pointSizeX, pointSizeY, strokeAlign, strokeWidth, radius, internalTransform, TRIANGLE_ROUNDED_LEGACY_WORLD_SIZE);
52718
+ copyVertex(vertices, internalTransform, voffset, TRIANGLE_ROUNDED_LEGACY_VERTEX_COUNT, pointCount, pointsValues, pointOffset);
52773
52719
  // Steps
52774
52720
  if (isNotInited || isVertexChanged || isTransformChanged || isCornerChanged) {
52775
- buildTriangleRoundedStep(steps, voffset, strokeWidth, strokeStyle, corner, radius, TRIANGLE_ROUNDED_WORLD_SIZE);
52776
- copyStep(steps, voffset, TRIANGLE_ROUNDED_VERTEX_COUNT, pointCount);
52721
+ buildTriangleRoundedLegacyStep(steps, voffset, strokeWidth, strokeStyle, corner, radius, TRIANGLE_ROUNDED_LEGACY_WORLD_SIZE);
52722
+ copyStep(steps, voffset, TRIANGLE_ROUNDED_LEGACY_VERTEX_COUNT, pointCount);
52777
52723
  }
52778
52724
  // UVs
52779
52725
  if (isNotInited || isVertexChanged || isTextureChanged) {
52780
- buildTriangleRoundedUv(uvs, voffset, textureUvs, radius, TRIANGLE_ROUNDED_WORLD_SIZE);
52781
- copyUvs(uvs, voffset, TRIANGLE_ROUNDED_VERTEX_COUNT, pointCount);
52726
+ buildTriangleRoundedLegacyUv(uvs, voffset, textureUvs, radius, TRIANGLE_ROUNDED_LEGACY_WORLD_SIZE);
52727
+ copyUvs(uvs, voffset, TRIANGLE_ROUNDED_LEGACY_VERTEX_COUNT, pointCount);
52782
52728
  }
52783
52729
  }
52784
52730
  else {
@@ -52788,23 +52734,23 @@
52788
52734
  var py = pointsValues[ip + 1] + pointOffset.getY(i);
52789
52735
  var pointSizeX = pointSize.getX(i);
52790
52736
  var pointSizeY = pointSize.getY(i);
52791
- var iv = voffset + i * TRIANGLE_ROUNDED_VERTEX_COUNT;
52737
+ var iv = voffset + i * TRIANGLE_ROUNDED_LEGACY_VERTEX_COUNT;
52792
52738
  // Vertices
52793
- buildTriangleRoundedVertex(vertices, iv, px, py, pointSizeX, pointSizeY, strokeAlign, strokeWidth, radius, internalTransform, TRIANGLE_ROUNDED_WORLD_SIZE);
52739
+ buildTriangleRoundedLegacyVertex(vertices, iv, px, py, pointSizeX, pointSizeY, strokeAlign, strokeWidth, radius, internalTransform, TRIANGLE_ROUNDED_LEGACY_WORLD_SIZE);
52794
52740
  // Steps
52795
52741
  if (isNotInited || isVertexChanged || isTransformChanged || isCornerChanged) {
52796
- buildTriangleRoundedStep(steps, iv, strokeWidth, strokeStyle, corner, radius, TRIANGLE_ROUNDED_WORLD_SIZE);
52742
+ buildTriangleRoundedLegacyStep(steps, iv, strokeWidth, strokeStyle, corner, radius, TRIANGLE_ROUNDED_LEGACY_WORLD_SIZE);
52797
52743
  }
52798
52744
  // UVs
52799
52745
  if (isNotInited || isVertexChanged || isTextureChanged) {
52800
- buildTriangleRoundedUv(uvs, iv, textureUvs, radius, TRIANGLE_ROUNDED_WORLD_SIZE);
52746
+ buildTriangleRoundedLegacyUv(uvs, iv, textureUvs, radius, TRIANGLE_ROUNDED_LEGACY_WORLD_SIZE);
52801
52747
  }
52802
52748
  }
52803
52749
  }
52804
52750
  // Fill the rest
52805
52751
  var pointCountReserved = this.pointCountReserved;
52806
- var voffsetReserved = voffset + pointCount * TRIANGLE_ROUNDED_VERTEX_COUNT;
52807
- var vcountReserved = TRIANGLE_ROUNDED_VERTEX_COUNT * (pointCountReserved - pointCount);
52752
+ var voffsetReserved = voffset + pointCount * TRIANGLE_ROUNDED_LEGACY_VERTEX_COUNT;
52753
+ var vcountReserved = TRIANGLE_ROUNDED_LEGACY_VERTEX_COUNT * (pointCountReserved - pointCount);
52808
52754
  buildNullVertex(vertices, voffsetReserved, vcountReserved);
52809
52755
  buildNullStep(steps, voffsetReserved, vcountReserved);
52810
52756
  buildNullUv(uvs, voffsetReserved, vcountReserved);
@@ -52818,16 +52764,15 @@
52818
52764
  * SPDX-License-Identifier: Apache-2.0
52819
52765
  */
52820
52766
  var createLineOfTriangleRoundedsUploaded = function (buffer, shape, voffset, ioffset, antialiasWeight) {
52821
- return createLineOfAnyUploaded(buffer, shape, voffset, TRIANGLE_ROUNDED_VERTEX_COUNT, ioffset, TRIANGLE_ROUNDED_INDEX_COUNT, antialiasWeight, BuilderLineOfTriangleRoundeds);
52767
+ return createLineOfAnyUploaded(buffer, shape, voffset, TRIANGLE_ROUNDED_LEGACY_VERTEX_COUNT, ioffset, TRIANGLE_ROUNDED_LEGACY_INDEX_COUNT, antialiasWeight, BuilderLineOfTriangleRoundeds);
52822
52768
  };
52823
52769
 
52824
52770
  /*
52825
52771
  * Copyright (C) 2019 Toshiba Corporation
52826
52772
  * SPDX-License-Identifier: Apache-2.0
52827
52773
  */
52828
- var containsCorner_ = function (shape, x, y, r, aw, sw, ss) {
52829
- var fill = shape.fill;
52830
- if (fill.enable) {
52774
+ var containsCorner_ = function (x, y, r, aw, sw, ss, filled) {
52775
+ if (filled) {
52831
52776
  if (x * x + y * y <= r * r) {
52832
52777
  return true;
52833
52778
  }
@@ -52845,7 +52790,7 @@
52845
52790
  }
52846
52791
  return false;
52847
52792
  };
52848
- var containsCorner = function (shape, x, y, x0, y0, x1, y1, x2, y2, x3, y3, r12, r13, aw, radius, sw, ss) {
52793
+ var containsCorner = function (x, y, x0, y0, x1, y1, x2, y2, x3, y3, r12, r13, aw, radius, sw, ss, filled) {
52849
52794
  var xl = x1 + r12 * (x2 - x1) - x0;
52850
52795
  var yl = y1 + r12 * (y2 - y1) - y0;
52851
52796
  var n = Math.sqrt(xl * xl + yl * yl);
@@ -52865,14 +52810,14 @@
52865
52810
  var yc = y - y0;
52866
52811
  var dx = (+nry * xc - nrx * yc) * deti;
52867
52812
  var dy = (-nly * xc + nlx * yc) * deti;
52868
- if (containsCorner_(shape, dx, dy, n, aw * radius, sw, ss)) {
52813
+ if (containsCorner_(dx, dy, n, aw * radius, sw, ss, filled)) {
52869
52814
  return true;
52870
52815
  }
52871
52816
  }
52872
52817
  }
52873
52818
  return false;
52874
52819
  };
52875
- var hitTestTriangleRounded = function (shape, x, y, ax, ay, sw, ss) {
52820
+ var hitTestTriangleRoundedImpl = function (shape, x, y, ax, ay, sw, ss, filled) {
52876
52821
  var a = (2 * ay) / ax;
52877
52822
  if (hitTestTriangleFilled(x, y, a, -ay, +ay)) {
52878
52823
  var az = Math.sqrt(ax * ax + 4 * ay * ay);
@@ -52899,7 +52844,7 @@
52899
52844
  if (!c0 && !c1 && corner & EShapeCorner.TOP) {
52900
52845
  // Top corner
52901
52846
  var rz = (0.5 * (az - aw) * radius) / az;
52902
- if (containsCorner(shape, x, y, x10, y10, x1, y1, x7, y7, x4, y4, rz, rz, aw, radius, sw, ss)) {
52847
+ if (containsCorner(x, y, x10, y10, x1, y1, x7, y7, x4, y4, rz, rz, aw, radius, sw, ss, filled)) {
52903
52848
  return true;
52904
52849
  }
52905
52850
  }
@@ -52907,7 +52852,7 @@
52907
52852
  // Bottom-left corner
52908
52853
  var ry = (aw * radius) / (2 * ay);
52909
52854
  var rx = (ry * az) / (2 * ax);
52910
- if (containsCorner(shape, x, y, x12, y12, x7, y7, x4, y4, x1, y1, rx, ry, aw, radius, sw, ss)) {
52855
+ if (containsCorner(x, y, x12, y12, x7, y7, x4, y4, x1, y1, rx, ry, aw, radius, sw, ss, filled)) {
52911
52856
  return true;
52912
52857
  }
52913
52858
  }
@@ -52915,14 +52860,13 @@
52915
52860
  // Bottom-right corner
52916
52861
  var ry = (aw * radius) / (2 * ay);
52917
52862
  var rx = (ry * az) / (2 * ax);
52918
- if (containsCorner(shape, x, y, x11, y11, x4, y4, x1, y1, x7, y7, ry, rx, aw, radius, sw, ss)) {
52863
+ if (containsCorner(x, y, x11, y11, x4, y4, x1, y1, x7, y7, ry, rx, aw, radius, sw, ss, filled)) {
52919
52864
  return true;
52920
52865
  }
52921
52866
  }
52922
52867
  else {
52923
52868
  // Others
52924
- var fill = shape.fill;
52925
- if (fill.enable) {
52869
+ if (filled) {
52926
52870
  return true;
52927
52871
  }
52928
52872
  else {
@@ -52940,27 +52884,88 @@
52940
52884
  }
52941
52885
  return false;
52942
52886
  };
52887
+ var hitTestTriangleRoundedLegacy = function (shape, x, y, ax, ay, sw, ss) {
52888
+ return hitTestTriangleRoundedImpl(shape, x, y, ax, ay, sw, ss, shape.fill.enable);
52889
+ };
52890
+ /**
52891
+ * Returns true if the point is in the cone with the apex (cx, cy) spanned by the unit normals n1 and n2
52892
+ * but outside the circle of radius `rho`, that is, in the part cut off by a rounded corner.
52893
+ */
52894
+ var isCutByCorner = function (x, y, cx, cy, n1x, n1y, n2x, n2y, rho) {
52895
+ var dx = x - cx;
52896
+ var dy = y - cy;
52897
+ var det = n1x * n2y - n1y * n2x;
52898
+ var a = (dx * n2y - dy * n2x) / det;
52899
+ var b = (n1x * dy - n1y * dx) / det;
52900
+ return 0 <= a && 0 <= b && rho * rho < dx * dx + dy * dy;
52901
+ };
52902
+ /**
52903
+ * Tests whether the point is in the rounded triangle shrunk by `s`.
52904
+ * Sharp corners and corners whose radius is not larger than `s` stay sharp.
52905
+ */
52906
+ var hitTestTriangleRoundedInset = function (shape, x, y, ax, ay, s) {
52907
+ var az = Math.sqrt(ax * ax + 4 * ay * ay);
52908
+ // The outward unit normals of the left side (nlx, nly) and the right side (-nlx, nly)
52909
+ var nlx = (-2 * ay) / az;
52910
+ var nly = -ax / az;
52911
+ var yt = y + ay;
52912
+ if (-s < nlx * x + nly * yt || -s < -nlx * x + nly * yt || ay - s < y) {
52913
+ return false;
52914
+ }
52915
+ var radius = shape.radius;
52916
+ var aw = (2 * ax * ay) / (ax + az);
52917
+ var rho = radius * aw - s;
52918
+ if (0 < rho) {
52919
+ var corner = shape.corner;
52920
+ var cby = ay - radius * aw;
52921
+ if (corner & EShapeCorner.TOP &&
52922
+ isCutByCorner(x, y, 0, -ay + radius * (2 * ay - aw), nlx, nly, -nlx, nly, rho)) {
52923
+ return false;
52924
+ }
52925
+ if (corner & EShapeCorner.BOTTOM_RIGHT &&
52926
+ isCutByCorner(x, y, ax * (1 - radius), cby, -nlx, nly, 0, 1, rho)) {
52927
+ return false;
52928
+ }
52929
+ if (corner & EShapeCorner.BOTTOM_LEFT &&
52930
+ isCutByCorner(x, y, -ax * (1 - radius), cby, nlx, nly, 0, 1, rho)) {
52931
+ return false;
52932
+ }
52933
+ }
52934
+ return true;
52935
+ };
52936
+ var hitTestTriangleRounded = function (shape, x, y, ax, ay, sw, ss) {
52937
+ var fill = shape.fill;
52938
+ if ((fill.enable || 0 < sw) && hitTestTriangleRoundedInset(shape, x, y, ax, ay, 0)) {
52939
+ if (fill.enable && hitTestFill(x, y, ax, ay, fill)) {
52940
+ return true;
52941
+ }
52942
+ if (0 < sw && !hitTestTriangleRoundedInset(shape, x, y, ax, ay, sw * ss)) {
52943
+ return true;
52944
+ }
52945
+ }
52946
+ return false;
52947
+ };
52943
52948
 
52944
52949
  /*
52945
52950
  * Copyright (C) 2019 Toshiba Corporation
52946
52951
  * SPDX-License-Identifier: Apache-2.0
52947
52952
  */
52948
- var EShapeTriangleRounded = /** @class */ (function (_super) {
52949
- __extends(EShapeTriangleRounded, _super);
52950
- function EShapeTriangleRounded(type) {
52951
- if (type === void 0) { type = EShapeType.TRIANGLE_ROUNDED; }
52953
+ var EShapeTriangleRoundedLegacy = /** @class */ (function (_super) {
52954
+ __extends(EShapeTriangleRoundedLegacy, _super);
52955
+ function EShapeTriangleRoundedLegacy(type) {
52956
+ if (type === void 0) { type = EShapeType.TRIANGLE_ROUNDED_LEGACY; }
52952
52957
  return _super.call(this, type) || this;
52953
52958
  }
52954
- EShapeTriangleRounded.prototype.clone = function () {
52955
- return new EShapeTriangleRounded(this.type).copy(this);
52959
+ EShapeTriangleRoundedLegacy.prototype.clone = function () {
52960
+ return new EShapeTriangleRoundedLegacy(this.type).copy(this);
52956
52961
  };
52957
- EShapeTriangleRounded.prototype.containsAbs = function (x, y, ax, ay, sw, ss, sa) {
52962
+ EShapeTriangleRoundedLegacy.prototype.containsAbs = function (x, y, ax, ay, sw, ss, sa) {
52958
52963
  if (_super.prototype.containsAbsBBox.call(this, x, y, ax, ay)) {
52959
- return hitTestTriangleRounded(this, x, y, ax, ay, sw, ss);
52964
+ return hitTestTriangleRoundedLegacy(this, x, y, ax, ay, sw, ss);
52960
52965
  }
52961
52966
  return false;
52962
52967
  };
52963
- return EShapeTriangleRounded;
52968
+ return EShapeTriangleRoundedLegacy;
52964
52969
  }(EShapePrimitive));
52965
52970
 
52966
52971
  /*
@@ -53007,7 +53012,7 @@
53007
53012
  return false;
53008
53013
  };
53009
53014
  return EShapeLineOfTriangleRoundeds;
53010
- }(EShapeTriangleRounded));
53015
+ }(EShapeTriangleRoundedLegacy));
53011
53016
 
53012
53017
  /*
53013
53018
  * Copyright (C) 2019 Toshiba Corporation
@@ -56192,30 +56197,516 @@
56192
56197
  EShapeDeserializers[EShapeType.TRIANGLE_LEGACY] = deserializeTriangleLegacy;
56193
56198
  };
56194
56199
 
56200
+ /*
56201
+ * Copyright (C) 2019-2026 Toshiba Corporation
56202
+ * SPDX-License-Identifier: Apache-2.0
56203
+ */
56204
+ var EShapeTriangleRoundedTriangulatedImpl = /** @class */ (function () {
56205
+ function EShapeTriangleRoundedTriangulatedImpl(parent) {
56206
+ this._id = 0;
56207
+ this._parent = parent;
56208
+ this._width = 0;
56209
+ this._height = 0;
56210
+ this._strokeAlign = 0;
56211
+ this._strokeWidth = 0;
56212
+ this._sizeX = 0;
56213
+ this._sizeY = 0;
56214
+ this._radius = 0;
56215
+ this._corner = EShapeCorner.NONE;
56216
+ this._vertices = [];
56217
+ this._nvertices = 0;
56218
+ this._distances = [];
56219
+ this._lengths = [];
56220
+ this._clippings = [];
56221
+ this._uvs = [];
56222
+ this._indices = [];
56223
+ this._nindices = 0;
56224
+ this._boundary = [0, 0, 0, 0];
56225
+ }
56226
+ Object.defineProperty(EShapeTriangleRoundedTriangulatedImpl.prototype, "id", {
56227
+ get: function () {
56228
+ this.triangulate();
56229
+ return this._id;
56230
+ },
56231
+ enumerable: false,
56232
+ configurable: true
56233
+ });
56234
+ Object.defineProperty(EShapeTriangleRoundedTriangulatedImpl.prototype, "vertices", {
56235
+ get: function () {
56236
+ this.triangulate();
56237
+ return this._vertices;
56238
+ },
56239
+ enumerable: false,
56240
+ configurable: true
56241
+ });
56242
+ Object.defineProperty(EShapeTriangleRoundedTriangulatedImpl.prototype, "nvertices", {
56243
+ get: function () {
56244
+ this.triangulate();
56245
+ return this._nvertices;
56246
+ },
56247
+ enumerable: false,
56248
+ configurable: true
56249
+ });
56250
+ Object.defineProperty(EShapeTriangleRoundedTriangulatedImpl.prototype, "distances", {
56251
+ get: function () {
56252
+ this.triangulate();
56253
+ return this._distances;
56254
+ },
56255
+ enumerable: false,
56256
+ configurable: true
56257
+ });
56258
+ Object.defineProperty(EShapeTriangleRoundedTriangulatedImpl.prototype, "lengths", {
56259
+ get: function () {
56260
+ this.triangulate();
56261
+ return this._lengths;
56262
+ },
56263
+ enumerable: false,
56264
+ configurable: true
56265
+ });
56266
+ Object.defineProperty(EShapeTriangleRoundedTriangulatedImpl.prototype, "clippings", {
56267
+ get: function () {
56268
+ this.triangulate();
56269
+ return this._clippings;
56270
+ },
56271
+ enumerable: false,
56272
+ configurable: true
56273
+ });
56274
+ Object.defineProperty(EShapeTriangleRoundedTriangulatedImpl.prototype, "uvs", {
56275
+ get: function () {
56276
+ this.triangulate();
56277
+ return this._uvs;
56278
+ },
56279
+ enumerable: false,
56280
+ configurable: true
56281
+ });
56282
+ Object.defineProperty(EShapeTriangleRoundedTriangulatedImpl.prototype, "indices", {
56283
+ get: function () {
56284
+ this.triangulate();
56285
+ return this._indices;
56286
+ },
56287
+ enumerable: false,
56288
+ configurable: true
56289
+ });
56290
+ Object.defineProperty(EShapeTriangleRoundedTriangulatedImpl.prototype, "nindices", {
56291
+ get: function () {
56292
+ this.triangulate();
56293
+ return this._nindices;
56294
+ },
56295
+ enumerable: false,
56296
+ configurable: true
56297
+ });
56298
+ Object.defineProperty(EShapeTriangleRoundedTriangulatedImpl.prototype, "boundary", {
56299
+ get: function () {
56300
+ this.triangulate();
56301
+ return this._boundary;
56302
+ },
56303
+ enumerable: false,
56304
+ configurable: true
56305
+ });
56306
+ EShapeTriangleRoundedTriangulatedImpl.prototype.triangulate = function () {
56307
+ var isNotInitialized = this._id === 0;
56308
+ var parent = this._parent;
56309
+ var size = parent.size;
56310
+ var width = size.x;
56311
+ var height = size.y;
56312
+ var isRectChanged = this._width !== width || this._height !== height;
56313
+ var stroke = parent.stroke;
56314
+ var strokeAlign = stroke.align;
56315
+ var strokeWidth = stroke.enable ? stroke.width : 0;
56316
+ var isStrokeChanged = this._strokeAlign !== strokeAlign || this._strokeWidth !== strokeWidth;
56317
+ var radius = parent.radius;
56318
+ var isRadiusChanged = this._radius !== radius;
56319
+ var corner = parent.corner;
56320
+ var isCornerChanged = this._corner !== corner;
56321
+ var isSizeChanged = false;
56322
+ var sizeX = this._sizeX;
56323
+ var sizeY = this._sizeY;
56324
+ if (isRectChanged || isStrokeChanged) {
56325
+ this._width = width;
56326
+ this._height = height;
56327
+ this._strokeAlign = strokeAlign;
56328
+ this._strokeWidth = strokeWidth;
56329
+ var s = strokeAlign * strokeWidth;
56330
+ sizeX = width * 0.5 + (0 <= width ? +s : -s);
56331
+ sizeY = height * 0.5 + (0 <= height ? +s : -s);
56332
+ isSizeChanged = this._sizeX !== sizeX || this._sizeY !== sizeY;
56333
+ }
56334
+ if (isNotInitialized ||
56335
+ isSizeChanged ||
56336
+ isStrokeChanged ||
56337
+ isRadiusChanged ||
56338
+ isCornerChanged) {
56339
+ this._sizeX = sizeX;
56340
+ this._sizeY = sizeY;
56341
+ this._radius = radius;
56342
+ this._corner = corner;
56343
+ this.update(sizeX, sizeY, radius, corner);
56344
+ }
56345
+ };
56346
+ EShapeTriangleRoundedTriangulatedImpl.prototype.update = function (sx, sy, radius, corner) {
56347
+ var boundary = this._boundary;
56348
+ var ax = Math.abs(sx);
56349
+ var ay = Math.abs(sy);
56350
+ boundary[0] = -ax;
56351
+ boundary[1] = -ay;
56352
+ boundary[2] = +ax;
56353
+ boundary[3] = +ay;
56354
+ var n = EShapeDefaults.CIRCLE_SEGMENT_COUNT >> 2;
56355
+ var nv = 9 * n + 6;
56356
+ var ni = 3 * n + 6;
56357
+ this._nvertices = nv;
56358
+ this._nindices = ni;
56359
+ this._id += 1;
56360
+ if (ax <= 0 || ay <= 0) {
56361
+ this.pad(0, 0, nv, ni, 0);
56362
+ return;
56363
+ }
56364
+ var scale = 1.1;
56365
+ var az = 2 * ay;
56366
+ var b0 = Math.sqrt(ax * ax + az * az);
56367
+ var r0 = (ax * az) / (ax + b0);
56368
+ var r = radius * r0;
56369
+ var fs = (scale - 1) * r0;
56370
+ var rs = r + fs;
56371
+ var r0i = 1 / r0;
56372
+ var rr0 = r * r0i;
56373
+ var a0 = ax * rr0;
56374
+ var b1 = b0 - a0;
56375
+ var b2 = b0 - ax;
56376
+ var b3 = b2 * rr0;
56377
+ var b0i = 1 / b0;
56378
+ var b1b0 = b1 * b0i;
56379
+ var b3b0 = b3 * b0i;
56380
+ var b2b0 = b2 * b0i;
56381
+ var gx = Math.sign(sx);
56382
+ var x0 = -sx;
56383
+ var x1 = -sx + gx * ax * (1 - b1b0);
56384
+ var x2 = -sx + gx * ax * rr0;
56385
+ var x3 = -sx + gx * ax * (1 - b3b0);
56386
+ var x4 = 0;
56387
+ var x6 = -x2;
56388
+ var xl = -sx + gx * ax * (1 - b2b0);
56389
+ var gy = Math.sign(sy);
56390
+ var y0 = -sy;
56391
+ var y1 = -sy + gy * az * b3b0;
56392
+ var y2 = -sy + gy * (az - r0) * rr0;
56393
+ var y3 = -sy + gy * (az - r0);
56394
+ var y4 = -sy + gy * az * b1b0;
56395
+ var y5 = -sy + gy * (az - r);
56396
+ var y6 = +sy;
56397
+ var yc = -sy + gy * az * b2b0;
56398
+ var dlx = xl - x4;
56399
+ var dly = yc - y3;
56400
+ var nlx = dlx * r0i;
56401
+ var nly = dly * r0i;
56402
+ var nrx = -nlx;
56403
+ var nry = nly;
56404
+ var nbx = 0;
56405
+ var nby = gy;
56406
+ var tt = (nrx * (nrx - nlx) + nry * (nry - nly)) / (nry * nlx - nrx * nly);
56407
+ var tl = (nbx * (nbx - nlx) + nby * (nby - nly)) / (nby * nlx - nbx * nly);
56408
+ var sx0 = x0 + (nlx - nly * tl) * fs;
56409
+ var sx1 = x1 + nlx * fs;
56410
+ var sx3 = x3 + nlx * fs;
56411
+ var sx5 = -sx3;
56412
+ var sx7 = -sx1;
56413
+ var sx8 = -sx0;
56414
+ var sy0 = y0 + (nly + nlx * tt) * fs;
56415
+ var sy1 = y1 + nly * fs;
56416
+ var sy4 = y4 + nly * fs;
56417
+ var sy6 = y6 + gy * fs;
56418
+ var fd = r0i;
56419
+ var fx = 1 / sx;
56420
+ var fy = 1 / sy;
56421
+ var ct = 0 < r && !!(corner & EShapeCorner.TOP);
56422
+ var cr = 0 < r && !!(corner & EShapeCorner.BOTTOM_RIGHT);
56423
+ var cl = 0 < r && !!(corner & EShapeCorner.BOTTOM_LEFT);
56424
+ var aapex = ct || cr || cl ? Math.atan2(ax, az) : 0;
56425
+ var gz = gx * gy;
56426
+ var atop = gz * (Math.PI - 2 * aapex);
56427
+ var abottom = gz * (Math.PI * 0.5 + aapex);
56428
+ // Top Fan
56429
+ var iv = 0;
56430
+ var ii = 0;
56431
+ var l = 0;
56432
+ if (ct) {
56433
+ l = this.writeFan(x4, y2, sx3, sy1, atop, nlx, nly, l, r, rs, fd, scale, fx, fy, n, iv, ii);
56434
+ iv += 3 * (n - 1);
56435
+ ii += 3 * (n - 1);
56436
+ }
56437
+ // Right Pentagon
56438
+ var p1x = sx5;
56439
+ var p1y = sy1;
56440
+ var ttx = x3;
56441
+ var tty = y1;
56442
+ if (!ct) {
56443
+ p1x = x4;
56444
+ p1y = sy0;
56445
+ ttx = x4;
56446
+ tty = y0;
56447
+ }
56448
+ var p2x = sx7;
56449
+ var p2y = sy4;
56450
+ var trbx = -x1;
56451
+ var trby = y4;
56452
+ if (!cr) {
56453
+ p2x = sx8;
56454
+ p2y = sy6;
56455
+ trbx = -x0;
56456
+ trby = y6;
56457
+ }
56458
+ var lr = Math.sqrt((trbx + ttx) * (trbx + ttx) + (trby - tty) * (trby - tty));
56459
+ var lrc = Math.sqrt((ttx - xl) * (ttx - xl) + (yc - tty) * (yc - tty));
56460
+ var nlr = l + lr;
56461
+ var tdx = sx * b0i;
56462
+ var tdy = 2 * sy * b0i;
56463
+ var lr1 = l + (p1x + ttx) * tdx + (p1y - tty) * tdy;
56464
+ var lr2 = nlr + (p2x - trbx) * tdx + (p2y - trby) * tdy;
56465
+ var c0 = scale;
56466
+ var c1 = 1 - radius;
56467
+ this.writePenta(ct ? x4 : p1x, ct ? y2 : p1y, p1x, p1y, p2x, p2y, cr ? x6 : p2x, cr ? y5 : p2y, x4, y3, ct ? l : lr1, lr1, lr2, cr ? nlr : lr2, l + lrc, ct ? c1 : c0, c0, c0, cr ? c1 : c0, 0, fd, fx, fy, iv, ii);
56468
+ iv += 5;
56469
+ ii += 9;
56470
+ l = nlr;
56471
+ // Right Fan
56472
+ if (cr) {
56473
+ l = this.writeFan(x6, y5, sx7, sy4, abottom, nrx, nry, l, r, rs, fd, scale, fx, fy, n, iv, ii);
56474
+ iv += 3 * (n - 1);
56475
+ ii += 3 * (n - 1);
56476
+ }
56477
+ // Bottom Pentagon
56478
+ var p3x = x6;
56479
+ var p3y = sy6;
56480
+ var q3x = x6;
56481
+ var q3y = y5;
56482
+ var tbrx = x6;
56483
+ if (!cr) {
56484
+ p3x = sx8;
56485
+ q3x = p3x;
56486
+ q3y = p3y;
56487
+ tbrx = -x0;
56488
+ }
56489
+ var p4x = x2;
56490
+ var p4y = sy6;
56491
+ var q4x = x2;
56492
+ var q4y = y5;
56493
+ var tblx = x2;
56494
+ if (!cl) {
56495
+ p4x = sx0;
56496
+ q4x = p4x;
56497
+ q4y = p4y;
56498
+ tblx = x0;
56499
+ }
56500
+ var lb = Math.abs(tbrx - tblx);
56501
+ var lbc = Math.abs(tbrx - x4);
56502
+ var nlb = l + lb;
56503
+ var lb1 = l - gx * (p3x - tbrx);
56504
+ var lb2 = nlb - gx * (p4x - tblx);
56505
+ this.writePenta(q3x, q3y, p3x, p3y, p4x, p4y, q4x, q4y, x4, y3, cr ? l : lb1, lb1, lb2, cl ? nlb : lb2, l + lbc, cr ? c1 : c0, c0, c0, cl ? c1 : c0, 0, fd, fx, fy, iv, ii);
56506
+ iv += 5;
56507
+ ii += 9;
56508
+ l = nlb;
56509
+ // Left Fan
56510
+ if (cl) {
56511
+ l = this.writeFan(x2, y5, x2, sy6, abottom, nbx, nby, l, r, rs, fd, scale, fx, fy, n, iv, ii);
56512
+ iv += 3 * (n - 1);
56513
+ ii += 3 * (n - 1);
56514
+ }
56515
+ // Left Pentagon
56516
+ var p5x = sx1;
56517
+ var p5y = sy4;
56518
+ var q5x = x2;
56519
+ var q5y = y5;
56520
+ var tlbx = x1;
56521
+ var tlby = y4;
56522
+ if (!cl) {
56523
+ p5x = sx0;
56524
+ p5y = sy6;
56525
+ q5x = p5x;
56526
+ q5y = p5y;
56527
+ tlbx = x0;
56528
+ tlby = y6;
56529
+ }
56530
+ var p6x = sx3;
56531
+ var p6y = sy1;
56532
+ var q6x = x4;
56533
+ var q6y = y2;
56534
+ if (!ct) {
56535
+ p6x = x4;
56536
+ p6y = sy0;
56537
+ q6x = p6x;
56538
+ q6y = p6y;
56539
+ }
56540
+ var ll = Math.sqrt((tlbx - ttx) * (tlbx - ttx) + (tlby - tty) * (tlby - tty));
56541
+ var llc = Math.sqrt((xl - tlbx) * (xl - tlbx) + (yc - tlby) * (yc - tlby));
56542
+ var nll = l + ll;
56543
+ var ll0 = nll + (p6x - ttx) * tdx - (p6y - tty) * tdy;
56544
+ var ll4 = l + (p5x - tlbx) * tdx - (p5y - tlby) * tdy;
56545
+ this.writePenta(p6x, p6y, q6x, q6y, x4, y3, q5x, q5y, p5x, p5y, ll0, ct ? nll : ll0, l + llc, cl ? l : ll4, ll4, c0, ct ? c1 : c0, 0, cl ? c1 : c0, c0, fd, fx, fy, iv, ii);
56546
+ iv += 5;
56547
+ ii += 9;
56548
+ this.pad(iv, ii, nv, ni, fd);
56549
+ };
56550
+ EShapeTriangleRoundedTriangulatedImpl.prototype.writePenta = function (x0, y0, x1, y1, x2, y2, x3, y3, x4, y4, length0, length1, length2, length3, length4, clipping0, clipping1, clipping2, clipping3, clipping4, distance, fx, fy, iv, ii) {
56551
+ this.writeVertex(iv + 0, x0, y0, distance, length0, clipping0, fx, fy);
56552
+ this.writeVertex(iv + 1, x1, y1, distance, length1, clipping1, fx, fy);
56553
+ this.writeVertex(iv + 2, x2, y2, distance, length2, clipping2, fx, fy);
56554
+ this.writeVertex(iv + 3, x3, y3, distance, length3, clipping3, fx, fy);
56555
+ this.writeVertex(iv + 4, x4, y4, distance, length4, clipping4, fx, fy);
56556
+ var indices = this._indices;
56557
+ indices[ii + 0] = iv + 0;
56558
+ indices[ii + 1] = iv + 1;
56559
+ indices[ii + 2] = iv + 2;
56560
+ indices[ii + 3] = iv + 0;
56561
+ indices[ii + 4] = iv + 2;
56562
+ indices[ii + 5] = iv + 3;
56563
+ indices[ii + 6] = iv + 0;
56564
+ indices[ii + 7] = iv + 3;
56565
+ indices[ii + 8] = iv + 4;
56566
+ };
56567
+ EShapeTriangleRoundedTriangulatedImpl.prototype.writeFan = function (cx, cy, x0, y0, dt, nx, ny, l0, r, rs, fd, scale, fx, fy, n, iv, ii) {
56568
+ var m = n - 1;
56569
+ var da = dt / m;
56570
+ var dl = Math.abs(da) * r;
56571
+ // Rim vertices at radius rs sit dl / 2 * (rs / r) from the chord midpoint, so the length is exact at radius r.
56572
+ var dlm = 0.5 * dl * (rs / r - 1);
56573
+ var c0 = scale;
56574
+ var c1 = 1 - r * fd;
56575
+ var indices = this._indices;
56576
+ var l = l0;
56577
+ var xa = x0;
56578
+ var ya = y0;
56579
+ for (var i = 0; i < m; i += 1) {
56580
+ var angle = (i + 1) * da;
56581
+ var ca = Math.cos(angle);
56582
+ var sa = Math.sin(angle);
56583
+ var xb = cx + rs * (nx * ca - ny * sa);
56584
+ var yb = cy + rs * (nx * sa + ny * ca);
56585
+ var nl = l + dl;
56586
+ this.writeVertex(iv + 0, xa, ya, fd, l - dlm, c0, fx, fy);
56587
+ this.writeVertex(iv + 1, xb, yb, fd, nl + dlm, c0, fx, fy);
56588
+ this.writeVertex(iv + 2, cx, cy, fd, l + 0.5 * dl, c1, fx, fy);
56589
+ indices[ii + 0] = iv + 2;
56590
+ indices[ii + 1] = iv + 0;
56591
+ indices[ii + 2] = iv + 1;
56592
+ iv += 3;
56593
+ ii += 3;
56594
+ l = nl;
56595
+ xa = xb;
56596
+ ya = yb;
56597
+ }
56598
+ return l;
56599
+ };
56600
+ EShapeTriangleRoundedTriangulatedImpl.prototype.writeVertex = function (vertex, x, y, distance, length, clipping, fx, fy) {
56601
+ var vertex2 = vertex << 1;
56602
+ this._vertices[vertex2] = x;
56603
+ this._vertices[vertex2 + 1] = y;
56604
+ this._distances[vertex] = distance;
56605
+ this._lengths[vertex] = length;
56606
+ this._clippings[vertex] = clipping;
56607
+ this._uvs[vertex2] = 0.5 * (x * fx + 1);
56608
+ this._uvs[vertex2 + 1] = 0.5 * (y * fy + 1);
56609
+ };
56610
+ EShapeTriangleRoundedTriangulatedImpl.prototype.pad = function (iv, ii, nv, ni, distance) {
56611
+ for (var i = iv; i < nv; ++i) {
56612
+ var vertex2 = i << 1;
56613
+ this._vertices[vertex2] = 0;
56614
+ this._vertices[vertex2 + 1] = 0;
56615
+ this._distances[i] = distance;
56616
+ this._lengths[i] = 0;
56617
+ this._clippings[i] = 0;
56618
+ this._uvs[vertex2] = 0.5;
56619
+ this._uvs[vertex2 + 1] = 0.5;
56620
+ }
56621
+ for (var i = ii; i < ni * 3; ++i) {
56622
+ this._indices[i] = 0;
56623
+ }
56624
+ this._vertices.length = nv * 2;
56625
+ this._distances.length = nv;
56626
+ this._lengths.length = nv;
56627
+ this._clippings.length = nv;
56628
+ this._uvs.length = nv * 2;
56629
+ this._indices.length = ni * 3;
56630
+ };
56631
+ return EShapeTriangleRoundedTriangulatedImpl;
56632
+ }());
56633
+
56634
+ /*
56635
+ * Copyright (C) 2019-2026 Toshiba Corporation
56636
+ * SPDX-License-Identifier: Apache-2.0
56637
+ */
56638
+ var EShapeTriangleRounded = /** @class */ (function (_super) {
56639
+ __extends(EShapeTriangleRounded, _super);
56640
+ function EShapeTriangleRounded(type) {
56641
+ if (type === void 0) { type = EShapeType.TRIANGLE_ROUNDED; }
56642
+ var _this = _super.call(this, type) || this;
56643
+ _this._triangulated = _this.newTriangulated();
56644
+ return _this;
56645
+ }
56646
+ EShapeTriangleRounded.prototype.newTriangulated = function () {
56647
+ return new EShapeTriangleRoundedTriangulatedImpl(this);
56648
+ };
56649
+ Object.defineProperty(EShapeTriangleRounded.prototype, "triangulated", {
56650
+ get: function () {
56651
+ return this._triangulated;
56652
+ },
56653
+ enumerable: false,
56654
+ configurable: true
56655
+ });
56656
+ EShapeTriangleRounded.prototype.clone = function () {
56657
+ return new EShapeTriangleRounded(this.type).copy(this);
56658
+ };
56659
+ EShapeTriangleRounded.prototype.containsAbs = function (x, y, ax, ay, sw, ss, sa) {
56660
+ if (_super.prototype.containsAbsBBox.call(this, x, y, ax, ay)) {
56661
+ return hitTestTriangleRounded(this, x, y, ax, ay, sw, ss);
56662
+ }
56663
+ return false;
56664
+ };
56665
+ return EShapeTriangleRounded;
56666
+ }(EShapePrimitive));
56667
+
56668
+ /*
56669
+ * Copyright (C) 2019 Toshiba Corporation
56670
+ * SPDX-License-Identifier: Apache-2.0
56671
+ */
56672
+ var deserializeTriangleRounded = function (item, manager, shape) {
56673
+ return deserializeBase(item, manager, shape || new EShapeTriangleRounded());
56674
+ };
56675
+
56676
+ /*
56677
+ * Copyright (C) 2019 Toshiba Corporation
56678
+ * SPDX-License-Identifier: Apache-2.0
56679
+ */
56680
+ var loadShapeTriangleRounded = function () {
56681
+ EShapeUploadeds[EShapeType.TRIANGLE_ROUNDED] = createPolygonUploaded;
56682
+ EShapeDeserializers[EShapeType.TRIANGLE_ROUNDED] = deserializeTriangleRounded;
56683
+ EShapeCapabilities.set(EShapeType.TRIANGLE_ROUNDED, EShapeCapability.PRIMITIVE | EShapeCapability.BORDER_RADIUS);
56684
+ };
56685
+
56195
56686
  /*
56196
56687
  * Copyright (C) 2019 Toshiba Corporation
56197
56688
  * SPDX-License-Identifier: Apache-2.0
56198
56689
  */
56199
- var BuilderTriangleRounded = /** @class */ (function (_super) {
56200
- __extends(BuilderTriangleRounded, _super);
56201
- function BuilderTriangleRounded(buffer, vertexOffset, indexOffset) {
56202
- var _this = _super.call(this, buffer, vertexOffset, indexOffset, TRIANGLE_ROUNDED_VERTEX_COUNT, TRIANGLE_ROUNDED_INDEX_COUNT) || this;
56690
+ var BuilderTriangleRoundedLegacy = /** @class */ (function (_super) {
56691
+ __extends(BuilderTriangleRoundedLegacy, _super);
56692
+ function BuilderTriangleRoundedLegacy(buffer, vertexOffset, indexOffset) {
56693
+ var _this = _super.call(this, buffer, vertexOffset, indexOffset, TRIANGLE_ROUNDED_LEGACY_VERTEX_COUNT, TRIANGLE_ROUNDED_LEGACY_INDEX_COUNT) || this;
56203
56694
  _this.radius = 0;
56204
56695
  _this.corner = 0;
56205
56696
  return _this;
56206
56697
  }
56207
- BuilderTriangleRounded.prototype.init = function () {
56698
+ BuilderTriangleRoundedLegacy.prototype.init = function () {
56208
56699
  var buffer = this.buffer;
56209
56700
  buffer.updateIndices();
56210
- buildTriangleRoundedIndex(buffer.indices, this.vertexOffset, this.indexOffset);
56701
+ buildTriangleRoundedLegacyIndex(buffer.indices, this.vertexOffset, this.indexOffset);
56211
56702
  this.inited |= BuilderFlag.INDEX;
56212
56703
  };
56213
- BuilderTriangleRounded.prototype.update = function (shape) {
56704
+ BuilderTriangleRoundedLegacy.prototype.update = function (shape) {
56214
56705
  var buffer = this.buffer;
56215
56706
  this.updateVertexStepAndUv(buffer, shape);
56216
56707
  this.updateColor(buffer, shape);
56217
56708
  };
56218
- BuilderTriangleRounded.prototype.updateVertexStepAndUv = function (buffer, shape) {
56709
+ BuilderTriangleRoundedLegacy.prototype.updateVertexStepAndUv = function (buffer, shape) {
56219
56710
  var size = shape.size;
56220
56711
  var sizeX = size.x;
56221
56712
  var sizeY = size.y;
@@ -56256,55 +56747,55 @@
56256
56747
  this.textureTransformId = textureTransformId;
56257
56748
  var voffset = this.vertexOffset;
56258
56749
  buffer.updateVertices();
56259
- buildTriangleRoundedVertex(buffer.vertices, voffset, 0, 0, sizeX, sizeY, strokeAlign, strokeWidth, radius, shape.transform.internalTransform, TRIANGLE_ROUNDED_WORLD_SIZE);
56750
+ buildTriangleRoundedLegacyVertex(buffer.vertices, voffset, 0, 0, sizeX, sizeY, strokeAlign, strokeWidth, radius, shape.transform.internalTransform, TRIANGLE_ROUNDED_LEGACY_WORLD_SIZE);
56260
56751
  if (isNotInited || isVertexChanged || isTransformChanged || isCornerChanged) {
56261
56752
  buffer.updateSteps();
56262
- buildTriangleRoundedStep(buffer.steps, voffset, strokeWidth, strokeStyle, corner, radius, TRIANGLE_ROUNDED_WORLD_SIZE);
56753
+ buildTriangleRoundedLegacyStep(buffer.steps, voffset, strokeWidth, strokeStyle, corner, radius, TRIANGLE_ROUNDED_LEGACY_WORLD_SIZE);
56263
56754
  }
56264
56755
  if (isNotInited || isVertexChanged || isTextureChanged) {
56265
56756
  buffer.updateUvs();
56266
- buildTriangleRoundedUv(buffer.uvs, voffset, toTextureUvs(texture), radius, TRIANGLE_ROUNDED_WORLD_SIZE);
56757
+ buildTriangleRoundedLegacyUv(buffer.uvs, voffset, toTextureUvs(texture), radius, TRIANGLE_ROUNDED_LEGACY_WORLD_SIZE);
56267
56758
  }
56268
56759
  }
56269
56760
  };
56270
- return BuilderTriangleRounded;
56761
+ return BuilderTriangleRoundedLegacy;
56271
56762
  }(BuilderBase));
56272
56763
 
56273
56764
  /*
56274
56765
  * Copyright (C) 2019 Toshiba Corporation
56275
56766
  * SPDX-License-Identifier: Apache-2.0
56276
56767
  */
56277
- var createTriangleRoundedUploaded = function (buffer, shape, voffset, ioffset, antialiasWeight) {
56768
+ var createTriangleRoundedLegacyUploaded = function (buffer, shape, voffset, ioffset, antialiasWeight) {
56278
56769
  var tcount = toTextBufferCount(shape);
56279
56770
  var tvcount = tcount << TEXT_VERTEX_COUNT_SHIFT;
56280
56771
  var ticount = tcount << TEXT_INDEX_COUNT_SHIFT;
56281
- var vcount = TRIANGLE_ROUNDED_VERTEX_COUNT + tvcount;
56282
- var icount = TRIANGLE_ROUNDED_INDEX_COUNT + ticount;
56772
+ var vcount = TRIANGLE_ROUNDED_LEGACY_VERTEX_COUNT + tvcount;
56773
+ var icount = TRIANGLE_ROUNDED_LEGACY_INDEX_COUNT + ticount;
56283
56774
  if (buffer.check(voffset, ioffset, vcount, icount)) {
56284
56775
  return new EShapeUploadedImpl(buffer, voffset, ioffset, vcount, icount, [
56285
- new BuilderTriangleRounded(buffer, voffset, ioffset),
56286
- new BuilderText(buffer, voffset + TRIANGLE_ROUNDED_VERTEX_COUNT, ioffset + TRIANGLE_ROUNDED_INDEX_COUNT, tvcount, ticount)
56776
+ new BuilderTriangleRoundedLegacy(buffer, voffset, ioffset),
56777
+ new BuilderText(buffer, voffset + TRIANGLE_ROUNDED_LEGACY_VERTEX_COUNT, ioffset + TRIANGLE_ROUNDED_LEGACY_INDEX_COUNT, tvcount, ticount)
56287
56778
  ]).init(shape);
56288
56779
  }
56289
56780
  return null;
56290
56781
  };
56291
56782
 
56292
56783
  /*
56293
- * Copyright (C) 2019 Toshiba Corporation
56784
+ * Copyright (C) 2019-2026 Toshiba Corporation
56294
56785
  * SPDX-License-Identifier: Apache-2.0
56295
56786
  */
56296
- var deserializeTriangleRounded = function (item, manager, shape) {
56297
- return deserializeBase(item, manager, shape || new EShapeTriangleRounded());
56787
+ var deserializeTriangleRoundedLegacy = function (item, manager, shape) {
56788
+ return deserializeBase(item, manager, shape || new EShapeTriangleRoundedLegacy());
56298
56789
  };
56299
56790
 
56300
56791
  /*
56301
56792
  * Copyright (C) 2019 Toshiba Corporation
56302
56793
  * SPDX-License-Identifier: Apache-2.0
56303
56794
  */
56304
- var loadShapeTriangleRounded = function () {
56305
- EShapeUploadeds[EShapeType.TRIANGLE_ROUNDED] = createTriangleRoundedUploaded;
56306
- EShapeDeserializers[EShapeType.TRIANGLE_ROUNDED] = deserializeTriangleRounded;
56307
- EShapeCapabilities.set(EShapeType.TRIANGLE_ROUNDED, EShapeCapability.PRIMITIVE | EShapeCapability.BORDER_RADIUS);
56795
+ var loadShapeTriangleRoundedLegacy = function () {
56796
+ EShapeUploadeds[EShapeType.TRIANGLE_ROUNDED_LEGACY] = createTriangleRoundedLegacyUploaded;
56797
+ EShapeDeserializers[EShapeType.TRIANGLE_ROUNDED_LEGACY] = deserializeTriangleRoundedLegacy;
56798
+ EShapeCapabilities.set(EShapeType.TRIANGLE_ROUNDED_LEGACY, EShapeCapability.PRIMITIVE | EShapeCapability.BORDER_RADIUS);
56308
56799
  };
56309
56800
 
56310
56801
  /*
@@ -56334,6 +56825,7 @@
56334
56825
  loadShapeRectangle();
56335
56826
  loadShapeSemicircle();
56336
56827
  loadShapeTriangleLegacy();
56828
+ loadShapeTriangleRoundedLegacy();
56337
56829
  loadShapeTriangleRounded();
56338
56830
  loadShapeTriangle();
56339
56831
  loadShapeLineOfCircles();
@@ -88410,6 +88902,7 @@
88410
88902
  loadShapeRectangle: loadShapeRectangle,
88411
88903
  loadShapeSemicircle: loadShapeSemicircle,
88412
88904
  loadShapeTriangleLegacy: loadShapeTriangleLegacy,
88905
+ loadShapeTriangleRoundedLegacy: loadShapeTriangleRoundedLegacy,
88413
88906
  loadShapeTriangleRounded: loadShapeTriangleRounded,
88414
88907
  loadShapeTriangle: loadShapeTriangle,
88415
88908
  BAR_VERTEX_COUNT: BAR_VERTEX_COUNT,
@@ -88509,13 +89002,20 @@
88509
89002
  buildTriangleLegacyVertex: buildTriangleLegacyVertex,
88510
89003
  buildTriangleLegacyStep: buildTriangleLegacyStep,
88511
89004
  buildTriangleLegacyUv: buildTriangleLegacyUv,
88512
- TRIANGLE_ROUNDED_VERTEX_COUNT: TRIANGLE_ROUNDED_VERTEX_COUNT,
88513
- TRIANGLE_ROUNDED_INDEX_COUNT: TRIANGLE_ROUNDED_INDEX_COUNT,
88514
- TRIANGLE_ROUNDED_WORLD_SIZE: TRIANGLE_ROUNDED_WORLD_SIZE,
88515
- buildTriangleRoundedIndex: buildTriangleRoundedIndex,
88516
- buildTriangleRoundedVertex: buildTriangleRoundedVertex,
88517
- buildTriangleRoundedStep: buildTriangleRoundedStep,
88518
- buildTriangleRoundedUv: buildTriangleRoundedUv,
89005
+ buildTriangleRoundedIndex: buildTriangleRoundedLegacyIndex,
89006
+ buildTriangleRoundedStep: buildTriangleRoundedLegacyStep,
89007
+ buildTriangleRoundedUv: buildTriangleRoundedLegacyUv,
89008
+ buildTriangleRoundedVertex: buildTriangleRoundedLegacyVertex,
89009
+ TRIANGLE_ROUNDED_INDEX_COUNT: TRIANGLE_ROUNDED_LEGACY_INDEX_COUNT,
89010
+ TRIANGLE_ROUNDED_VERTEX_COUNT: TRIANGLE_ROUNDED_LEGACY_VERTEX_COUNT,
89011
+ TRIANGLE_ROUNDED_WORLD_SIZE: TRIANGLE_ROUNDED_LEGACY_WORLD_SIZE,
89012
+ TRIANGLE_ROUNDED_LEGACY_VERTEX_COUNT: TRIANGLE_ROUNDED_LEGACY_VERTEX_COUNT,
89013
+ TRIANGLE_ROUNDED_LEGACY_INDEX_COUNT: TRIANGLE_ROUNDED_LEGACY_INDEX_COUNT,
89014
+ TRIANGLE_ROUNDED_LEGACY_WORLD_SIZE: TRIANGLE_ROUNDED_LEGACY_WORLD_SIZE,
89015
+ buildTriangleRoundedLegacyIndex: buildTriangleRoundedLegacyIndex,
89016
+ buildTriangleRoundedLegacyVertex: buildTriangleRoundedLegacyVertex,
89017
+ buildTriangleRoundedLegacyStep: buildTriangleRoundedLegacyStep,
89018
+ buildTriangleRoundedLegacyUv: buildTriangleRoundedLegacyUv,
88519
89019
  buildTriangleIndex: buildTriangleLegacyIndex,
88520
89020
  buildTriangleStep: buildTriangleLegacyStep,
88521
89021
  buildTriangleUv: buildTriangleLegacyUv,
@@ -88555,7 +89055,8 @@
88555
89055
  BuilderSemicircle: BuilderSemicircle,
88556
89056
  BuilderText: BuilderText,
88557
89057
  BuilderTriangleLegacy: BuilderTriangleLegacy,
88558
- BuilderTriangleRounded: BuilderTriangleRounded,
89058
+ BuilderTriangleRounded: BuilderTriangleRoundedLegacy,
89059
+ BuilderTriangleRoundedLegacy: BuilderTriangleRoundedLegacy,
88559
89060
  BuilderTriangle: BuilderTriangleLegacy,
88560
89061
  BuilderFlag: BuilderFlag,
88561
89062
  toTransformLocalId: toTransformLocalId,
@@ -88593,7 +89094,8 @@
88593
89094
  createRectangleUploaded: createRectangleLegacyUploaded,
88594
89095
  createSemicircleUploaded: createSemicircleUploaded,
88595
89096
  createTriangleLegacyUploaded: createTriangleLegacyUploaded,
88596
- createTriangleRoundedUploaded: createTriangleRoundedUploaded,
89097
+ createTriangleRoundedUploaded: createTriangleRoundedLegacyUploaded,
89098
+ createTriangleRoundedLegacyUploaded: createTriangleRoundedLegacyUploaded,
88597
89099
  createTriangleUploaded: createTriangleLegacyUploaded,
88598
89100
  deserializeAll: deserializeAll,
88599
89101
  deserializeBar: deserializeBar,
@@ -88629,6 +89131,7 @@
88629
89131
  deserializeSemicircle: deserializeSemicircle,
88630
89132
  deserializeTriangleLegacy: deserializeTriangleLegacy,
88631
89133
  deserializeTriangleRounded: deserializeTriangleRounded,
89134
+ deserializeTriangleRoundedLegacy: deserializeTriangleRoundedLegacy,
88632
89135
  deserializeTriangle: deserializeTriangle,
88633
89136
  deserialize: deserialize,
88634
89137
  EShapeBarPoints: EShapeBarPoints,
@@ -88704,6 +89207,8 @@
88704
89207
  EShapeTextOutlineImpl: EShapeTextOutlineImpl,
88705
89208
  EShapeTriangleLegacy: EShapeTriangleLegacy,
88706
89209
  EShapeTriangleRounded: EShapeTriangleRounded,
89210
+ EShapeTriangleRoundedLegacy: EShapeTriangleRoundedLegacy,
89211
+ EShapeTriangleRoundedTriangulatedImpl: EShapeTriangleRoundedTriangulatedImpl,
88707
89212
  EShapeTriangleTriangulatedImpl: EShapeTriangleTriangulatedImpl,
88708
89213
  EShapeTriangle: EShapeTriangle,
88709
89214
  hitTestBBox: hitTestBBox,
@@ -88714,6 +89219,7 @@
88714
89219
  hitTestRectangleRounded: hitTestRectangleRounded,
88715
89220
  hitTestRectangleLegacy: hitTestRectangleLegacy,
88716
89221
  hitTestRectangle: hitTestRectangle,
89222
+ hitTestTriangleRoundedLegacy: hitTestTriangleRoundedLegacy,
88717
89223
  hitTestTriangleRounded: hitTestTriangleRounded,
88718
89224
  hitTestTriangleFilled: hitTestTriangleFilled,
88719
89225
  hitTestTriangleLegacy: hitTestTriangleLegacy,