@wcardinal/wcardinal-ui 0.467.0 → 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 (98) 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-fill.d.ts +2 -0
  19. package/dist/types/wcardinal/ui/shape/variant/hit-test-rectangle-rounded.d.ts +1 -0
  20. package/dist/types/wcardinal/ui/shape/variant/hit-test-triangle-rounded.d.ts +1 -0
  21. package/dist/types/wcardinal/ui/shape/variant/index.d.ts +7 -0
  22. package/dist/wcardinal/ui/shape/e-shape-type.js +1 -0
  23. package/dist/wcardinal/ui/shape/e-shape-type.js.map +1 -1
  24. package/dist/wcardinal/ui/shape/load/index.js +1 -0
  25. package/dist/wcardinal/ui/shape/load/index.js.map +1 -1
  26. package/dist/wcardinal/ui/shape/load/load-shape-all.js +2 -0
  27. package/dist/wcardinal/ui/shape/load/load-shape-all.js.map +1 -1
  28. package/dist/wcardinal/ui/shape/load/load-shape-triangle-rounded-legacy.js +17 -0
  29. package/dist/wcardinal/ui/shape/load/load-shape-triangle-rounded-legacy.js.map +1 -0
  30. package/dist/wcardinal/ui/shape/load/load-shape-triangle-rounded.js +2 -2
  31. package/dist/wcardinal/ui/shape/load/load-shape-triangle-rounded.js.map +1 -1
  32. package/dist/wcardinal/ui/shape/variant/build-rectangle-legacy.js +4 -0
  33. package/dist/wcardinal/ui/shape/variant/build-rectangle-legacy.js.map +1 -1
  34. package/dist/wcardinal/ui/shape/variant/build-rectangle-rounded-legacy.js +20 -19
  35. package/dist/wcardinal/ui/shape/variant/build-rectangle-rounded-legacy.js.map +1 -1
  36. package/dist/wcardinal/ui/shape/variant/build-triangle-legacy.js +4 -0
  37. package/dist/wcardinal/ui/shape/variant/build-triangle-legacy.js.map +1 -1
  38. package/dist/wcardinal/ui/shape/variant/build-triangle-rounded-legacy.js +538 -0
  39. package/dist/wcardinal/ui/shape/variant/build-triangle-rounded-legacy.js.map +1 -0
  40. package/dist/wcardinal/ui/shape/variant/build-triangle-rounded.js +5 -536
  41. package/dist/wcardinal/ui/shape/variant/build-triangle-rounded.js.map +1 -1
  42. package/dist/wcardinal/ui/shape/variant/builder-triangle-rounded-legacy.js +84 -0
  43. package/dist/wcardinal/ui/shape/variant/builder-triangle-rounded-legacy.js.map +1 -0
  44. package/dist/wcardinal/ui/shape/variant/builder-triangle-rounded.js +1 -79
  45. package/dist/wcardinal/ui/shape/variant/builder-triangle-rounded.js.map +1 -1
  46. package/dist/wcardinal/ui/shape/variant/create-triangle-rounded-legacy-uploaded.js +24 -0
  47. package/dist/wcardinal/ui/shape/variant/create-triangle-rounded-legacy-uploaded.js.map +1 -0
  48. package/dist/wcardinal/ui/shape/variant/create-triangle-rounded-uploaded.js +1 -19
  49. package/dist/wcardinal/ui/shape/variant/create-triangle-rounded-uploaded.js.map +1 -1
  50. package/dist/wcardinal/ui/shape/variant/deserialize-triangle-rounded-legacy.js +10 -0
  51. package/dist/wcardinal/ui/shape/variant/deserialize-triangle-rounded-legacy.js.map +1 -0
  52. package/dist/wcardinal/ui/shape/variant/e-shape-circle-triangulated-impl.js +134 -199
  53. package/dist/wcardinal/ui/shape/variant/e-shape-circle-triangulated-impl.js.map +1 -1
  54. package/dist/wcardinal/ui/shape/variant/e-shape-line-of-triangle-roundeds.js +2 -2
  55. package/dist/wcardinal/ui/shape/variant/e-shape-line-of-triangle-roundeds.js.map +1 -1
  56. package/dist/wcardinal/ui/shape/variant/e-shape-rectangle-rounded-legacy.js +2 -2
  57. package/dist/wcardinal/ui/shape/variant/e-shape-rectangle-rounded-legacy.js.map +1 -1
  58. package/dist/wcardinal/ui/shape/variant/e-shape-rectangle-rounded-triangulated-impl.js +62 -64
  59. package/dist/wcardinal/ui/shape/variant/e-shape-rectangle-rounded-triangulated-impl.js.map +1 -1
  60. package/dist/wcardinal/ui/shape/variant/e-shape-triangle-rounded-legacy.js +27 -0
  61. package/dist/wcardinal/ui/shape/variant/e-shape-triangle-rounded-legacy.js.map +1 -0
  62. package/dist/wcardinal/ui/shape/variant/e-shape-triangle-rounded-triangulated-impl.js +437 -0
  63. package/dist/wcardinal/ui/shape/variant/e-shape-triangle-rounded-triangulated-impl.js.map +1 -0
  64. package/dist/wcardinal/ui/shape/variant/e-shape-triangle-rounded-triangulated.js +6 -0
  65. package/dist/wcardinal/ui/shape/variant/e-shape-triangle-rounded-triangulated.js.map +1 -0
  66. package/dist/wcardinal/ui/shape/variant/e-shape-triangle-rounded.js +15 -2
  67. package/dist/wcardinal/ui/shape/variant/e-shape-triangle-rounded.js.map +1 -1
  68. package/dist/wcardinal/ui/shape/variant/hit-test-circle.js +3 -29
  69. package/dist/wcardinal/ui/shape/variant/hit-test-circle.js.map +1 -1
  70. package/dist/wcardinal/ui/shape/variant/hit-test-fill.js +33 -0
  71. package/dist/wcardinal/ui/shape/variant/hit-test-fill.js.map +1 -0
  72. package/dist/wcardinal/ui/shape/variant/hit-test-rectangle-rounded.js +120 -97
  73. package/dist/wcardinal/ui/shape/variant/hit-test-rectangle-rounded.js.map +1 -1
  74. package/dist/wcardinal/ui/shape/variant/hit-test-rectangle.js +3 -29
  75. package/dist/wcardinal/ui/shape/variant/hit-test-rectangle.js.map +1 -1
  76. package/dist/wcardinal/ui/shape/variant/hit-test-triangle-rounded.js +71 -11
  77. package/dist/wcardinal/ui/shape/variant/hit-test-triangle-rounded.js.map +1 -1
  78. package/dist/wcardinal/ui/shape/variant/hit-test-triangle.js +3 -29
  79. package/dist/wcardinal/ui/shape/variant/hit-test-triangle.js.map +1 -1
  80. package/dist/wcardinal/ui/shape/variant/index.js +7 -0
  81. package/dist/wcardinal/ui/shape/variant/index.js.map +1 -1
  82. package/dist/wcardinal-ui-theme-dark-en-us.js +1 -1
  83. package/dist/wcardinal-ui-theme-dark-en-us.min.js +1 -1
  84. package/dist/wcardinal-ui-theme-dark-ja-jp.js +1 -1
  85. package/dist/wcardinal-ui-theme-dark-ja-jp.min.js +1 -1
  86. package/dist/wcardinal-ui-theme-dark.js +1 -1
  87. package/dist/wcardinal-ui-theme-dark.min.js +1 -1
  88. package/dist/wcardinal-ui-theme-white-en-us.js +1 -1
  89. package/dist/wcardinal-ui-theme-white-en-us.min.js +1 -1
  90. package/dist/wcardinal-ui-theme-white-ja-jp.js +1 -1
  91. package/dist/wcardinal-ui-theme-white-ja-jp.min.js +1 -1
  92. package/dist/wcardinal-ui-theme-white.js +1 -1
  93. package/dist/wcardinal-ui-theme-white.min.js +1 -1
  94. package/dist/wcardinal-ui.cjs.js +1050 -567
  95. package/dist/wcardinal-ui.js +1050 -567
  96. package/dist/wcardinal-ui.min.js +2 -2
  97. package/dist/wcardinal-ui.min.js.map +1 -1
  98. package/package.json +1 -1
@@ -1,5 +1,5 @@
1
1
  /*!
2
- Winter Cardinal UI v0.467.0
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
 
@@ -8470,6 +8471,38 @@
8470
8471
  return EShapePrimitive;
8471
8472
  }(EShapeBase));
8472
8473
 
8474
+ var hitTestFill = function (x, y, ax, ay, fill) {
8475
+ if (fill.enable) {
8476
+ var percent = Math.max(0, Math.min(1, fill.percent));
8477
+ if (1 <= percent) {
8478
+ return true;
8479
+ }
8480
+ switch (fill.direction) {
8481
+ case EShapeFillDirection.TOP:
8482
+ if (y + ay <= percent * (2 * ay)) {
8483
+ return true;
8484
+ }
8485
+ break;
8486
+ case EShapeFillDirection.RIGHT:
8487
+ if ((1 - percent) * (2 * ax) <= x + ax) {
8488
+ return true;
8489
+ }
8490
+ break;
8491
+ case EShapeFillDirection.BOTTOM:
8492
+ if ((1 - percent) * (2 * ay) <= y + ay) {
8493
+ return true;
8494
+ }
8495
+ break;
8496
+ case EShapeFillDirection.LEFT:
8497
+ if (x + ax <= percent * (2 * ax)) {
8498
+ return true;
8499
+ }
8500
+ break;
8501
+ }
8502
+ }
8503
+ return false;
8504
+ };
8505
+
8473
8506
  /*
8474
8507
  * Copyright (C) 2019 Toshiba Corporation
8475
8508
  * SPDX-License-Identifier: Apache-2.0
@@ -8507,34 +8540,8 @@
8507
8540
  if (!hitTestCircleFilled(x, y, ax, ay)) {
8508
8541
  return false;
8509
8542
  }
8510
- var fill = shape.fill;
8511
- if (fill.enable) {
8512
- var percent = Math.max(0, Math.min(1, fill.percent));
8513
- if (1 <= percent) {
8514
- return true;
8515
- }
8516
- switch (fill.direction) {
8517
- case EShapeFillDirection.TOP:
8518
- if (y + ay <= percent * (2 * ay)) {
8519
- return true;
8520
- }
8521
- break;
8522
- case EShapeFillDirection.RIGHT:
8523
- if ((1 - percent) * (2 * ax) <= x + ax) {
8524
- return true;
8525
- }
8526
- break;
8527
- case EShapeFillDirection.BOTTOM:
8528
- if ((1 - percent) * (2 * ay) <= y + ay) {
8529
- return true;
8530
- }
8531
- break;
8532
- case EShapeFillDirection.LEFT:
8533
- if (x + ax <= percent * (2 * ax)) {
8534
- return true;
8535
- }
8536
- break;
8537
- }
8543
+ if (hitTestFill(x, y, ax, ay, shape.fill)) {
8544
+ return true;
8538
8545
  }
8539
8546
  return hitTestCircleStroke(x, y, ax, ay, sw, ss);
8540
8547
  };
@@ -8608,34 +8615,8 @@
8608
8615
  if (!hitTestBBox(x, y, ax, ay)) {
8609
8616
  return false;
8610
8617
  }
8611
- var fill = shape.fill;
8612
- if (fill.enable) {
8613
- var percent = Math.max(0, Math.min(1, fill.percent));
8614
- if (1 <= percent) {
8615
- return true;
8616
- }
8617
- switch (fill.direction) {
8618
- case EShapeFillDirection.TOP:
8619
- if (y + ay <= percent * (2 * ay)) {
8620
- return true;
8621
- }
8622
- break;
8623
- case EShapeFillDirection.RIGHT:
8624
- if ((1 - percent) * (2 * ax) <= x + ax) {
8625
- return true;
8626
- }
8627
- break;
8628
- case EShapeFillDirection.BOTTOM:
8629
- if ((1 - percent) * (2 * ay) <= y + ay) {
8630
- return true;
8631
- }
8632
- break;
8633
- case EShapeFillDirection.LEFT:
8634
- if (x + ax <= percent * (2 * ax)) {
8635
- return true;
8636
- }
8637
- break;
8638
- }
8618
+ if (hitTestFill(x, y, ax, ay, shape.fill)) {
8619
+ return true;
8639
8620
  }
8640
8621
  return hitTestRectangleStroke(shape, x, y, ax, ay, sw, ss);
8641
8622
  };
@@ -8685,34 +8666,8 @@
8685
8666
  if (!hitTestTriangleFilled(x, y, a, -ay, +ay)) {
8686
8667
  return false;
8687
8668
  }
8688
- var fill = shape.fill;
8689
- if (fill.enable) {
8690
- var percent = Math.max(0, Math.min(1, fill.percent));
8691
- if (1 <= percent) {
8692
- return true;
8693
- }
8694
- switch (fill.direction) {
8695
- case EShapeFillDirection.TOP:
8696
- if (y + ay <= percent * (2 * ay)) {
8697
- return true;
8698
- }
8699
- break;
8700
- case EShapeFillDirection.RIGHT:
8701
- if ((1 - percent) * (2 * ax) <= x + ax) {
8702
- return true;
8703
- }
8704
- break;
8705
- case EShapeFillDirection.BOTTOM:
8706
- if ((1 - percent) * (2 * ay) <= y + ay) {
8707
- return true;
8708
- }
8709
- break;
8710
- case EShapeFillDirection.LEFT:
8711
- if (x + ax <= percent * (2 * ax)) {
8712
- return true;
8713
- }
8714
- break;
8715
- }
8669
+ if (hitTestFill(x, y, ax, ay, shape.fill)) {
8670
+ return true;
8716
8671
  }
8717
8672
  return hitTestTriangleStroke(x, y, a, ax, ay, sw, ss);
8718
8673
  };
@@ -40674,7 +40629,7 @@
40674
40629
  boundary[3] = +ay;
40675
40630
  // # of vertices and # of indices
40676
40631
  var n = this._n >> 2;
40677
- var nv = 8 * n + 18;
40632
+ var nv = 12 * n + 10;
40678
40633
  var ni = 4 * n + 10;
40679
40634
  this._nvertices = nv;
40680
40635
  this._nindices = ni;
@@ -41304,7 +41259,7 @@
41304
41259
  * Preconditions:
41305
41260
  * * shape.stroke.side === EShapeStrokeSide.TOP_OR_RIGHT
41306
41261
  * * ay <= ax
41307
- * * 5 * N + 5 <= nv
41262
+ * * 6 * N + 3 <= nv
41308
41263
  * * 4 * N + 1 <= ni
41309
41264
  */
