@drincs/pixi-vn 0.9.7 → 0.9.9

package/dist/classes/ticker/index.js

@@ -4,20 +4,19 @@ import {
   RotateTicker,
   TickerBase,
   ZoomTicker
-} from "../../chunk-NB4Q3GFK.js";
+} from "../../chunk-RGKEAZTY.js";
 import "../../chunk-OMPJ74CO.js";
 import "../../chunk-2JGQWY5I.js";
-import "../../chunk-2BUPSB7O.js";
-import "../../chunk-IRUKNG2Y.js";
-import "../../chunk-6GJXIPNB.js";
-import "../../chunk-I6TNJEE3.js";
 import "../../chunk-DPUSONJ3.js";
-import "../../chunk-WNOARCWH.js";
+import "../../chunk-GEY6RTYO.js";
+import "../../chunk-2BUPSB7O.js";
+import "../../chunk-LZNY6NEZ.js";
 import "../../chunk-6FAGAUDR.js";
+import "../../chunk-I6TNJEE3.js";
 import "../../chunk-RI37WOHP.js";
 import "../../chunk-ETZISN54.js";
 import "../../chunk-VXCA724Z.js";
-import "../../chunk-PP5T5HEO.js";
+import "../../chunk-52ZSR3AN.js";
 import "../../chunk-ZZLQ3ILH.js";
 import "../../chunk-JTQGULTR.js";
 import "../../chunk-FHNQBWIZ.js";
@@ -25,16 +24,16 @@ import "../../chunk-ZBUW3MBH.js";
 import "../../chunk-PIYIZHZL.js";
 import "../../chunk-B7XQM2BB.js";
 import "../../chunk-LEMOIFSV.js";
-import "../../chunk-TOG67Z7Q.js";
-import "../../chunk-WS3FY4Q6.js";
-import "../../chunk-Z3NBKYVU.js";
-import "../../chunk-SAUNZQHZ.js";
-import "../../chunk-CAWOWL3P.js";
-import "../../chunk-ODIEVSQX.js";
-import "../../chunk-5JREOVCG.js";
-import "../../chunk-73ID6GAW.js";
-import "../../chunk-5VX2VTDZ.js";
-import "../../chunk-PP3SBC3C.js";
+import "../../chunk-V7WJOX65.js";
+import "../../chunk-X55ALTH7.js";
+import "../../chunk-MQPMJVDR.js";
+import "../../chunk-D753T42C.js";
+import "../../chunk-IG7HSAEJ.js";
+import "../../chunk-F74VVSHO.js";
+import "../../chunk-XGGTEP7V.js";
+import "../../chunk-UWBWDBB3.js";
+import "../../chunk-BJGKFUMU.js";
+import "../../chunk-KAHX5SKO.js";
 import "../../chunk-HKAY3U4R.js";
 import "../../chunk-SJIEQTBV.js";
 import "../../chunk-CBG6JWY4.js";

package/dist/constants.cjs

