@drincs/pixi-vn
Version:
Pixi'VN is a npm package that provides various features for creating visual novels.
529 lines (521 loc) • 16.1 kB
JavaScript
;
var pixi_js = require('pixi.js');
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __async = (__this, __arguments, generator) => {
return new Promise((resolve, reject) => {
var fulfilled = (value) => {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
};
var rejected = (value) => {
try {
step(generator.throw(value));
} catch (e) {
reject(e);
}
};
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
step((generator = generator.apply(__this, __arguments)).next());
});
};
var CANVAS_CONTAINER_ID = "CanvasContainer";
var CanvasContainer = class extends pixi_js.Container {
constructor(options) {
super(options);
this.pixivnId = CANVAS_CONTAINER_ID;
this.pixivnId = this.constructor.prototype.pixivnId || CANVAS_CONTAINER_ID;
}
get memory() {
let memory = getMemoryContainer(this);
this.children.forEach((child) => {
memory.elements.push(exportCanvasElement(child));
});
return memory;
}
set memory(value) {
setMemoryContainer(this, value);
value.elements.forEach((child) => {
this.addChild(importCanvasElement(child));
});
}
};
function getMemoryContainer(element) {
let className = "CanvasContainer";
if (element.hasOwnProperty("pixivnId")) {
className = element.pixivnId;
}
return {
pixivnId: className,
elements: [],
width: element.width,
height: element.height,
isRenderGroup: element.isRenderGroup,
blendMode: element.blendMode,
tint: element.tint,
alpha: element.alpha,
angle: element.angle,
renderable: element.renderable,
rotation: element.rotation,
scale: { x: element.scale.x, y: element.scale.y },
pivot: { x: element.pivot.x, y: element.pivot.y },
position: { x: element.position.x, y: element.position.y },
skew: { x: element.skew.x, y: element.skew.y },
visible: element.visible,
x: element.x,
y: element.y,
boundsArea: element.boundsArea,
cursor: element.cursor,
eventMode: element.eventMode,
interactive: element.interactive,
interactiveChildren: element.interactiveChildren,
hitArea: element.hitArea
};
}
function setMemoryContainer(element, memory) {
memory.isRenderGroup && (element.isRenderGroup = memory.isRenderGroup);
memory.blendMode && (element.blendMode = memory.blendMode);
memory.tint && (element.tint = memory.tint);
memory.alpha && (element.alpha = memory.alpha);
memory.angle && (element.angle = memory.angle);
memory.renderable && (element.renderable = memory.renderable);
memory.rotation && (element.rotation = memory.rotation);
if (memory.scale) {
if (typeof memory.scale === "number") {
element.scale.set(memory.scale, memory.scale);
} else {
element.scale.set(memory.scale.x, memory.scale.y);
}
}
if (memory.pivot) {
if (typeof memory.pivot === "number") {
element.pivot.set(memory.pivot, memory.pivot);
} else {
element.pivot.set(memory.pivot.x, memory.pivot.y);
}
}
memory.position && element.position.set(memory.position.x, memory.position.y);
memory.skew && element.skew.set(memory.skew.x, memory.skew.y);
memory.visible && (element.visible = memory.visible);
memory.x && (element.x = memory.x);
memory.y && (element.y = memory.y);
memory.boundsArea && (element.boundsArea = memory.boundsArea);
memory.cursor && (element.cursor = memory.cursor);
memory.eventMode && (element.eventMode = memory.eventMode);
memory.interactive && (element.interactive = memory.interactive);
memory.interactiveChildren && (element.interactiveChildren = memory.interactiveChildren);
memory.hitArea && (element.hitArea = memory.hitArea);
memory.width && (element.width = memory.width);
memory.height && (element.height = memory.height);
}
function getTexture(imageUrl) {
return __async(this, null, function* () {
if (pixi_js.Assets.cache.has(imageUrl)) {
return pixi_js.Assets.get(imageUrl);
}
return pixi_js.Assets.load(imageUrl).then((texture) => {
if (!texture) {
console.error("[Pixi'VN] Texture not found", imageUrl);
return;
}
if (!(texture instanceof pixi_js.Texture)) {
console.error("[Pixi'VN] File not is a image", imageUrl);
return;
}
return texture;
}).catch((e) => {
console.error("[Pixi'VN] Error loading image", e);
return;
});
});
}
function getFillGradientFillPattern(prop, propName) {
if (!(prop instanceof Object)) {
return prop;
}
console.warn(`[Pixi'VN] CanvasText.style.${propName} is a FillGradient or FillPattern, this is not supported yet.`, prop);
return void 0;
}
function getTextStyle(style) {
return {
align: style.align,
breakWords: style.breakWords,
dropShadow: style.dropShadow,
fill: getFillGradientFillPattern(style.stroke, "fill"),
fontFamily: style.fontFamily,
fontSize: style.fontSize,
fontStyle: style.fontStyle,
fontVariant: style.fontVariant,
fontWeight: style.fontWeight,
leading: style.leading,
letterSpacing: style.letterSpacing,
lineHeight: style.lineHeight,
padding: style.padding,
stroke: getFillGradientFillPattern(style.stroke, "stroke"),
textBaseline: style.textBaseline,
trim: style.trim,
whiteSpace: style.whiteSpace,
wordWrap: style.wordWrap,
wordWrapWidth: style.wordWrapWidth
};
}
// src/decorators/EventDecorator.ts
var registeredEvents = {};
function getEventTypeById(eventId) {
try {
let eventType = registeredEvents[eventId];
if (!eventType) {
console.error(`[Pixi'VN] Event ${eventId} not found`);
return;
}
new eventType();
return eventType;
} catch (e) {
console.error(`[Pixi'VN] Error while getting Event ${eventId}`, e);
return;
}
}
function getEventInstanceById(eventId) {
try {
let eventType = registeredEvents[eventId];
if (!eventType) {
console.error(`[Pixi'VN] Event ${eventId} not found`);
return;
}
let event = new eventType();
return event;
} catch (e) {
console.error(`[Pixi'VN] Error while getting Event ${eventId}`, e);
return;
}
}
// src/classes/canvas/CanvasSprite.ts
var CANVAS_SPRITE_ID = "CanvasSprite";
var CanvasSprite = class _CanvasSprite extends pixi_js.Sprite {
constructor(options) {
super(options);
this.pixivnId = CANVAS_SPRITE_ID;
this._onEvents = {};
this.pixivnId = this.constructor.prototype.pixivnId || CANVAS_SPRITE_ID;
}
get memory() {
return getMemorySprite(this);
}
set memory(value) {
setMemorySprite(this, value);
}
get onEvents() {
return this._onEvents;
}
/**
* is same function as on(), but it keeps in memory the children.
* @param event The event type, e.g., 'click', 'mousedown', 'mouseup', 'pointerdown', etc.
* @param eventClass The class that extends CanvasEvent.
* @returns
* @example
* ```typescript
* \@eventDecorator()
* export class EventTest extends CanvasEvent<CanvasSprite> {
* override fn(event: CanvasEventNamesType, sprite: CanvasSprite): void {
* if (event === 'pointerdown') {
* sprite.scale.x *= 1.25;
* sprite.scale.y *= 1.25;
* }
* }
* }
* ```
*
* ```typescript
* let sprite = addImage("alien", 'https://pixijs.com/assets/eggHead.png')
* await sprite.load()
*
* sprite.eventMode = 'static';
* sprite.cursor = 'pointer';
* sprite.onEvent('pointerdown', EventTest);
*
* GameWindowManager.addCanvasElement("bunny", sprite);
* ```
*/
onEvent(event, eventClass) {
let id = eventClass.prototype.id;
let instance = getEventInstanceById(id);
this._onEvents[event] = id;
if (instance) {
super.on(event, () => {
instance.fn(event, this);
});
}
return this;
}
/**
* on() does not keep in memory the event class, use onEvent() instead
* @deprecated
* @private
* @param event
* @param fn
* @param context
*/
on(event, fn, context) {
return super.on(event, fn, context);
}
static from(source, skipCache) {
let sprite = pixi_js.Sprite.from(source, skipCache);
let mySprite = new _CanvasSprite();
mySprite.texture = sprite.texture;
return mySprite;
}
};
function getMemorySprite(element) {
let temp = getMemoryContainer(element);
return __spreadProps(__spreadValues({}, temp), {
pixivnId: element.pixivnId,
textureImage: getTextureMemory(element.texture),
anchor: { x: element.anchor.x, y: element.anchor.y },
roundPixels: element.roundPixels,
onEvents: element.onEvents
});
}
function setMemorySprite(element, memory) {
setMemoryContainer(element, memory);
getTexture(memory.textureImage.image).then((texture) => {
if (texture) {
element.texture = texture;
}
});
if (memory.anchor) {
if (typeof memory.anchor === "number") {
element.anchor.set(memory.anchor, memory.anchor);
} else {
element.anchor.set(memory.anchor.x, memory.anchor.y);
}
}
memory.roundPixels && (element.roundPixels = memory.roundPixels);
for (let event in memory.onEvents) {
let id = memory.onEvents[event];
let instance = getEventTypeById(id);
if (instance) {
element.onEvent(event, instance);
}
}
}
// src/classes/canvas/CanvasImage.ts
var CANVAS_IMAGE_ID = "CanvasImage";
var CanvasImage = class _CanvasImage extends CanvasSprite {
constructor(options, imageLink) {
super(options);
this.pixivnId = CANVAS_IMAGE_ID;
this.imageLink = "";
if (imageLink) {
this.imageLink = imageLink;
}
}
get memory() {
return __spreadProps(__spreadValues({}, getMemorySprite(this)), {
pixivnId: this.pixivnId,
imageLink: this.imageLink
});
}
set memory(memory) {
setMemorySprite(this, memory);
this.imageLink = memory.imageLink;
}
static from(source, skipCache) {
let sprite = pixi_js.Sprite.from(source, skipCache);
let mySprite = new _CanvasImage();
mySprite.texture = sprite.texture;
return mySprite;
}
/**
* Load the image from the link and set the texture of the sprite.
* @param image The link of the image. If it is not set, it will use the imageLink property.
* @returns A promise that resolves when the image is loaded.
*/
load(image) {
return __async(this, null, function* () {
if (!image) {
image = this.imageLink;
}
return getTexture(this.imageLink).then((texture) => {
if (texture) {
this.texture = texture;
}
}).catch((e) => {
console.error("[Pixi'VN] Error into CanvasImage.load()", e);
});
});
}
};
var CANVAS_TEXT_ID = "CanvasText";
var CanvasText = class extends pixi_js.Text {
constructor(options) {
super(options);
this.pixivnId = CANVAS_TEXT_ID;
this._onEvents = {};
this.pixivnId = this.constructor.prototype.pixivnId || CANVAS_TEXT_ID;
}
get memory() {
return getMemoryText(this);
}
set memory(value) {
setMemoryText(this, value);
}
get onEvents() {
return this._onEvents;
}
/**
* is same function as on(), but it keeps in memory the children.
* @param event The event type, e.g., 'click', 'mousedown', 'mouseup', 'pointerdown', etc.
* @param eventClass The class that extends CanvasEvent.
* @returns
* @example
* ```typescript
* \@eventDecorator()
* export class EventTest extends CanvasEvent<CanvasText> {
* override fn(event: CanvasEventNamesType, text: CanvasText): void {
* if (event === 'pointerdown') {
* text.scale.x *= 1.25;
* text.scale.y *= 1.25;
* }
* }
* }
* ```
*
* ```typescript
* const text = new CanvasText();
* text.text = "Hello World"
*
* text.eventMode = 'static';
* text.cursor = 'pointer';
* text.onEvent('pointerdown', EventTest);
*
* GameWindowManager.addCanvasElement("text", text);
* ```
*/
onEvent(event, eventClass) {
let id = eventClass.prototype.id;
let instance = getEventInstanceById(id);
this._onEvents[event] = id;
if (instance) {
super.on(event, () => {
instance.fn(event, this);
});
}
return this;
}
/**
* on() does not keep in memory the event class, use onEvent() instead
* @deprecated
* @private
* @param event
* @param fn
* @param context
*/
on(event, fn, context) {
return super.on(event, fn, context);
}
};
function getMemoryText(element) {
let temp = getMemoryContainer(element);
return __spreadProps(__spreadValues({}, temp), {
pixivnId: element.pixivnId,
anchor: { x: element.anchor.x, y: element.anchor.y },
text: element.text,
resolution: element.resolution,
style: getTextStyle(element.style),
roundPixels: element.roundPixels,
onEvents: element.onEvents
});
}
function setMemoryText(element, memory) {
setMemoryContainer(element, memory);
if (memory.anchor) {
if (typeof memory.anchor === "number") {
element.anchor.set(memory.anchor, memory.anchor);
} else {
element.anchor.set(memory.anchor.x, memory.anchor.y);
}
}
memory.text && (element.text = memory.text);
memory.resolution && (element.resolution = memory.resolution);
memory.style && (element.style = memory.style);
memory.roundPixels && (element.roundPixels = memory.roundPixels);
for (let event in memory.onEvents) {
let id = memory.onEvents[event];
let instance = getEventTypeById(id);
if (instance) {
element.onEvent(event, instance);
}
}
}
// src/decorators/CanvasElementDecorator.ts
var registeredCanvasElement = {};
function getCanvasElementInstanceById(canvasId) {
try {
let eventType = registeredCanvasElement[canvasId];
if (!eventType) {
if (canvasId === CANVAS_CONTAINER_ID) {
eventType = CanvasContainer;
} else if (canvasId === CANVAS_IMAGE_ID) {
eventType = CanvasImage;
} else if (canvasId === CANVAS_SPRITE_ID) {
eventType = CanvasSprite;
} else if (canvasId === CANVAS_TEXT_ID) {
eventType = CanvasText;
}
}
if (!eventType) {
console.error(`[Pixi'VN] CanvasElement ${canvasId} not found`);
return;
}
let canvasElement = new eventType();
return canvasElement;
} catch (e) {
console.error(`[Pixi'VN] Error while getting CanvasElement ${canvasId}`, e);
return;
}
}
// src/functions/CanvasUtility.ts
function getTextureMemory(texture) {
let sourceTexture = texture.source;
let textureMemory = {
image: sourceTexture.label
};
return textureMemory;
}
function exportCanvasElement(element) {
return element.memory;
}
function importCanvasElement(memory) {
let element = getCanvasElementInstanceById(memory.pixivnId);
if (element) {
element.memory = memory;
} else {
throw new Error("[Pixi'VN] The element " + memory.pixivnId + " could not be created");
}
return element;
}
exports.exportCanvasElement = exportCanvasElement;
exports.getTextureMemory = getTextureMemory;
exports.importCanvasElement = importCanvasElement;
//# sourceMappingURL=CanvasUtility.js.map
//# sourceMappingURL=CanvasUtility.js.map