41310
41265
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateTopRight0 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -41315,7 +41270,7 @@
41315
41270
  * Preconditions:
41316
41271
  * * shape.stroke.side === EShapeStrokeSide.TOP_OR_RIGHT
41317
41272
  * * ax < ay
41318
- * * 5 * N + 5 <= nv
41273
+ * * 6 * N + 3 <= nv
41319
41274
  * * 4 * N + 1 <= ni
41320
41275
  */
41321
41276
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateTopRight1 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -41447,7 +41402,7 @@
41447
41402
  if (ctr) {
41448
41403
  var lo = lot + 2 * ax - r;
41449
41404
  this.writeFan(+ax - r, -ay + r, 0, -1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
41450
- iv += 2 * n - 1;
41405
+ iv += 3 * (n - 1);
41451
41406
  ii += 3 * (n - 1);
41452
41407
  }
41453
41408
  this.pad(iv, ii, nv, ni, fd);
@@ -41456,7 +41411,7 @@
41456
41411
  * Preconditions:
41457
41412
  * * shape.stroke.side === EShapeStrokeSide.BOTTOM_OR_LEFT
41458
41413
  * * ay <= ax
41459
- * * 5 * N + 5 <= nv
41414
+ * * 6 * N + 3 <= nv
41460
41415
  * * 4 * N + 1 <= ni
41461
41416
  */
41462
41417
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateBottomLeft0 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -41467,7 +41422,7 @@
41467
41422
  * Preconditions:
41468
41423
  * * shape.stroke.side === EShapeStrokeSide.BOTTOM_OR_LEFT
41469
41424
  * * ax < ay
41470
- * * 5 * N + 5 <= nv
41425
+ * * 6 * N + 3 <= nv
41471
41426
  * * 4 * N + 1 <= ni
41472
41427
  */
41473
41428
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateBottomLeft1 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -41601,7 +41556,7 @@
41601
41556
  if (cbl) {
41602
41557
  var lo = lob + 2 * ax - r;
41603
41558
  this.writeFan(-ax + r, +ay - r, 0, 1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
41604
- iv += 2 * n - 1;
41559
+ iv += 3 * (n - 1);
41605
41560
  ii += 3 * (n - 1);
41606
41561
  }
41607
41562
  this.pad(iv, ii, nv, ni, fd);
@@ -41618,7 +41573,7 @@
41618
41573
  * Preconditions:
41619
41574
  * * shape.stroke.side === EShapeStrokeSide.TOP_OR_LEFT
41620
41575
  * * ay <= ax
41621
- * * 5 * N + 5 <= nv
41576
+ * * 6 * N + 3 <= nv
41622
41577
  * * 4 * N + 1 <= ni
41623
41578
  */
41624
41579
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateTopLeft0 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -41629,7 +41584,7 @@
41629
41584
  * Preconditions:
41630
41585
  * * shape.stroke.side === EShapeStrokeSide.TOP_OR_LEFT
41631
41586
  * * ax < ay
41632
- * * 5 * N + 5 <= nv
41587
+ * * 6 * N + 3 <= nv
41633
41588
  * * 4 * N + 1 <= ni
41634
41589
  */
41635
41590
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateTopLeft1 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -41775,7 +41730,7 @@
41775
41730
  if (ctl) {
41776
41731
  var lo = lol + 2 * ay - r;
41777
41732
  this.writeFan(-ax + r, -ay + r, -1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
41778
- iv += 2 * n - 1;
41733
+ iv += 3 * (n - 1);
41779
41734
  ii += 3 * (n - 1);
41780
41735
  }
41781
41736
  this.pad(iv, ii, nv, ni, fd);
@@ -41784,7 +41739,7 @@
41784
41739
  * Preconditions:
41785
41740
  * * shape.stroke.side === EShapeStrokeSide.BOTTOM_OR_RIGHT
41786
41741
  * * ay <= ax
41787
- * * 5 * N + 5 <= nv
41742
+ * * 6 * N + 3 <= nv
41788
41743
  * * 4 * N + 1 <= ni
41789
41744
  */
41790
41745
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateBottomRight0 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -41795,7 +41750,7 @@
41795
41750
  * Preconditions:
41796
41751
  * * shape.stroke.side === EShapeStrokeSide.BOTTOM_OR_RIGHT
41797
41752
  * * ax < ay
41798
- * * 5 * N + 5 <= nv
41753
+ * * 6 * N + 3 <= nv
41799
41754
  * * 4 * N + 1 <= ni
41800
41755
  */
41801
41756
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateBottomRight1 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -41938,7 +41893,7 @@
41938
41893
  if (cbr) {
41939
41894
  var lo = lor + 2 * ay - r;
41940
41895
  this.writeFan(+ax - r, +ay - r, 1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
41941
- iv += 2 * n - 1;
41896
+ iv += 3 * (n - 1);
41942
41897
  ii += 3 * (n - 1);
41943
41898
  }
41944
41899
  this.pad(iv, ii, nv, ni, fd);
@@ -41947,7 +41902,7 @@
41947
41902
  * Preconditions:
41948
41903
  * * shape.stroke.side === EShapeStrokeSide.NOT_TOP
41949
41904
  * * ay <= ax
41950
- * * 6 * N + 12 <= nv
41905
+ * * 8 * N + 8 <= nv
41951
41906
  * * 4 * N + 6 <= ni
41952
41907
  */
41953
41908
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateNotTop0 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -41990,13 +41945,13 @@
41990
41945
  if (cbl) {
41991
41946
  var lo = lob + 2 * ax - r;
41992
41947
  this.writeFan(-ax + r, +ay - r, 0, 1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
41993
- iv += 2 * n - 1;
41948
+ iv += 3 * (n - 1);
41994
41949
  ii += 3 * (n - 1);
41995
41950
  }
41996
41951
  if (cbr) {
41997
41952
  var lo = lor + 2 * ay - r;
41998
41953
  this.writeFan(+ax - r, +ay - r, 1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
41999
- iv += 2 * n - 1;
41954
+ iv += 3 * (n - 1);
42000
41955
  ii += 3 * (n - 1);
42001
41956
  }
42002
41957
  this.pad(iv, ii, nv, ni, fd);
@@ -42005,7 +41960,7 @@
42005
41960
  * Preconditions:
42006
41961
  * * shape.stroke.side === EShapeStrokeSide.NOT_TOP
42007
41962
  * * ax < ay
42008
- * * 6 * N + 12 <= nv
41963
+ * * 8 * N + 8 <= nv
42009
41964
  * * 4 * N + 6 <= ni
42010
41965
  */
42011
41966
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateNotTop1 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -42046,13 +42001,13 @@
42046
42001
  if (cbl) {
42047
42002
  var lo = lob + 2 * ax - r;
42048
42003
  this.writeFan(-ax + r, +ay - r, 0, 1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42049
- iv += 2 * n - 1;
42004
+ iv += 3 * (n - 1);
42050
42005
  ii += 3 * (n - 1);
42051
42006
  }
42052
42007
  if (cbr) {
42053
42008
  var lo = lor + 2 * ay - r;
42054
42009
  this.writeFan(+ax - r, +ay - r, 1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42055
- iv += 2 * n - 1;
42010
+ iv += 3 * (n - 1);
42056
42011
  ii += 3 * (n - 1);
42057
42012
  }
42058
42013
  this.pad(iv, ii, nv, ni, fd);
@@ -42130,7 +42085,7 @@
42130
42085
  * Preconditions:
42131
42086
  * * shape.stroke.side === EShapeStrokeSide.NOT_BOTTOM
42132
42087
  * * ay <= ax
42133
- * * 6 * N + 12 <= nv
42088
+ * * 8 * N + 8 <= nv
42134
42089
  * * 4 * N + 6 <= ni
42135
42090
  */
42136
42091
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateNotBottom0 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -42179,13 +42134,13 @@
42179
42134
  if (ctl) {
42180
42135
  var lo = lol + 2 * ay - r;
42181
42136
  this.writeFan(-ax + r, -ay + r, -1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42182
- iv += 2 * n - 1;
42137
+ iv += 3 * (n - 1);
42183
42138
  ii += 3 * (n - 1);
42184
42139
  }
42185
42140
  if (ctr) {
42186
42141
  var lo = lot + 2 * ax - r;
42187
42142
  this.writeFan(+ax - r, -ay + r, 0, -1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42188
- iv += 2 * n - 1;
42143
+ iv += 3 * (n - 1);
42189
42144
  ii += 3 * (n - 1);
42190
42145
  }
42191
42146
  this.pad(iv, ii, nv, ni, fd);
@@ -42194,7 +42149,7 @@
42194
42149
  * Preconditions:
42195
42150
  * * shape.stroke.side === EShapeStrokeSide.NOT_BOTTOM
42196
42151
  * * ax < ay
42197
- * * 6 * N + 12 <= nv
42152
+ * * 8 * N + 8 <= nv
42198
42153
  * * 4 * N + 6 <= ni
42199
42154
  */
42200
42155
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateNotBottom1 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -42242,13 +42197,13 @@
42242
42197
  if (ctl) {
42243
42198
  var lo = lol + 2 * ay - r;
42244
42199
  this.writeFan(-ax + r, -ay + r, -1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42245
- iv += 2 * n - 1;
42200
+ iv += 3 * (n - 1);
42246
42201
  ii += 3 * (n - 1);
42247
42202
  }
42248
42203
  if (ctr) {
42249
42204
  var lo = lot + 2 * ax - r;
42250
42205
  this.writeFan(+ax - r, -ay + r, 0, -1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42251
- iv += 2 * n - 1;
42206
+ iv += 3 * (n - 1);
42252
42207
  ii += 3 * (n - 1);
42253
42208
  }
42254
42209
  this.pad(iv, ii, nv, ni, fd);
@@ -42323,7 +42278,7 @@
42323
42278
  * Preconditions:
42324
42279
  * * shape.stroke.side === EShapeStrokeSide.NOT_LEFT
42325
42280
  * * ay <= ax
42326
- * * 6 * N + 12 <= nv
42281
+ * * 8 * N + 8 <= nv
42327
42282
  * * 4 * N + 6 <= ni
42328
42283
  */
42329
42284
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateNotLeft0 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -42370,13 +42325,13 @@
42370
42325
  if (ctr) {
42371
42326
  var lo = lot + 2 * ax - r;
42372
42327
  this.writeFan(+ax - r, -ay + r, 0, -1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42373
- iv += 2 * n - 1;
42328
+ iv += 3 * (n - 1);
42374
42329
  ii += 3 * (n - 1);
42375
42330
  }
42376
42331
  if (cbr) {
42377
42332
  var lo = lor + 2 * ay - r;
42378
42333
  this.writeFan(+ax - r, +ay - r, 1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42379
- iv += 2 * n - 1;
42334
+ iv += 3 * (n - 1);
42380
42335
  ii += 3 * (n - 1);
42381
42336
  }
42382
42337
  this.pad(iv, ii, nv, ni, fd);
@@ -42385,7 +42340,7 @@
42385
42340
  * Preconditions:
42386
42341
  * * shape.stroke.side === EShapeStrokeSide.NOT_LEFT
42387
42342
  * * ax < ay
42388
- * * 6 * N + 12 <= nv
42343
+ * * 8 * N + 8 <= nv
42389
42344
  * * 4 * N + 6 <= ni
42390
42345
  */
42391
42346
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateNotLeft1 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -42433,13 +42388,13 @@
42433
42388
  if (ctr) {
42434
42389
  var lo = lot + 2 * ax - r;
42435
42390
  this.writeFan(+ax - r, -ay + r, 0, -1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42436
- iv += 2 * n - 1;
42391
+ iv += 3 * (n - 1);
42437
42392
  ii += 3 * (n - 1);
42438
42393
  }
42439
42394
  if (cbr) {
42440
42395
  var lo = lor + 2 * ay - r;
42441
42396
  this.writeFan(+ax - r, +ay - r, 1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42442
- iv += 2 * n - 1;
42397
+ iv += 3 * (n - 1);
42443
42398
  ii += 3 * (n - 1);
42444
42399
  }
42445
42400
  this.pad(iv, ii, nv, ni, fd);
@@ -42514,7 +42469,7 @@
42514
42469
  * Preconditions:
42515
42470
  * * shape.stroke.side === EShapeStrokeSide.NOT_RIGHT
42516
42471
  * * ay <= ax
42517
- * * 6 * N + 12 <= nv
42472
+ * * 8 * N + 8 <= nv
42518
42473
  * * 4 * N + 6 <= ni
42519
42474
  */
42520
42475
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateNotRight0 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -42555,13 +42510,13 @@
42555
42510
  if (ctl) {
42556
42511
  var lo = lol + 2 * ay - r;
42557
42512
  this.writeFan(-ax + r, -ay + r, -1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42558
- iv += 2 * n - 1;
42513
+ iv += 3 * (n - 1);
42559
42514
  ii += 3 * (n - 1);
42560
42515
  }
42561
42516
  if (cbl) {
42562
42517
  var lo = lob + 2 * ax - r;
42563
42518
  this.writeFan(-ax + r, +ay - r, 0, 1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42564
- iv += 2 * n - 1;
42519
+ iv += 3 * (n - 1);
42565
42520
  ii += 3 * (n - 1);
42566
42521
  }
42567
42522
  this.pad(iv, ii, nv, ni, fd);
@@ -42570,7 +42525,7 @@
42570
42525
  * Preconditions:
42571
42526
  * * shape.stroke.side === EShapeStrokeSide.NOT_RIGHT
42572
42527
  * * ax < ay
42573
- * * 6 * N + 12 <= nv
42528
+ * * 8 * N + 8 <= nv
42574
42529
  * * 4 * N + 6 <= ni
42575
42530
  */
42576
42531
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateNotRight1 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -42612,13 +42567,13 @@
42612
42567
  if (ctl) {
42613
42568
  var lo = lol + 2 * ay - r;
42614
42569
  this.writeFan(-ax + r, -ay + r, -1, 0, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42615
- iv += 2 * n - 1;
42570
+ iv += 3 * (n - 1);
42616
42571
  ii += 3 * (n - 1);
42617
42572
  }
42618
42573
  if (cbl) {
42619
42574
  var lo = lob + 2 * ax - r;
42620
42575
  this.writeFan(-ax + r, +ay - r, 0, 1, lo, iv, ii, n, r, rs, fd, scale, fx, fy);
42621
- iv += 2 * n - 1;
42576
+ iv += 3 * (n - 1);
42622
42577
  ii += 3 * (n - 1);
42623
42578
  }
42624
42579
  this.pad(iv, ii, nv, ni, fd);
@@ -42693,7 +42648,7 @@
42693
42648
  * Preconditions:
42694
42649
  * * shape.stroke.side === EShapeStrokeSide.ALL or NONE
42695
42650
  * * ay <= ax
42696
- * * 8 * N + 18 <= nv
42651
+ * * 12 * N + 10 <= nv
42697
42652
  * * 4 * N + 10 <= ni
42698
42653
  */
42699
42654
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateAll0 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -42738,10 +42693,10 @@
42738
42693
  iv += 5;
42739
42694
  ii += 9;
42740
42695
  var rs = r + fs;
42741
- var l = 2 * ax + lot;
42696
+ var l = 2 * ax + lot - r;
42742
42697
  if (ctr) {
42743
42698
  this.writeFan(x4, y1, 0, -1, l, iv, ii, n, r, rs, fd, s, fx, fy);
42744
- iv += 2 * n - 1;
42699
+ iv += 3 * (n - 1);
42745
42700
  ii += 3 * (n - 1);
42746
42701
  l += 2 * ay + lc;
42747
42702
  }
@@ -42750,7 +42705,7 @@
42750
42705
  }
42751
42706
  if (cbr) {
42752
42707
  this.writeFan(x4, y4, 1, 0, l, iv, ii, n, r, rs, fd, s, fx, fy);
42753
- iv += 2 * n - 1;
42708
+ iv += 3 * (n - 1);
42754
42709
  ii += 3 * (n - 1);
42755
42710
  l += 2 * ax + lc;
42756
42711
  }
@@ -42759,7 +42714,7 @@
42759
42714
  }
42760
42715
  if (cbl) {
42761
42716
  this.writeFan(x1, y4, 0, 1, l, iv, ii, n, r, rs, fd, s, fx, fy);
42762
- iv += 2 * n - 1;
42717
+ iv += 3 * (n - 1);
42763
42718
  ii += 3 * (n - 1);
42764
42719
  l += 2 * ay + lc;
42765
42720
  }
@@ -42768,7 +42723,7 @@
42768
42723
  }
42769
42724
  if (ctl) {
42770
42725
  this.writeFan(x1, y1, -1, 0, l, iv, ii, n, r, rs, fd, s, fx, fy);
42771
- iv += 2 * n - 1;
42726
+ iv += 3 * (n - 1);
42772
42727
  ii += 3 * (n - 1);
42773
42728
  }
42774
42729
  this.pad(iv, ii, nv, ni, fd);
@@ -42777,7 +42732,7 @@
42777
42732
  * Preconditions:
42778
42733
  * * shape.stroke.side === EShapeStrokeSide.ALL or NONE
42779
42734
  * * ax < ay
42780
- * * 8 * N + 18 <= nv
42735
+ * * 12 * N + 10 <= nv
42781
42736
  * * 4 * N + 10 <= ni
42782
42737
  */
42783
42738
  EShapeRectangleRoundedTriangulatedImpl.prototype.updateAll1 = function (fx, fy, ax, ay, scale, radius, corner, nv, ni) {
@@ -42822,10 +42777,10 @@
42822
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);
42823
42778
  iv += 6;
42824
42779
  ii += 12;
42825
- var l = 2 * ax + lot;
42780
+ var l = 2 * ax + lot - r;
42826
42781
  if (ctr) {
42827
42782
  this.writeFan(x4, y1, 0, -1, l, iv, ii, n, r, rs, fd, s, fx, fy);
42828
- iv += 1 + 2 * (n - 1);
42783
+ iv += 3 * (n - 1);
42829
42784
  ii += 3 * (n - 1);
42830
42785
  l += 2 * ay + lc;
42831
42786
  }
@@ -42834,7 +42789,7 @@
42834
42789
  }
42835
42790
  if (cbr) {
42836
42791
  this.writeFan(x4, y4, 1, 0, l, iv, ii, n, r, rs, fd, s, fx, fy);
42837
- iv += 1 + 2 * (n - 1);
42792
+ iv += 3 * (n - 1);
42838
42793
  ii += 3 * (n - 1);
42839
42794
  l += 2 * ax + lc;
42840
42795
  }
@@ -42843,7 +42798,7 @@
42843
42798
  }
42844
42799
  if (cbl) {
42845
42800
  this.writeFan(x1, y4, 0, 1, l, iv, ii, n, r, rs, fd, s, fx, fy);
42846
- iv += 1 + 2 * (n - 1);
42801
+ iv += 3 * (n - 1);
42847
42802
  ii += 3 * (n - 1);
42848
42803
  l += 2 * ay + lc;
42849
42804
  }
@@ -42852,7 +42807,7 @@
42852
42807
  }
42853
42808
  if (ctl) {
42854
42809
  this.writeFan(x1, y1, -1, 0, l, iv, ii, n, r, rs, fd, s, fx, fy);
42855
- iv += 1 + 2 * (n - 1);
42810
+ iv += 3 * (n - 1);
42856
42811
  ii += 3 * (n - 1);
42857
42812
  }
42858
42813
  this.pad(iv, ii, nv, ni, fd);
@@ -43125,29 +43080,27 @@
43125
43080
  var dangle = (Math.PI * 0.5) / (n - 1);
43126
43081
  var c = Math.cos(dangle);
43127
43082
  var s = Math.sin(dangle);
43128
- 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;
43129
43088
  var dx = rs * cos0;
43130
43089
  var dy = rs * sin0;
43131
- var iv0 = iv++;
43132
43090
  var l = lo;
43133
- this.writeVertex(iv0, cx + dx, cy + dy, fd, lo, scale, fx, fy);
43134
- var indices = this._indices;
43135
- var cc = 1 - r * fd;
43136
43091
  for (var i = 0; i < n - 1; ++i) {
43137
- var iv1 = iv++;
43138
- l += dl;
43139
- this.writeVertex(iv1, cx, cy, fd, l, cc, fx, fy);
43140
- var iv2 = iv++;
43141
- l += dl;
43142
43092
  var ndx = c * dx - s * dy;
43143
43093
  var ndy = s * dx + c * dy;
43144
- 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;
43145
43102
  dx = ndx;
43146
43103
  dy = ndy;
43147
- indices[ii++] = iv1;
43148
- indices[ii++] = iv0;
43149
- indices[ii++] = iv2;
43150
- iv0 = iv2;
43151
43104
  }
43152
43105
  };
43153
43106
  EShapeRectangleRoundedTriangulatedImpl.prototype.writeVertexTop = function (vertex, x, y, lengthOffset, fdistance, scale, fx, fy, ax, ay) {
@@ -43179,7 +43132,7 @@
43179
43132
  * Copyright (C) 2019 Toshiba Corporation
43180
43133
  * SPDX-License-Identifier: Apache-2.0
43181
43134
  */
43182
- var hitTestRectangleRounded_ = function (x, y, ax, ay, r, corner) {
43135
+ var hitTestRectangleRoundedFilled = function (x, y, ax, ay, r, corner) {
43183
43136
  var bx0 = -ax + r;
43184
43137
  if (x <= bx0) {
43185
43138
  var by0 = -ay + r;
@@ -43232,116 +43185,138 @@
43232
43185
  }
43233
43186
  }
43234
43187
  };
43235
- var hitTestRectangleRounded = function (shape, x, y, ax, ay, sw, ss) {
43188
+ var hitTestRectangleRoundedStroke = function (shape, x, y, ax, ay, sw, ss, r, corner) {
43189
+ var s = sw * ss;
43190
+ var wx = Math.max(0.0, ax - s);
43191
+ var wy = Math.max(0.0, ay - s);
43192
+ var wr = Math.max(0.0, r - s);
43193
+ if (!hitTestRectangleRoundedFilled(x, y, wx, wy, wr, corner)) {
43194
+ var strokeSide = shape.stroke.side;
43195
+ if (strokeSide === EShapeStrokeSide.ALL) {
43196
+ return true;
43197
+ }
43198
+ else {
43199
+ if (x <= -wx + wr) {
43200
+ var hasLeftSide = !!(strokeSide & EShapeStrokeSide.LEFT);
43201
+ if (y <= -wy + wr) {
43202
+ var hasTopSide = !!(strokeSide & EShapeStrokeSide.TOP);
43203
+ if (hasTopSide && hasLeftSide) {
43204
+ return true;
43205
+ }
43206
+ else if (hasTopSide) {
43207
+ return -wx <= y;
43208
+ }
43209
+ else if (hasLeftSide) {
43210
+ return x <= -wx;
43211
+ }
43212
+ else {
43213
+ return false;
43214
+ }
43215
+ }
43216
+ else if (+wy - wr <= y) {
43217
+ var hasBottomSide = !!(strokeSide & EShapeStrokeSide.BOTTOM);
43218
+ if (hasBottomSide && hasLeftSide) {
43219
+ return true;
43220
+ }
43221
+ else if (hasBottomSide) {
43222
+ return +wx <= y;
43223
+ }
43224
+ else if (hasLeftSide) {
43225
+ return x <= -wx;
43226
+ }
43227
+ else {
43228
+ return false;
43229
+ }
43230
+ }
43231
+ else {
43232
+ return hasLeftSide;
43233
+ }
43234
+ }
43235
+ else if (+wx - wr <= x) {
43236
+ var hasRightSide = !!(strokeSide & EShapeStrokeSide.RIGHT);
43237
+ if (y <= -wy + wr) {
43238
+ var hasTopSide = !!(strokeSide & EShapeStrokeSide.TOP);
43239
+ if (hasTopSide && hasRightSide) {
43240
+ return true;
43241
+ }
43242
+ else if (hasTopSide) {
43243
+ return -wx <= y;
43244
+ }
43245
+ else if (hasRightSide) {
43246
+ return +wx <= x;
43247
+ }
43248
+ else {
43249
+ return false;
43250
+ }
43251
+ }
43252
+ else if (+wy - wr <= y) {
43253
+ var hasBottomSide = !!(strokeSide & EShapeStrokeSide.BOTTOM);
43254
+ if (hasBottomSide && hasRightSide) {
43255
+ return true;
43256
+ }
43257
+ else if (hasBottomSide) {
43258
+ return +wx <= y;
43259
+ }
43260
+ else if (hasRightSide) {
43261
+ return +wx <= x;
43262
+ }
43263
+ else {
43264
+ return false;
43265
+ }
43266
+ }
43267
+ else {
43268
+ return hasRightSide;
43269
+ }
43270
+ }
43271
+ else {
43272
+ if (y <= -wy + wr) {
43273
+ return !!(strokeSide & EShapeStrokeSide.TOP);
43274
+ }
43275
+ else if (+wy - wr <= y) {
43276
+ return !!(strokeSide & EShapeStrokeSide.BOTTOM);
43277
+ }
43278
+ else {
43279
+ return false;
43280
+ }
43281
+ }
43282
+ }
43283
+ }
43284
+ return false;
43285
+ };
43286
+ var hitTestRectangleRoundedLegacy = function (shape, x, y, ax, ay, sw, ss) {
43236
43287
  var fill = shape.fill;
43237
43288
  if (fill.enable || 0 < sw) {
43238
43289
  var r = shape.radius * Math.min(ax, ay);
43239
43290
  var corner = shape.corner;
43240
- if (hitTestRectangleRounded_(x, y, ax, ay, r, corner)) {
43291
+ if (hitTestRectangleRoundedFilled(x, y, ax, ay, r, corner)) {
43241
43292
  if (fill.enable) {
43242
43293
  return true;
43243
43294
  }
43244
43295
  else {
43245
- var s = sw * ss;
43246
- var wx = Math.max(0.0, ax - s);
43247
- var wy = Math.max(0.0, ay - s);
43248
- var wr = Math.max(0.0, r - s);
43249
- if (!hitTestRectangleRounded_(x, y, wx, wy, wr, corner)) {
43250
- var strokeSide = shape.stroke.side;
43251
- if (strokeSide === EShapeStrokeSide.ALL) {
43252
- return true;
43253
- }
43254
- else {
43255
- if (x <= -wx + wr) {
43256
- var hasLeftSide = !!(strokeSide & EShapeStrokeSide.LEFT);
43257
- if (y <= -wy + wr) {
43258
- var hasTopSide = !!(strokeSide & EShapeStrokeSide.TOP);
43259
- if (hasTopSide && hasLeftSide) {
43260
- return true;
43261
- }
43262
- else if (hasTopSide) {
43263
- return -wx <= y;
43264
- }
43265
- else if (hasLeftSide) {
43266
- return x <= -wx;
43267
- }
43268
- else {
43269
- return false;
43270
- }
43271
- }
43272
- else if (+wy - wr <= y) {
43273
- var hasBottomSide = !!(strokeSide & EShapeStrokeSide.BOTTOM);
43274
- if (hasBottomSide && hasLeftSide) {
43275
- return true;
43276
- }
43277
- else if (hasBottomSide) {
43278
- return +wx <= y;
43279
- }
43280
- else if (hasLeftSide) {
43281
- return x <= -wx;
43282
- }
43283
- else {
43284
- return false;
43285
- }
43286
- }
43287
- else {
43288
- return hasLeftSide;
43289
- }
43290
- }
43291
- else if (+wx - wr <= x) {
43292
- var hasRightSide = !!(strokeSide & EShapeStrokeSide.RIGHT);
43293
- if (y <= -wy + wr) {
43294
- var hasTopSide = !!(strokeSide & EShapeStrokeSide.TOP);
43295
- if (hasTopSide && hasRightSide) {
43296
- return true;
43297
- }
43298
- else if (hasTopSide) {
43299
- return -wx <= y;
43300
- }
43301
- else if (hasRightSide) {
43302
- return +wx <= x;
43303
- }
43304
- else {
43305
- return false;
43306
- }
43307
- }
43308
- else if (+wy - wr <= y) {
43309
- var hasBottomSide = !!(strokeSide & EShapeStrokeSide.BOTTOM);
43310
- if (hasBottomSide && hasRightSide) {
43311
- return true;
43312
- }
43313
- else if (hasBottomSide) {
43314
- return +wx <= y;
43315
- }
43316
- else if (hasRightSide) {
43317
- return +wx <= x;
43318
- }
43319
- else {
43320
- return false;
43321
- }
43322
- }
43323
- else {
43324
- return hasRightSide;
43325
- }
43326
- }
43327
- else {
43328
- if (y <= -wy + wr) {
43329
- return !!(strokeSide & EShapeStrokeSide.TOP);
43330
- }
43331
- else if (+wy - wr <= y) {
43332
- return !!(strokeSide & EShapeStrokeSide.BOTTOM);
43333
- }
43334
- else {
43335
- return false;
43336
- }
43337
- }
43338
- }
43296
+ if (hitTestRectangleRoundedStroke(shape, x, y, ax, ay, sw, ss, r, corner)) {
43297
+ return true;
43339
43298
  }
43340
43299
  }
43341
43300
  }
43342
43301
  }
43343
43302
  return false;
43344
43303
  };
43304
+ var hitTestRectangleRounded = function (shape, x, y, ax, ay, sw, ss) {
43305
+ var fill = shape.fill;
43306
+ if (fill.enable || 0 < sw) {
43307
+ var r = shape.radius * Math.min(ax, ay);
43308
+ var corner = shape.corner;
43309
+ if (hitTestRectangleRoundedFilled(x, y, ax, ay, r, corner)) {
43310
+ if (hitTestFill(x, y, ax, ay, fill)) {
43311
+ return true;
43312
+ }
43313
+ if (hitTestRectangleRoundedStroke(shape, x, y, ax, ay, sw, ss, r, corner)) {
43314
+ return true;
43315
+ }
43316
+ }
43317
+ }
43318
+ return false;
43319
+ };
43345
43320
 
43346
43321
  /*
43347
43322
  * Copyright (C) 2019 Toshiba Corporation
@@ -43897,6 +43872,7 @@
43897
43872
  this._nvertices = 0;
43898
43873
  this._distances = [];
43899
43874
  this._lengths = [];
43875
+ this._lengthShifts = [];
43900
43876
  this._clippings = [];
43901
43877
  this._uvs = [];
43902
43878
  this._indices = [];
@@ -44023,7 +43999,7 @@
44023
43999
  boundary[2] = +ax;
44024
44000
  boundary[3] = +ay;
44025
44001
  // # of vertices and # of indices
44026
- var nv = 3 * n - 3;
44002
+ var nv = 4 * n - 4;
44027
44003
  var ni = 2 * n - 4;
44028
44004
  this._nvertices = nv;
44029
44005
  this._nindices = ni;
@@ -44088,83 +44064,56 @@
44088
44064
  var dangle = (2 * Math.PI) / n;
44089
44065
  var c = Math.cos(dangle);
44090
44066
  var s = Math.sin(dangle);
44091
- // First Edge
44092
- var x0 = 0;
44093
- var y0 = sizeY;
44094
- var u = -s;
44095
- var v = c;
44096
- var su = scale * u;
44097
- var sv = scale * v;
44098
- var x1 = u * sizeX;
44099
- var y1 = v * sizeY;
44100
- var dx = 0.5 * (x1 + x0) - 0;
44101
- var dy = 0.5 * (y1 + y0) - 0;
44102
- var fdistance = 1 / Math.sqrt(dx * dx + dy * dy);
44103
- var lx = x1 - x0;
44104
- var ly = y1 - y0;
44105
- var dl = Math.sqrt(lx * lx + ly * ly);
44106
- var l1 = dl;
44107
- var l2 = 0.5 * dl;
44108
- vertices[0] = 0;
44109
- vertices[1] = scale * sizeY;
44110
- vertices[2] = su * sizeX;
44111
- vertices[3] = sv * sizeY;
44112
- vertices[4] = 0;
44113
- vertices[5] = 0;
44114
- distances[0] = fdistance;
44115
- distances[1] = fdistance;
44116
- distances[2] = fdistance;
44117
- clippings[0] = scale;
44118
- clippings[1] = scale;
44119
- clippings[2] = 0;
44120
- lengths[0] = 0;
44121
- lengths[1] = l1;
44122
- lengths[2] = l2;
44123
- uvs[0] = 0.5;
44124
- uvs[1] = 0.5 * (scale + 1);
44125
- uvs[2] = 0.5 * (su + 1);
44126
- uvs[3] = 0.5 * (sv + 1);
44127
- uvs[4] = 0.5;
44128
- uvs[5] = 0.5;
44129
- indices[0] = 0;
44130
- indices[1] = 1;
44131
- indices[2] = 2;
44132
- // The Other Edges
44133
- var iv1 = 3;
44134
- var iv2 = 6;
44135
- var ii = 3;
44136
- for (var i = 2; i <= n; ++i) {
44137
- var un = c * u - s * v;
44138
- var vn = s * u + c * v;
44139
- u = un;
44140
- v = vn;
44141
- su = scale * u;
44142
- sv = scale * v;
44143
- l1 += dl;
44144
- l2 += dl;
44145
- vertices[iv2 + 0] = su * sizeX;
44146
- vertices[iv2 + 1] = sv * sizeY;
44147
- vertices[iv2 + 2] = 0;
44148
- vertices[iv2 + 3] = 0;
44149
- distances[iv1 + 0] = fdistance;
44150
- distances[iv1 + 1] = fdistance;
44151
- clippings[iv1 + 0] = scale;
44152
- clippings[iv1 + 1] = 0;
44153
- lengths[iv1 + 0] = l1;
44154
- lengths[iv1 + 1] = l2;
44155
- uvs[iv2 + 0] = 0.5 * (su + 1);
44156
- uvs[iv2 + 1] = 0.5 * (sv + 1);
44157
- uvs[iv2 + 2] = 0.5;
44158
- uvs[iv2 + 3] = 0.5;
44159
- indices[ii + 0] = iv1 - 2;
44160
- indices[ii + 1] = iv1;
44161
- indices[ii + 2] = iv1 + 1;
44162
- iv1 += 2;
44163
- 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;
44164
44113
  ii += 3;
44165
44114
  }
44166
44115
  // Degenerate triangles keep the buffer sizes consistent with elongated circles.
44167
- this.pad(iv1, ii, nv, ni, fdistance);
44116
+ this.pad(iv, ii, nv, ni, fdistance);
44168
44117
  };
44169
44118
  /**
44170
44119
  * Precondition: sizeX !== 0 && sizeY !== 0 && abs(sizeY) < abs(sizeX)
@@ -44179,8 +44128,10 @@
44179
44128
  var dangle = (2 * Math.PI) / n;
44180
44129
  var c = Math.cos(dangle);
44181
44130
  var s = Math.sin(dangle);
44182
- var fx = sizeX / sizeY;
44183
- var fy = sizeY / sizeX;
44131
+ var fx = 1 / sizeX;
44132
+ var fy = 1 / sizeY;
44133
+ var fxy = sizeX * fy;
44134
+ var fyx = sizeY * fx;
44184
44135
  var ileft = n >> 2;
44185
44136
  var iright = ileft * 3;
44186
44137
  var ppx = sizeX * s;
@@ -44189,20 +44140,12 @@
44189
44140
  var py = sizeY;
44190
44141
  var nx = -sizeX * s;
44191
44142
  var ny = sizeY * c;
44192
- var nnx = nx * c - ny * fx * s;
44193
- var nny = nx * fy * s + ny * c;
44143
+ var nnx = nx * c - ny * fxy * s;
44144
+ var nny = nx * fyx * s + ny * c;
44194
44145
  var sx = this.toSkeletonX(ppx, ppy, px, py, nx, ny);
44195
- vertices[0] = 0;
44196
- vertices[1] = sizeY;
44197
- clippings[0] = -1;
44198
- distances[0] = sx;
44199
- lengths[0] = 0;
44200
- uvs[0] = 0.5;
44201
- uvs[1] = 1;
44202
- var iv = 1;
44146
+ var iv = 0;
44203
44147
  var ii = 0;
44204
- var length = 0;
44205
- var current = 0;
44148
+ var l = 0;
44206
44149
  var maxDistance = 0;
44207
44150
  for (var i = 0; i < n; ++i) {
44208
44151
  var inext = (i + 1) % n;
@@ -44218,59 +44161,38 @@
44218
44161
  var dy = ny - py;
44219
44162
  var dl = Math.sqrt(dx * dx + dy * dy);
44220
44163
  var fl = 1 / dl;
44221
- var nlength = length + dl;
44222
- var iv1 = iv++;
44223
- var iv2 = iv1 << 1;
44224
- var niv1 = iv++;
44225
- var niv2 = niv1 << 1;
44226
- var ndistance = Math.abs(-dx * py - dy * (nsx - px)) * fl;
44227
- maxDistance = Math.max(maxDistance, ndistance);
44228
- vertices[iv2 + 0] = nx;
44229
- vertices[iv2 + 1] = ny;
44230
- clippings[iv1] = -1 - ndistance;
44231
- distances[iv1] = nsx;
44232
- lengths[iv1] = nlength;
44233
- uvs[iv2 + 0] = 0.5 * (nx / sizeX + 1);
44234
- uvs[iv2 + 1] = 0.5 * (ny / sizeY + 1);
44235
- vertices[niv2 + 0] = nsx;
44236
- vertices[niv2 + 1] = 0;
44237
- clippings[niv1] = ndistance;
44238
- distances[niv1] = 0;
44239
- lengths[niv1] = length + ((nsx - px) * dx - py * dy) * fl;
44240
- uvs[niv2] = 0.5 * (nsx / sizeX + 1);
44241
- uvs[niv2 + 1] = 0.5;
44242
- indices[ii++] = current;
44243
- indices[ii++] = iv1;
44244
- indices[ii++] = niv1;
44245
- distances[current] = sx;
44246
- if (sx === nsx) {
44247
- clippings[current] = -1 - ndistance;
44248
- }
44249
- else {
44250
- var mdistance = Math.abs(-dx * py - dy * (sx - px)) * fl;
44251
- maxDistance = Math.max(maxDistance, mdistance);
44252
- clippings[current] = -1 - mdistance;
44253
- var miv1 = iv++;
44254
- var miv2 = miv1 << 1;
44255
- vertices[miv2] = sx;
44256
- vertices[miv2 + 1] = 0;
44257
- clippings[miv1] = mdistance;
44258
- distances[miv1] = 0;
44259
- lengths[miv1] = length + ((sx - px) * dx - py * dy) * fl;
44260
- uvs[miv2] = 0.5 * (sx / sizeX + 1);
44261
- uvs[miv2 + 1] = 0.5;
44262
- indices[ii++] = current;
44263
- indices[ii++] = niv1;
44264
- indices[ii++] = miv1;
44265
- }
44266
- current = iv1;
44267
- 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;
44268
44190
  px = nx;
44269
44191
  py = ny;
44270
44192
  nx = nnx;
44271
44193
  ny = nny;
44272
- nnx = c * nx - s * ny * fx;
44273
- nny = s * nx * fy + c * ny;
44194
+ nnx = c * nx - s * ny * fxy;
44195
+ nny = s * nx * fyx + c * ny;
44274
44196
  sx = nsx;
44275
44197
  }
44276
44198
  var fdistance = 0;
@@ -44278,6 +44200,7 @@
44278
44200
  fdistance = 1 / maxDistance;
44279
44201
  }
44280
44202
  var shift = (scale - 1) * maxDistance;
44203
+ var lengthShifts = this._lengthShifts;
44281
44204
  for (var i = 0; i < iv; ++i) {
44282
44205
  var clipping = clippings[i];
44283
44206
  if (0 <= clipping) {
@@ -44290,6 +44213,7 @@
44290
44213
  var factor = shift / distance;
44291
44214
  var x = vertices[i2] + (vertices[i2] - distances[i]) * factor;
44292
44215
  var y = vertices[i2 + 1] * (1 + factor);
44216
+ lengths[i] += factor * lengthShifts[i];
44293
44217
  vertices[i2] = x;
44294
44218
  vertices[i2 + 1] = y;
44295
44219
  uvs[i2] = 0.5 * (x / sizeX + 1);
@@ -44326,8 +44250,10 @@
44326
44250
  var dangle = (2 * Math.PI) / n;
44327
44251
  var c = Math.cos(dangle);
44328
44252
  var s = Math.sin(dangle);
44329
- var fx = sizeX / sizeY;
44330
- var fy = sizeY / sizeX;
44253
+ var fx = 1 / sizeX;
44254
+ var fy = 1 / sizeY;
44255
+ var fxy = sizeX * fy;
44256
+ var fyx = sizeY * fx;
44331
44257
  var itop = 0;
44332
44258
  var ibottom = n >> 1;
44333
44259
  var ppx = sizeX * s;
@@ -44338,20 +44264,12 @@
44338
44264
  var py = sizeY;
44339
44265
  var nx = -sizeX * s;
44340
44266
  var ny = sizeY * c;
44341
- var nnx = c * nx - s * ny * fx;
44342
- var nny = s * nx * fy + c * ny;
44267
+ var nnx = c * nx - s * ny * fxy;
44268
+ var nny = s * nx * fyx + c * ny;
44343
44269
  var sy = this.toSkeletonY(pppx, pppy, ppx, ppy, px, py);
44344
- vertices[0] = 0;
44345
- vertices[1] = sizeY;
44346
- clippings[0] = -1;
44347
- distances[0] = sy;
44348
- lengths[0] = 0;
44349
- uvs[0] = 0.5;
44350
- uvs[1] = 1;
44351
- var iv = 1;
44270
+ var iv = 0;
44352
44271
  var ii = 0;
44353
- var length = 0;
44354
- var current = 0;
44272
+ var l = 0;
44355
44273
  var maxDistance = 0;
44356
44274
  for (var i = 0; i < n; ++i) {
44357
44275
  var inext = (i + 1) % n;
@@ -44367,59 +44285,38 @@
44367
44285
  var dy = ny - py;
44368
44286
  var dl = Math.sqrt(dx * dx + dy * dy);
44369
44287
  var fl = 1 / dl;
44370
- var nlength = length + dl;
44371
- var iv1 = iv++;
44372
- var iv2 = iv1 << 1;
44373
- var niv1 = iv++;
44374
- var niv2 = niv1 << 1;
44375
- var ndistance = Math.abs(dx * (nsy - py) + dy * px) * fl;
44376
- maxDistance = Math.max(maxDistance, ndistance);
44377
- vertices[iv2 + 0] = nx;
44378
- vertices[iv2 + 1] = ny;
44379
- clippings[iv1] = -1 - ndistance;
44380
- distances[iv1] = nsy;
44381
- lengths[iv1] = nlength;
44382
- uvs[iv2 + 0] = 0.5 * (nx / sizeX + 1);
44383
- uvs[iv2 + 1] = 0.5 * (ny / sizeY + 1);
44384
- vertices[niv2] = 0;
44385
- vertices[niv2 + 1] = nsy;
44386
- clippings[niv1] = ndistance;
44387
- distances[niv1] = 0;
44388
- lengths[niv1] = length + (-px * dx + (nsy - py) * dy) * fl;
44389
- uvs[niv2] = 0.5;
44390
- uvs[niv2 + 1] = 0.5 * (nsy / sizeY + 1);
44391
- indices[ii++] = current;
44392
- indices[ii++] = iv1;
44393
- indices[ii++] = niv1;
44394
- distances[current] = sy;
44395
- if (sy === nsy) {
44396
- clippings[current] = -1 - ndistance;
44397
- }
44398
- else {
44399
- var mdistance = Math.abs(dx * (sy - py) + dy * px) * fl;
44400
- maxDistance = Math.max(maxDistance, mdistance);
44401
- clippings[current] = -1 - mdistance;
44402
- var miv1 = iv++;
44403
- var miv2 = miv1 << 1;
44404
- vertices[miv2] = 0;
44405
- vertices[miv2 + 1] = sy;
44406
- clippings[miv1] = mdistance;
44407
- distances[miv1] = 0;
44408
- lengths[miv1] = length + (-px * dx + (sy - py) * dy) * fl;
44409
- uvs[miv2] = 0.5;
44410
- uvs[miv2 + 1] = 0.5 * (sy / sizeY + 1);
44411
- indices[ii++] = current;
44412
- indices[ii++] = niv1;
44413
- indices[ii++] = miv1;
44414
- }
44415
- current = iv1;
44416
- 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;
44417
44314
  px = nx;
44418
44315
  py = ny;
44419
44316
  nx = nnx;
44420
44317
  ny = nny;
44421
- nnx = c * nx - s * ny * fx;
44422
- nny = s * nx * fy + c * ny;
44318
+ nnx = c * nx - s * ny * fxy;
44319
+ nny = s * nx * fyx + c * ny;
44423
44320
  sy = nsy;
44424
44321
  }
44425
44322
  var fdistance = 0;
@@ -44427,6 +44324,7 @@
44427
44324
  fdistance = 1 / maxDistance;
44428
44325
  }
44429
44326
  var shift = (scale - 1) * maxDistance;
44327
+ var lengthShifts = this._lengthShifts;
44430
44328
  for (var i = 0; i < iv; ++i) {
44431
44329
  var clipping = clippings[i];
44432
44330
  if (0 <= clipping) {
@@ -44439,6 +44337,7 @@
44439
44337
  var factor = shift / distance;
44440
44338
  var x = vertices[i2] * (1 + factor);
44441
44339
  var y = vertices[i2 + 1] + (vertices[i2 + 1] - distances[i]) * factor;
44340
+ lengths[i] += factor * lengthShifts[i];
44442
44341
  vertices[i2] = x;
44443
44342
  vertices[i2 + 1] = y;
44444
44343
  uvs[i2] = 0.5 * (x / sizeX + 1);
@@ -44462,6 +44361,17 @@
44462
44361
  var by = pdy * fp + ndy * fn;
44463
44362
  return py - (px * by) / bx;
44464
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
+ };
44465
44375
  return EShapeCircleTriangulatedImpl;
44466
44376
  }());
44467
44377
 
@@ -45392,6 +45302,10 @@
45392
45302
  return BuilderLine;
45393
45303
  }(BuilderBase));
45394
45304
 
45305
+ /*
45306
+ * Copyright (C) 2019 Toshiba Corporation
45307
+ * SPDX-License-Identifier: Apache-2.0
45308
+ */
45395
45309
  var TRIANGLE_LEGACY_VERTEX_COUNT = 7;
45396
45310
  var TRIANGLE_LEGACY_INDEX_COUNT = 3;
45397
45311
  var TRIANGLE_LEGACY_WORLD_SIZE = [0, 0, 0];
@@ -45869,6 +45783,10 @@
45869
45783
  return BuilderNull;
45870
45784
  }());
45871
45785
 
45786
+ /*
45787
+ * Copyright (C) 2019 Toshiba Corporation
45788
+ * SPDX-License-Identifier: Apache-2.0
45789
+ */
45872
45790
  var RECTANGLE_LEGACY_VERTEX_COUNT = 16;
45873
45791
  var RECTANGLE_LEGACY_INDEX_COUNT = 8;
45874
45792
  var RECTANGLE_LEGACY_WORLD_SIZE = [0, 0];
@@ -50665,12 +50583,15 @@
50665
50583
  EShapeDeserializers[EShapeType.LINE_OF_CIRCLES] = deserializeLineOfCircles;
50666
50584
  };
50667
50585
 
50586
+ /*
50587
+ * Copyright (C) 2019 Toshiba Corporation
50588
+ * SPDX-License-Identifier: Apache-2.0
50589
+ */
50668
50590
  var RECTANGLE_ROUNDED_LEGACY_VERTEX_COUNT = 44;
50669
50591
  var RECTANGLE_ROUNDED_LEGACY_INDEX_COUNT = 24;
50670
50592
  var RECTANGLE_ROUNDED_LEGACY_WORLD_SIZE = [
50671
50593
  0, 0, 0, 0, 0
50672
50594
  ];
50673
- var RECTANGLE_ROUNDED_LEGACY_WORK_POINT = new pixi_js.Point();
50674
50595
  var buildRectangleRoundedLegacyIndex = function (indices, voffset, ioffset) {
50675
50596
  // c0 c1 c4 c5
50676
50597
  // |---| |---|
@@ -50784,22 +50705,21 @@
50784
50705
  var sy = sizeY * 0.5 + (0 <= sizeY ? +s : -s);
50785
50706
  var ax = Math.abs(sx);
50786
50707
  var ay = Math.abs(sy);
50787
- var a = radius * Math.min(ax, ay);
50788
- var rx = a / ax;
50789
- var ry = a / ay;
50790
- var work = RECTANGLE_ROUNDED_LEGACY_WORK_POINT;
50791
- work.set(originX - sx, originY - sy);
50792
- internalTransform.apply(work, work);
50793
- var b0x = work.x;
50794
- var b0y = work.y;
50795
- work.set(originX, originY - sy);
50796
- internalTransform.apply(work, work);
50797
- var b1x = work.x;
50798
- var b1y = work.y;
50799
- work.set(originX - sx, originY);
50800
- internalTransform.apply(work, work);
50801
- var b3x = work.x;
50802
- 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;
50803
50723
  var d01x = b1x - b0x;
50804
50724
  var d01y = b1y - b0y;
50805
50725
  var d03x = b3x - b0x;
@@ -51025,7 +50945,7 @@
51025
50945
  // World size
51026
50946
  worldSize[0] = ax;
51027
50947
  worldSize[1] = ay;
51028
- worldSize[2] = a;
50948
+ worldSize[2] = az;
51029
50949
  worldSize[3] = rx;
51030
50950
  worldSize[4] = ry;
51031
50951
  };
@@ -51873,7 +51793,7 @@
51873
51793
  };
51874
51794
  EShapeRectangleRoundedLegacy.prototype.containsAbs = function (x, y, ax, ay, sw, ss, sa) {
51875
51795
  if (_super.prototype.containsAbsBBox.call(this, x, y, ax, ay)) {
51876
- return hitTestRectangleRounded(this, x, y, ax, ay, sw, ss);
51796
+ return hitTestRectangleRoundedLegacy(this, x, y, ax, ay, sw, ss);
51877
51797
  }
51878
51798
  return false;
51879
51799
  };
@@ -52153,13 +52073,16 @@
52153
52073
  EShapeCapabilities.set(EShapeType.LINE_OF_RECTANGLES, EShapeCapability.PRIMITIVE | EShapeCapability.STROKE_SIDE);
52154
52074
  };
52155
52075
 
52156
- var TRIANGLE_ROUNDED_VERTEX_COUNT = 22;
52157
- var TRIANGLE_ROUNDED_INDEX_COUNT = 15;
52158
- 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 = [
52159
52083
  0, 0, 0, 0, 0
52160
52084
  ];
52161
- var TRIANGLE_ROUNDED_WORK_POINT = new pixi_js.Point();
52162
- var buildTriangleRoundedIndex = function (indices, voffset, ioffset) {
52085
+ var buildTriangleRoundedLegacyIndex = function (indices, voffset, ioffset) {
52163
52086
  // Top corner
52164
52087
  var ii = ioffset * 3 - 1;
52165
52088
  indices[++ii] = voffset + 0;
@@ -52213,7 +52136,7 @@
52213
52136
  indices[++ii] = voffset + 21;
52214
52137
  indices[++ii] = voffset + 13;
52215
52138
  };
52216
- 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) {
52217
52140
  // Calculate the transformed positions
52218
52141
  var s = strokeAlign * strokeWidth;
52219
52142
  var sx = sizeX * 0.5 + (0 <= sizeX ? +s : -s);
@@ -52223,23 +52146,24 @@
52223
52146
  var ry = (sw * radius) / (2 * sy);
52224
52147
  var rz = (0.5 * (sz - sw) * radius) / sz;
52225
52148
  var rx = (ry * sz) / (2 * sx);
52226
- var work = TRIANGLE_ROUNDED_WORK_POINT;
52227
- work.set(originX, originY - sy);
52228
- internalTransform.apply(work, work);
52229
- var x1 = work.x;
52230
- var y1 = work.y;
52231
- work.set(originX, originY);
52232
- internalTransform.apply(work, work);
52233
- var tx = work.x;
52234
- var ty = work.y;
52235
- work.set(originX + sx, originY);
52236
- internalTransform.apply(work, work);
52237
- var dx = tx - x1;
52238
- var dy = ty - y1;
52239
- var x4 = work.x + dx;
52240
- var y4 = work.y + dy;
52241
- var x7 = tx + (tx - work.x) + dx;
52242
- 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;
52243
52167
  var dx14 = x4 - x1;
52244
52168
  var dy14 = y4 - y1;
52245
52169
  var x2 = x1 + rz * dx14;
@@ -52258,10 +52182,8 @@
52258
52182
  var y8 = y7 + ry * dy71;
52259
52183
  var x9 = x1 - rz * dx71;
52260
52184
  var y9 = y1 - rz * dy71;
52261
- work.set(originX, originY + sy - sw); // Incenter of a triangle
52262
- internalTransform.apply(work, work);
52263
- var x0 = work.x;
52264
- var y0 = work.y;
52185
+ var x0 = a * originX + c * (originY + sy - sw) + tx;
52186
+ var y0 = b * originX + d * (originY + sy - sw) + ty;
52265
52187
  var x10 = x1 + radius * (x0 - x1);
52266
52188
  var y10 = y1 + radius * (y0 - y1);
52267
52189
  var x11 = x4 + radius * (x0 - x4);
@@ -52269,8 +52191,8 @@
52269
52191
  var x12 = x7 + radius * (x0 - x7);
52270
52192
  var y12 = y7 + radius * (y0 - y7);
52271
52193
  // World size
52272
- var xb = tx + dx;
52273
- var yb = ty + dy;
52194
+ var xb = ox + dx;
52195
+ var yb = oy + dy;
52274
52196
  worldSize[0] = toLength(xb, yb, x0, y0);
52275
52197
  worldSize[1] = rx;
52276
52198
  worldSize[2] = ry;
@@ -52327,7 +52249,7 @@
52327
52249
  vertices[++iv] = x9;
52328
52250
  vertices[++iv] = y9;
52329
52251
  };
52330
- var buildTriangleRoundedStep = function (steps, voffset, strokeWidth, strokeStyle, corner, radius, worldSize) {
52252
+ var buildTriangleRoundedLegacyStep = function (steps, voffset, strokeWidth, strokeStyle, corner, radius, worldSize) {
52331
52253
  var scaleInvariant = toScaleInvariant(strokeStyle);
52332
52254
  var s = worldSize[0];
52333
52255
  var sr = radius * s;
@@ -52598,7 +52520,7 @@
52598
52520
  steps[++is] = c10;
52599
52521
  steps[++is] = 0;
52600
52522
  };
52601
- var buildTriangleRoundedUv = function (uvs, voffset, textureUvs, radius, worldSize) {
52523
+ var buildTriangleRoundedLegacyUv = function (uvs, voffset, textureUvs, radius, worldSize) {
52602
52524
  var x0 = textureUvs.x0;
52603
52525
  var x1 = textureUvs.x1;
52604
52526
  var x2 = textureUvs.x2;
@@ -52704,8 +52626,8 @@
52704
52626
  var ioffset = this.indexOffset;
52705
52627
  var pointCountReserved = this.pointCountReserved;
52706
52628
  if (0 < pointCountReserved) {
52707
- buildTriangleRoundedIndex(buffer.indices, voffset, ioffset);
52708
- 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);
52709
52631
  }
52710
52632
  this.inited |= BuilderFlag.INDEX;
52711
52633
  };
@@ -52714,7 +52636,7 @@
52714
52636
  if (points instanceof EShapeLineOfAnyPointsImpl) {
52715
52637
  var buffer = this.buffer;
52716
52638
  this.updateVertexStepAndUv(buffer, shape, points);
52717
- this.updateLineOfAnyColor(buffer, shape, points, TRIANGLE_ROUNDED_VERTEX_COUNT);
52639
+ this.updateLineOfAnyColor(buffer, shape, points, TRIANGLE_ROUNDED_LEGACY_VERTEX_COUNT);
52718
52640
  }
52719
52641
  };
52720
52642
  BuilderLineOfTriangleRoundeds.prototype.updateVertexStepAndUv = function (buffer, shape, points) {
@@ -52792,17 +52714,17 @@
52792
52714
  var pointSizeX = pointSize.getX(0);
52793
52715
  var pointSizeY = pointSize.getY(0);
52794
52716
  // Vertices
52795
- buildTriangleRoundedVertex(vertices, voffset, 0, 0, pointSizeX, pointSizeY, strokeAlign, strokeWidth, radius, internalTransform, TRIANGLE_ROUNDED_WORLD_SIZE);
52796
- 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);
52797
52719
  // Steps
52798
52720
  if (isNotInited || isVertexChanged || isTransformChanged || isCornerChanged) {
52799
- buildTriangleRoundedStep(steps, voffset, strokeWidth, strokeStyle, corner, radius, TRIANGLE_ROUNDED_WORLD_SIZE);
52800
- 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);
52801
52723
  }
52802
52724
  // UVs
52803
52725
  if (isNotInited || isVertexChanged || isTextureChanged) {
52804
- buildTriangleRoundedUv(uvs, voffset, textureUvs, radius, TRIANGLE_ROUNDED_WORLD_SIZE);
52805
- 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);
52806
52728
  }
52807
52729
  }
52808
52730
  else {
@@ -52812,23 +52734,23 @@
52812
52734
  var py = pointsValues[ip + 1] + pointOffset.getY(i);
52813
52735
  var pointSizeX = pointSize.getX(i);
52814
52736
  var pointSizeY = pointSize.getY(i);
52815
- var iv = voffset + i * TRIANGLE_ROUNDED_VERTEX_COUNT;
52737
+ var iv = voffset + i * TRIANGLE_ROUNDED_LEGACY_VERTEX_COUNT;
52816
52738
  // Vertices
52817
- 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);
52818
52740
  // Steps
52819
52741
  if (isNotInited || isVertexChanged || isTransformChanged || isCornerChanged) {
52820
- buildTriangleRoundedStep(steps, iv, strokeWidth, strokeStyle, corner, radius, TRIANGLE_ROUNDED_WORLD_SIZE);
52742
+ buildTriangleRoundedLegacyStep(steps, iv, strokeWidth, strokeStyle, corner, radius, TRIANGLE_ROUNDED_LEGACY_WORLD_SIZE);
52821
52743
  }
52822
52744
  // UVs
52823
52745
  if (isNotInited || isVertexChanged || isTextureChanged) {
52824
- buildTriangleRoundedUv(uvs, iv, textureUvs, radius, TRIANGLE_ROUNDED_WORLD_SIZE);
52746
+ buildTriangleRoundedLegacyUv(uvs, iv, textureUvs, radius, TRIANGLE_ROUNDED_LEGACY_WORLD_SIZE);
52825
52747
  }
52826
52748
  }
52827
52749
  }
52828
52750
  // Fill the rest
52829
52751
  var pointCountReserved = this.pointCountReserved;
52830
- var voffsetReserved = voffset + pointCount * TRIANGLE_ROUNDED_VERTEX_COUNT;
52831
- 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);
52832
52754
  buildNullVertex(vertices, voffsetReserved, vcountReserved);
52833
52755
  buildNullStep(steps, voffsetReserved, vcountReserved);
52834
52756
  buildNullUv(uvs, voffsetReserved, vcountReserved);
@@ -52842,16 +52764,15 @@
52842
52764
  * SPDX-License-Identifier: Apache-2.0
52843
52765
  */
52844
52766
  var createLineOfTriangleRoundedsUploaded = function (buffer, shape, voffset, ioffset, antialiasWeight) {
52845
- 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);
52846
52768
  };
52847
52769
 
52848
52770
  /*
52849
52771
  * Copyright (C) 2019 Toshiba Corporation
52850
52772
  * SPDX-License-Identifier: Apache-2.0
52851
52773
  */
52852
- var containsCorner_ = function (shape, x, y, r, aw, sw, ss) {
52853
- var fill = shape.fill;
52854
- if (fill.enable) {
52774
+ var containsCorner_ = function (x, y, r, aw, sw, ss, filled) {
52775
+ if (filled) {
52855
52776
  if (x * x + y * y <= r * r) {
52856
52777
  return true;
52857
52778
  }
@@ -52869,7 +52790,7 @@
52869
52790
  }
52870
52791
  return false;
52871
52792
  };
52872
- 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) {
52873
52794
  var xl = x1 + r12 * (x2 - x1) - x0;
52874
52795
  var yl = y1 + r12 * (y2 - y1) - y0;
52875
52796
  var n = Math.sqrt(xl * xl + yl * yl);
@@ -52889,14 +52810,14 @@
52889
52810
  var yc = y - y0;
52890
52811
  var dx = (+nry * xc - nrx * yc) * deti;
52891
52812
  var dy = (-nly * xc + nlx * yc) * deti;
52892
- if (containsCorner_(shape, dx, dy, n, aw * radius, sw, ss)) {
52813
+ if (containsCorner_(dx, dy, n, aw * radius, sw, ss, filled)) {
52893
52814
  return true;
52894
52815
  }
52895
52816
  }
52896
52817
  }
52897
52818
  return false;
52898
52819
  };
52899
- var hitTestTriangleRounded = function (shape, x, y, ax, ay, sw, ss) {
52820
+ var hitTestTriangleRoundedImpl = function (shape, x, y, ax, ay, sw, ss, filled) {
52900
52821
  var a = (2 * ay) / ax;
52901
52822
  if (hitTestTriangleFilled(x, y, a, -ay, +ay)) {
52902
52823
  var az = Math.sqrt(ax * ax + 4 * ay * ay);
@@ -52923,7 +52844,7 @@
52923
52844
  if (!c0 && !c1 && corner & EShapeCorner.TOP) {
52924
52845
  // Top corner
52925
52846
  var rz = (0.5 * (az - aw) * radius) / az;
52926
- 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)) {
52927
52848
  return true;
52928
52849
  }
52929
52850
  }
@@ -52931,7 +52852,7 @@
52931
52852
  // Bottom-left corner
52932
52853
  var ry = (aw * radius) / (2 * ay);
52933
52854
  var rx = (ry * az) / (2 * ax);
52934
- 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)) {
52935
52856
  return true;
52936
52857
  }
52937
52858
  }
@@ -52939,14 +52860,13 @@
52939
52860
  // Bottom-right corner
52940
52861
  var ry = (aw * radius) / (2 * ay);
52941
52862
  var rx = (ry * az) / (2 * ax);
52942
- 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)) {
52943
52864
  return true;
52944
52865
  }