@@ -2491,22 +2491,25 @@ var init_Rectangle = __esm({
        * @param x - The X coordinate of the point to test
        * @param y - The Y coordinate of the point to test
        * @param strokeWidth - The width of the line to check
+       * @param alignment - The alignment of the stroke, 0.5 by default
        * @returns Whether the x/y coordinates are within this rectangle
        */
-      strokeContains(x2, y2, strokeWidth) {
+      strokeContains(x2, y2, strokeWidth, alignment = 0.5) {
         const { width, height } = this;
         if (width <= 0 || height <= 0)
           return false;
         const _x = this.x;
         const _y = this.y;
-        const outerLeft = _x - strokeWidth / 2;
-        const outerRight = _x + width + strokeWidth / 2;
-        const outerTop = _y - strokeWidth / 2;
-        const outerBottom = _y + height + strokeWidth / 2;
-        const innerLeft = _x + strokeWidth / 2;
-        const innerRight = _x + width - strokeWidth / 2;
-        const innerTop = _y + strokeWidth / 2;
-        const innerBottom = _y + height - strokeWidth / 2;
+        const strokeWidthOuter = strokeWidth * (1 - alignment);
+        const strokeWidthInner = strokeWidth - strokeWidthOuter;
+        const outerLeft = _x - strokeWidthOuter;
+        const outerRight = _x + width + strokeWidthOuter;
+        const outerTop = _y - strokeWidthOuter;
+        const outerBottom = _y + height + strokeWidthOuter;
+        const innerLeft = _x + strokeWidthInner;
+        const innerRight = _x + width - strokeWidthInner;
+        const innerTop = _y + strokeWidthInner;
+        const innerBottom = _y + height - strokeWidthInner;
         return x2 >= outerLeft && x2 <= outerRight && y2 >= outerTop && y2 <= outerBottom && !(x2 > innerLeft && x2 < innerRight && y2 > innerTop && y2 < innerBottom);
       }
       /**
@@ -3627,24 +3630,22 @@ var init_toLocalGlobalMixin = __esm({
 });
 
 // node_modules/pixi.js/lib/rendering/renderers/shared/instructions/InstructionSet.mjs
-var _tick, InstructionSet;
+var InstructionSet;
 var init_InstructionSet = __esm({
   "node_modules/pixi.js/lib/rendering/renderers/shared/instructions/InstructionSet.mjs"() {
     "use strict";
     init_uid();
-    _tick = 0;
     InstructionSet = class {
       constructor() {
         this.uid = uid("instructionSet");
         this.instructions = [];
         this.instructionSize = 0;
         this.renderables = [];
-        this.tick = 0;
+        this.gcTick = 0;
       }
       /** reset the instruction set so it can be reused set size back to 0 */
       reset() {
         this.instructionSize = 0;
-        this.tick = _tick++;
       }
       /**
        * Add an instruction to the set
@@ -4803,6 +4804,7 @@ var init_RenderGroup = __esm({
         this.worldAlpha = 1;
         this.childrenToUpdate = /* @__PURE__ */ Object.create(null);
         this.updateTick = 0;
+        this.gcTick = 0;
         this.childrenRenderablesToUpdate = { list: [], index: 0 };
         this.structureDidChange = true;
         this.instructionSet = new InstructionSet();
@@ -4818,7 +4820,9 @@ var init_RenderGroup = __esm({
         root.didChange = true;
         const children = root.children;
         for (let i2 = 0; i2 < children.length; i2++) {
-          this.addChild(children[i2]);
+          const child = children[i2];
+          child._updateFlags = 15;
+          this.addChild(child);
         }
       }
       enableCacheAsTexture(options = {}) {
@@ -10752,8 +10756,7 @@ var init_ViewContainer = __esm({
         this.canBundle = true;
         this.allowChildren = false;
         this._roundPixels = 0;
-        this._lastUsed = 0;
-        this._lastInstructionTick = -1;
+        this._lastUsed = -1;
         this._bounds = new Bounds(0, 1, 0, 0);
         this._boundsDirty = true;
       }
@@ -18050,17 +18053,18 @@ var init_Circle = __esm({
        * @param x - The X coordinate of the point to test
        * @param y - The Y coordinate of the point to test
        * @param width - The width of the line to check
+       * @param alignment - The alignment of the stroke, 0.5 by default
        * @returns Whether the x/y coordinates are within this Circle
        */
-      strokeContains(x2, y2, width) {
+      strokeContains(x2, y2, width, alignment = 0.5) {
         if (this.radius === 0)
           return false;
         const dx = this.x - x2;
         const dy = this.y - y2;
-        const r2 = this.radius;
-        const w2 = width / 2;
+        const radius = this.radius;
+        const outerWidth = (1 - alignment) * width;
         const distance = Math.sqrt(dx * dx + dy * dy);
-        return distance < r2 + w2 && distance > r2 - w2;
+        return distance <= radius + outerWidth && distance > radius - (width - outerWidth);
       }
       /**
        * Returns the framing rectangle of the circle as a Rectangle object
@@ -18149,23 +18153,25 @@ var init_Ellipse = __esm({
        * Checks whether the x and y coordinates given are contained within this ellipse including stroke
        * @param x - The X coordinate of the point to test
        * @param y - The Y coordinate of the point to test
-       * @param width
+       * @param strokeWidth - The width of the line to check
+       * @param alignment - The alignment of the stroke
        * @returns Whether the x/y coords are within this ellipse
        */
-      strokeContains(x2, y2, width) {
+      strokeContains(x2, y2, strokeWidth, alignment = 0.5) {
         const { halfWidth, halfHeight } = this;
         if (halfWidth <= 0 || halfHeight <= 0) {
           return false;
         }
-        const halfStrokeWidth = width / 2;
-        const innerA = halfWidth - halfStrokeWidth;
-        const innerB = halfHeight - halfStrokeWidth;
-        const outerA = halfWidth + halfStrokeWidth;
-        const outerB = halfHeight + halfStrokeWidth;
+        const strokeOuterWidth = strokeWidth * (1 - alignment);
+        const strokeInnerWidth = strokeWidth - strokeOuterWidth;
+        const innerHorizontal = halfWidth - strokeInnerWidth;
+        const innerVertical = halfHeight - strokeInnerWidth;
+        const outerHorizontal = halfWidth + strokeOuterWidth;
+        const outerVertical = halfHeight + strokeOuterWidth;
         const normalizedX = x2 - this.x;
         const normalizedY = y2 - this.y;
-        const innerEllipse = normalizedX * normalizedX / (innerA * innerA) + normalizedY * normalizedY / (innerB * innerB);
-        const outerEllipse = normalizedX * normalizedX / (outerA * outerA) + normalizedY * normalizedY / (outerB * outerB);
+        const innerEllipse = normalizedX * normalizedX / (innerHorizontal * innerHorizontal) + normalizedY * normalizedY / (innerVertical * innerVertical);
+        const outerEllipse = normalizedX * normalizedX / (outerHorizontal * outerHorizontal) + normalizedY * normalizedY / (outerVertical * outerVertical);
         return innerEllipse > 1 && outerEllipse <= 1;
       }
       /**
@@ -18307,11 +18313,13 @@ var init_Polygon = __esm({
        * @param x - The X coordinate of the point to test
        * @param y - The Y coordinate of the point to test
        * @param strokeWidth - The width of the line to check
+       * @param alignment - The alignment of the stroke, 0.5 by default
        * @returns Whether the x/y coordinates are within this polygon
        */
-      strokeContains(x2, y2, strokeWidth) {
-        const halfStrokeWidth = strokeWidth / 2;
-        const halfStrokeWidthSqrd = halfStrokeWidth * halfStrokeWidth;
+      strokeContains(x2, y2, strokeWidth, alignment = 0.5) {
+        const strokeWidthSquared = strokeWidth * strokeWidth;
+        const rightWidthSquared = strokeWidthSquared * (1 - alignment);
+        const leftWidthSquared = strokeWidthSquared - rightWidthSquared;
         const { points } = this;
         const iterationLength = points.length - (this.closePath ? 0 : 2);
         for (let i2 = 0; i2 < iterationLength; i2 += 2) {
@@ -18319,8 +18327,9 @@ var init_Polygon = __esm({
           const y1 = points[i2 + 1];
           const x22 = points[(i2 + 2) % points.length];
           const y22 = points[(i2 + 3) % points.length];
-          const distanceSqrd = squaredDistanceToLineSegment(x2, y2, x1, y1, x22, y22);
-          if (distanceSqrd <= halfStrokeWidthSqrd) {
+          const distanceSquared = squaredDistanceToLineSegment(x2, y2, x1, y1, x22, y22);
+          const sign = Math.sign((x22 - x1) * (y2 - y1) - (y22 - y1) * (x2 - x1));
+          if (distanceSquared <= (sign < 0 ? leftWidthSquared : rightWidthSquared)) {
             return true;
           }
         }
@@ -18412,11 +18421,11 @@ var init_RoundedRectangle = __esm({
   "node_modules/pixi.js/lib/maths/shapes/RoundedRectangle.mjs"() {
     "use strict";
     init_Rectangle();
-    isCornerWithinStroke = (pX, pY, cornerX, cornerY, radius, halfStrokeWidth) => {
+    isCornerWithinStroke = (pX, pY, cornerX, cornerY, radius, strokeWidthInner, strokeWidthOuter) => {
       const dx = pX - cornerX;
       const dy = pY - cornerY;
       const distance = Math.sqrt(dx * dx + dy * dy);
-      return distance >= radius - halfStrokeWidth && distance <= radius + halfStrokeWidth;
+      return distance >= radius - strokeWidthInner && distance <= radius + strokeWidthOuter;
     };
     RoundedRectangle = class _RoundedRectangle {
       /**
@@ -18518,26 +18527,60 @@ var init_RoundedRectangle = __esm({
        * @param pX - The X coordinate of the point to test
        * @param pY - The Y coordinate of the point to test
        * @param strokeWidth - The width of the line to check
+       * @param alignment - The alignment of the stroke, 0.5 by default
        * @returns Whether the x/y coordinates are within this rectangle
        */
-      strokeContains(pX, pY, strokeWidth) {
+      strokeContains(pX, pY, strokeWidth, alignment = 0.5) {
         const { x: x2, y: y2, width, height, radius } = this;
-        const halfStrokeWidth = strokeWidth / 2;
+        const strokeWidthOuter = strokeWidth * (1 - alignment);
+        const strokeWidthInner = strokeWidth - strokeWidthOuter;
         const innerX = x2 + radius;
         const innerY = y2 + radius;
         const innerWidth = width - radius * 2;
         const innerHeight = height - radius * 2;
         const rightBound = x2 + width;
         const bottomBound = y2 + height;
-        if ((pX >= x2 - halfStrokeWidth && pX <= x2 + halfStrokeWidth || pX >= rightBound - halfStrokeWidth && pX <= rightBound + halfStrokeWidth) && pY >= innerY && pY <= innerY + innerHeight) {
+        if ((pX >= x2 - strokeWidthOuter && pX <= x2 + strokeWidthInner || pX >= rightBound - strokeWidthInner && pX <= rightBound + strokeWidthOuter) && pY >= innerY && pY <= innerY + innerHeight) {
           return true;
         }
-        if ((pY >= y2 - halfStrokeWidth && pY <= y2 + halfStrokeWidth || pY >= bottomBound - halfStrokeWidth && pY <= bottomBound + halfStrokeWidth) && pX >= innerX && pX <= innerX + innerWidth) {
+        if ((pY >= y2 - strokeWidthOuter && pY <= y2 + strokeWidthInner || pY >= bottomBound - strokeWidthInner && pY <= bottomBound + strokeWidthOuter) && pX >= innerX && pX <= innerX + innerWidth) {
           return true;
         }
         return (
           // Top-left
-          pX < innerX && pY < innerY && isCornerWithinStroke(pX, pY, innerX, innerY, radius, halfStrokeWidth) || pX > rightBound - radius && pY < innerY && isCornerWithinStroke(pX, pY, rightBound - radius, innerY, radius, halfStrokeWidth) || pX > rightBound - radius && pY > bottomBound - radius && isCornerWithinStroke(pX, pY, rightBound - radius, bottomBound - radius, radius, halfStrokeWidth) || pX < innerX && pY > bottomBound - radius && isCornerWithinStroke(pX, pY, innerX, bottomBound - radius, radius, halfStrokeWidth)
+          pX < innerX && pY < innerY && isCornerWithinStroke(
+            pX,
+            pY,
+            innerX,
+            innerY,
+            radius,
+            strokeWidthInner,
+            strokeWidthOuter
+          ) || pX > rightBound - radius && pY < innerY && isCornerWithinStroke(
+            pX,
+            pY,
+            rightBound - radius,
+            innerY,
+            radius,
+            strokeWidthInner,
+            strokeWidthOuter
+          ) || pX > rightBound - radius && pY > bottomBound - radius && isCornerWithinStroke(
+            pX,
+            pY,
+            rightBound - radius,
+            bottomBound - radius,
+            radius,
+            strokeWidthInner,
+            strokeWidthOuter
+          ) || pX < innerX && pY > bottomBound - radius && isCornerWithinStroke(
+            pX,
+            pY,
+            innerX,
+            bottomBound - radius,
+            radius,
+            strokeWidthInner,
+            strokeWidthOuter
+          )
         );
       }
       toString() {
@@ -19371,7 +19414,7 @@ var init_ShapePath = __esm({
         const delta = Math.PI * 2 / sides;
         const polygon = [];
         for (let i2 = 0; i2 < sides; i2++) {
-          const angle = i2 * delta + startAngle;
+          const angle = startAngle - i2 * delta;
           polygon.push(
             x2 + radius * Math.cos(angle),
             y2 + radius * Math.sin(angle)
@@ -21071,13 +21114,13 @@ var init_GraphicsContext = __esm({
           if (action === "stroke") {
             const data = instruction.data;
             const alignment = data.style.alignment;
-            const padding = data.style.width * (1 - alignment);
+            const outerPadding = data.style.width * (1 - alignment);
             const _bounds = data.path.bounds;
             bounds.addFrame(
-              _bounds.minX - padding,
-              _bounds.minY - padding,
-              _bounds.maxX + padding,
-              _bounds.maxY + padding
+              _bounds.minX - outerPadding,
+              _bounds.minY - outerPadding,
+              _bounds.maxX + outerPadding,
+              _bounds.maxY + outerPadding
             );
           }
         }
@@ -21110,7 +21153,8 @@ var init_GraphicsContext = __esm({
             if (instruction.action === "fill") {
               hasHit = shape.contains(transformedPoint.x, transformedPoint.y);
             } else {
-              hasHit = shape.strokeContains(transformedPoint.x, transformedPoint.y, style.width);
+              const strokeStyle = style;
+              hasHit = shape.strokeContains(transformedPoint.x, transformedPoint.y, strokeStyle.width, strokeStyle.alignment);
             }
             const holes = data.hole;
             if (holes) {
@@ -28944,7 +28988,7 @@ extensions.add(soundAsset);
 var sound = setInstance(new SoundLibrary());
 
 // package.json
-var version = "0.9.7";
+var version = "0.9.9";
 
 // src/constants.ts
 var Repeat = "repeat";

package/dist/constants.d.cts

@@ -2,7 +2,7 @@ import { filters as filters$1 } from '@pixi/sound';
 import { PauseType } from './types/PauseType.cjs';
 import { RepeatType } from './types/RepeatType.cjs';
 
-var version = "0.9.7";
+var version = "0.9.9";
 
 declare const Repeat: RepeatType;
 /**

package/dist/constants.d.ts

@@ -2,7 +2,7 @@ import { filters as filters$1 } from '@pixi/sound';
 import { PauseType } from './types/PauseType.js';
 import { RepeatType } from './types/RepeatType.js';
 
-var version = "0.9.7";
+var version = "0.9.9";
 
 declare const Repeat: RepeatType;
 /**

package/dist/constants.js

@@ -11,16 +11,16 @@ import {
   filters,
   version,
   videoFormats
-} from "./chunk-TOG67Z7Q.js";
-import "./chunk-WS3FY4Q6.js";
-import "./chunk-Z3NBKYVU.js";
-import "./chunk-SAUNZQHZ.js";
-import "./chunk-CAWOWL3P.js";
-import "./chunk-ODIEVSQX.js";
-import "./chunk-5JREOVCG.js";
-import "./chunk-73ID6GAW.js";
-import "./chunk-5VX2VTDZ.js";
-import "./chunk-PP3SBC3C.js";
+} from "./chunk-V7WJOX65.js";
+import "./chunk-X55ALTH7.js";
+import "./chunk-MQPMJVDR.js";
+import "./chunk-D753T42C.js";
+import "./chunk-IG7HSAEJ.js";
+import "./chunk-F74VVSHO.js";
+import "./chunk-XGGTEP7V.js";
+import "./chunk-UWBWDBB3.js";
+import "./chunk-BJGKFUMU.js";
+import "./chunk-KAHX5SKO.js";
 import "./chunk-N342G4HO.js";
 export {
   CANVAS_APP_STAGE_ALIAS,