52945
52866
  }
52946
52867
  else {
52947
52868
  // Others
52948
- var fill = shape.fill;
52949
- if (fill.enable) {
52869
+ if (filled) {
52950
52870
  return true;
52951
52871
  }
52952
52872
  else {
@@ -52964,27 +52884,88 @@
52964
52884
  }
52965
52885
  return false;
52966
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
+ };
52967
52948
 
52968
52949
  /*
52969
52950
  * Copyright (C) 2019 Toshiba Corporation
52970
52951
  * SPDX-License-Identifier: Apache-2.0
52971
52952
  */
52972
- var EShapeTriangleRounded = /** @class */ (function (_super) {
52973
- __extends(EShapeTriangleRounded, _super);
52974
- function EShapeTriangleRounded(type) {
52975
- 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; }
52976
52957
  return _super.call(this, type) || this;
52977
52958
  }
52978
- EShapeTriangleRounded.prototype.clone = function () {
52979
- return new EShapeTriangleRounded(this.type).copy(this);
52959
+ EShapeTriangleRoundedLegacy.prototype.clone = function () {
52960
+ return new EShapeTriangleRoundedLegacy(this.type).copy(this);
52980
52961
  };
52981
- EShapeTriangleRounded.prototype.containsAbs = function (x, y, ax, ay, sw, ss, sa) {
52962
+ EShapeTriangleRoundedLegacy.prototype.containsAbs = function (x, y, ax, ay, sw, ss, sa) {
52982
52963
  if (_super.prototype.containsAbsBBox.call(this, x, y, ax, ay)) {
52983
- return hitTestTriangleRounded(this, x, y, ax, ay, sw, ss);
52964
+ return hitTestTriangleRoundedLegacy(this, x, y, ax, ay, sw, ss);
52984
52965
  }
52985
52966
  return false;
52986
52967
  };
52987
- return EShapeTriangleRounded;
52968
+ return EShapeTriangleRoundedLegacy;
52988
52969
  }(EShapePrimitive));
52989
52970
 
52990
52971
  /*
@@ -53031,7 +53012,7 @@
53031
53012
  return false;
53032
53013
  };
53033
53014
  return EShapeLineOfTriangleRoundeds;
53034
- }(EShapeTriangleRounded));
53015
+ }(EShapeTriangleRoundedLegacy));
53035
53016
 
53036
53017
  /*
53037
53018
  * Copyright (C) 2019 Toshiba Corporation
@@ -56216,30 +56197,516 @@
56216
56197
  EShapeDeserializers[EShapeType.TRIANGLE_LEGACY] = deserializeTriangleLegacy;
56217
56198
  };
56218
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
+
56219
56686
  /*
56220
56687
  * Copyright (C) 2019 Toshiba Corporation
56221
56688
  * SPDX-License-Identifier: Apache-2.0
56222
56689
  */
56223
- var BuilderTriangleRounded = /** @class */ (function (_super) {
56224
- __extends(BuilderTriangleRounded, _super);
56225
- function BuilderTriangleRounded(buffer, vertexOffset, indexOffset) {
56226
- 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;
56227
56694
  _this.radius = 0;
56228
56695
  _this.corner = 0;
56229
56696
  return _this;
56230
56697
  }
56231
- BuilderTriangleRounded.prototype.init = function () {
56698
+ BuilderTriangleRoundedLegacy.prototype.init = function () {
56232
56699
  var buffer = this.buffer;
56233
56700
  buffer.updateIndices();
56234
- buildTriangleRoundedIndex(buffer.indices, this.vertexOffset, this.indexOffset);
56701
+ buildTriangleRoundedLegacyIndex(buffer.indices, this.vertexOffset, this.indexOffset);
56235
56702
  this.inited |= BuilderFlag.INDEX;
56236
56703
  };
56237
- BuilderTriangleRounded.prototype.update = function (shape) {
56704
+ BuilderTriangleRoundedLegacy.prototype.update = function (shape) {
56238
56705
  var buffer = this.buffer;
56239
56706
  this.updateVertexStepAndUv(buffer, shape);
56240
56707
  this.updateColor(buffer, shape);
56241
56708
  };
56242
- BuilderTriangleRounded.prototype.updateVertexStepAndUv = function (buffer, shape) {
56709
+ BuilderTriangleRoundedLegacy.prototype.updateVertexStepAndUv = function (buffer, shape) {
56243
56710
  var size = shape.size;
56244
56711
  var sizeX = size.x;
56245
56712
  var sizeY = size.y;
@@ -56280,55 +56747,55 @@
56280
56747
  this.textureTransformId = textureTransformId;
56281
56748
  var voffset = this.vertexOffset;
56282
56749
  buffer.updateVertices();
56283
- 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);
56284
56751
  if (isNotInited || isVertexChanged || isTransformChanged || isCornerChanged) {
56285
56752
  buffer.updateSteps();
56286
- 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);
56287
56754
  }
56288
56755
  if (isNotInited || isVertexChanged || isTextureChanged) {
56289
56756
  buffer.updateUvs();
56290
- buildTriangleRoundedUv(buffer.uvs, voffset, toTextureUvs(texture), radius, TRIANGLE_ROUNDED_WORLD_SIZE);
56757
+ buildTriangleRoundedLegacyUv(buffer.uvs, voffset, toTextureUvs(texture), radius, TRIANGLE_ROUNDED_LEGACY_WORLD_SIZE);
56291
56758
  }
56292
56759
  }
56293
56760
  };
56294
- return BuilderTriangleRounded;
56761
+ return BuilderTriangleRoundedLegacy;
56295
56762
  }(BuilderBase));
56296
56763
 
56297
56764
  /*
56298
56765
  * Copyright (C) 2019 Toshiba Corporation
56299
56766
  * SPDX-License-Identifier: Apache-2.0
56300
56767
  */
56301
- var createTriangleRoundedUploaded = function (buffer, shape, voffset, ioffset, antialiasWeight) {
56768
+ var createTriangleRoundedLegacyUploaded = function (buffer, shape, voffset, ioffset, antialiasWeight) {
56302
56769
  var tcount = toTextBufferCount(shape);
56303
56770
  var tvcount = tcount << TEXT_VERTEX_COUNT_SHIFT;
56304
56771
  var ticount = tcount << TEXT_INDEX_COUNT_SHIFT;
56305
- var vcount = TRIANGLE_ROUNDED_VERTEX_COUNT + tvcount;
56306
- 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;
56307
56774
  if (buffer.check(voffset, ioffset, vcount, icount)) {
56308
56775
  return new EShapeUploadedImpl(buffer, voffset, ioffset, vcount, icount, [
56309
- new BuilderTriangleRounded(buffer, voffset, ioffset),
56310
- 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)
56311
56778
  ]).init(shape);
56312
56779
  }
56313
56780
  return null;
56314
56781
  };
56315
56782
 
56316
56783
  /*
56317
- * Copyright (C) 2019 Toshiba Corporation
56784
+ * Copyright (C) 2019-2026 Toshiba Corporation
56318
56785
  * SPDX-License-Identifier: Apache-2.0
56319
56786
  */
56320
- var deserializeTriangleRounded = function (item, manager, shape) {
56321
- return deserializeBase(item, manager, shape || new EShapeTriangleRounded());
56787
+ var deserializeTriangleRoundedLegacy = function (item, manager, shape) {
56788
+ return deserializeBase(item, manager, shape || new EShapeTriangleRoundedLegacy());
56322
56789
  };
56323
56790
 
56324
56791
  /*
56325
56792
  * Copyright (C) 2019 Toshiba Corporation
56326
56793
  * SPDX-License-Identifier: Apache-2.0
56327
56794
  */
56328
- var loadShapeTriangleRounded = function () {
56329
- EShapeUploadeds[EShapeType.TRIANGLE_ROUNDED] = createTriangleRoundedUploaded;
56330
- EShapeDeserializers[EShapeType.TRIANGLE_ROUNDED] = deserializeTriangleRounded;
56331
- 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);
56332
56799
  };
56333
56800
 
56334
56801
  /*
@@ -56358,6 +56825,7 @@
56358
56825
  loadShapeRectangle();
56359
56826
  loadShapeSemicircle();
56360
56827
  loadShapeTriangleLegacy();
56828
+ loadShapeTriangleRoundedLegacy();
56361
56829
  loadShapeTriangleRounded();
56362
56830
  loadShapeTriangle();
56363
56831
  loadShapeLineOfCircles();
@@ -88434,6 +88902,7 @@
88434
88902
  loadShapeRectangle: loadShapeRectangle,
88435
88903
  loadShapeSemicircle: loadShapeSemicircle,
88436
88904
  loadShapeTriangleLegacy: loadShapeTriangleLegacy,
88905
+ loadShapeTriangleRoundedLegacy: loadShapeTriangleRoundedLegacy,
88437
88906
  loadShapeTriangleRounded: loadShapeTriangleRounded,
88438
88907
  loadShapeTriangle: loadShapeTriangle,
88439
88908
  BAR_VERTEX_COUNT: BAR_VERTEX_COUNT,
@@ -88533,13 +89002,20 @@
88533
89002
  buildTriangleLegacyVertex: buildTriangleLegacyVertex,
88534
89003
  buildTriangleLegacyStep: buildTriangleLegacyStep,
88535
89004
  buildTriangleLegacyUv: buildTriangleLegacyUv,
88536
- TRIANGLE_ROUNDED_VERTEX_COUNT: TRIANGLE_ROUNDED_VERTEX_COUNT,
88537
- TRIANGLE_ROUNDED_INDEX_COUNT: TRIANGLE_ROUNDED_INDEX_COUNT,
88538
- TRIANGLE_ROUNDED_WORLD_SIZE: TRIANGLE_ROUNDED_WORLD_SIZE,
88539
- buildTriangleRoundedIndex: buildTriangleRoundedIndex,
88540
- buildTriangleRoundedVertex: buildTriangleRoundedVertex,
88541
- buildTriangleRoundedStep: buildTriangleRoundedStep,
88542
- 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,
88543
89019
  buildTriangleIndex: buildTriangleLegacyIndex,
88544
89020
  buildTriangleStep: buildTriangleLegacyStep,
88545
89021
  buildTriangleUv: buildTriangleLegacyUv,
@@ -88579,7 +89055,8 @@
88579
89055
  BuilderSemicircle: BuilderSemicircle,
88580
89056
  BuilderText: BuilderText,
88581
89057
  BuilderTriangleLegacy: BuilderTriangleLegacy,
88582
- BuilderTriangleRounded: BuilderTriangleRounded,
89058
+ BuilderTriangleRounded: BuilderTriangleRoundedLegacy,
89059
+ BuilderTriangleRoundedLegacy: BuilderTriangleRoundedLegacy,
88583
89060
  BuilderTriangle: BuilderTriangleLegacy,
88584
89061
  BuilderFlag: BuilderFlag,
88585
89062
  toTransformLocalId: toTransformLocalId,
@@ -88617,7 +89094,8 @@
88617
89094
  createRectangleUploaded: createRectangleLegacyUploaded,
88618
89095
  createSemicircleUploaded: createSemicircleUploaded,
88619
89096
  createTriangleLegacyUploaded: createTriangleLegacyUploaded,
88620
- createTriangleRoundedUploaded: createTriangleRoundedUploaded,
89097
+ createTriangleRoundedUploaded: createTriangleRoundedLegacyUploaded,
89098
+ createTriangleRoundedLegacyUploaded: createTriangleRoundedLegacyUploaded,
88621
89099
  createTriangleUploaded: createTriangleLegacyUploaded,
88622
89100
  deserializeAll: deserializeAll,
88623
89101
  deserializeBar: deserializeBar,
@@ -88653,6 +89131,7 @@
88653
89131
  deserializeSemicircle: deserializeSemicircle,
88654
89132
  deserializeTriangleLegacy: deserializeTriangleLegacy,
88655
89133
  deserializeTriangleRounded: deserializeTriangleRounded,
89134
+ deserializeTriangleRoundedLegacy: deserializeTriangleRoundedLegacy,
88656
89135
  deserializeTriangle: deserializeTriangle,
88657
89136
  deserialize: deserialize,
88658
89137
  EShapeBarPoints: EShapeBarPoints,
@@ -88728,15 +89207,19 @@
88728
89207
  EShapeTextOutlineImpl: EShapeTextOutlineImpl,
88729
89208
  EShapeTriangleLegacy: EShapeTriangleLegacy,
88730
89209
  EShapeTriangleRounded: EShapeTriangleRounded,
89210
+ EShapeTriangleRoundedLegacy: EShapeTriangleRoundedLegacy,
89211
+ EShapeTriangleRoundedTriangulatedImpl: EShapeTriangleRoundedTriangulatedImpl,
88731
89212
  EShapeTriangleTriangulatedImpl: EShapeTriangleTriangulatedImpl,
88732
89213
  EShapeTriangle: EShapeTriangle,
88733
89214
  hitTestBBox: hitTestBBox,
88734
89215
  hitTestCircleLegacy: hitTestCircleLegacy,
88735
89216
  hitTestCircle: hitTestCircle,
88736
89217
  hitTestSemicircle: hitTestSemicircle,
89218
+ hitTestRectangleRoundedLegacy: hitTestRectangleRoundedLegacy,
88737
89219
  hitTestRectangleRounded: hitTestRectangleRounded,
88738
89220
  hitTestRectangleLegacy: hitTestRectangleLegacy,
88739
89221
  hitTestRectangle: hitTestRectangle,
89222
+ hitTestTriangleRoundedLegacy: hitTestTriangleRoundedLegacy,
88740
89223
  hitTestTriangleRounded: hitTestTriangleRounded,
88741
89224
  hitTestTriangleFilled: hitTestTriangleFilled,
88742
89225
  hitTestTriangleLegacy: hitTestTriangleLegacy,