File size: 6,979 Bytes
8fdc036 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 |
import {
Application,
Container,
Graphics,
Sprite,
Rectangle,
RenderTexture,
type IRenderer,
type DisplayObject,
type ICanvas
} from "pixi.js";
import { type LayerScene } from "../layers/utils";
import { background } from "@storybook/theming";
/**
* interface holding references to pixi app components
*/
export interface PixiApp {
/**
* The pixi container for layers
*/
layer_container: Container;
/**
* The pixi container for background images and colors
*/
background_container: Container;
/**
* The pixi renderer
*/
renderer: IRenderer;
/**
* The pixi canvas
*/
view: HTMLCanvasElement & ICanvas;
/**
* The pixi container for masking
*/
mask_container: Container;
destroy(): void;
/**
* Resizes the pixi app
* @param width the new width
* @param height the new height
*/
resize(width: number, height: number): void;
/**
* Gets the blobs for the background, layers, and composite
* @param bounds the bounds of the canvas
* @returns a promise with the blobs
*/
get_blobs(
layers: LayerScene[],
bounds: Rectangle,
dimensions: [number, number]
): Promise<ImageBlobs>;
// /**
// * Resets the mask
// */
// reset?: () => void;
/**
* Gets the layers
*/
get_layers?: () => LayerScene[];
}
/**
* Creates a PIXI app and attaches it to a DOM element
* @param target DOM element to attach PIXI app to
* @param width Width of the PIXI app
* @param height Height of the PIXI app
* @param antialias Whether to use antialiasing
* @returns object with pixi container and renderer
*/
export function create_pixi_app({
target,
dimensions: [width, height],
antialias
}: {
target: HTMLElement;
dimensions: [number, number];
antialias: boolean;
}): PixiApp {
const ratio = window.devicePixelRatio || 1;
const app = new Application({
width,
height,
antialias: antialias,
backgroundAlpha: 0,
eventMode: "static"
});
const view = app.view as HTMLCanvasElement;
// ensure that we can sort the background and layer containers
app.stage.sortableChildren = true;
view.style.maxWidth = `${width / ratio}px`;
view.style.maxHeight = `${height / ratio}px`;
view.style.width = "100%";
view.style.height = "100%";
target.appendChild(app.view as HTMLCanvasElement);
// we need a separate container for the background so that we can
// clear its content without knowing too much about its children
const background_container = new Container() as Container & DisplayObject;
background_container.zIndex = 0;
const layer_container = new Container() as Container & DisplayObject;
layer_container.zIndex = 1;
// ensure we can reorder layers via zIndex
layer_container.sortableChildren = true;
const mask_container = new Container() as Container & DisplayObject;
mask_container.zIndex = 1;
const composite_container = new Container() as Container & DisplayObject;
composite_container.zIndex = 0;
mask_container.addChild(background_container);
mask_container.addChild(layer_container);
app.stage.addChild(mask_container);
app.stage.addChild(composite_container);
const mask = new Graphics();
let text = RenderTexture.create({
width,
height
});
const sprite = new Sprite(text);
mask_container.mask = sprite;
app.render();
function reset_mask(width: number, height: number): void {
background_container.removeChildren();
mask.beginFill(0xffffff, 1);
mask.drawRect(0, 0, width, height);
mask.endFill();
text = RenderTexture.create({
width,
height
});
app.renderer.render(mask, {
renderTexture: text
});
const sprite = new Sprite(text);
mask_container.mask = sprite;
}
function resize(width: number, height: number): void {
app.renderer.resize(width, height);
view.style.maxWidth = `${width / ratio}px`;
view.style.maxHeight = `${height / ratio}px`;
reset_mask(width, height);
}
async function get_blobs(
_layers: LayerScene[],
bounds: Rectangle,
[w, h]: [number, number]
): Promise<ImageBlobs> {
const background = await get_canvas_blob(
app.renderer,
background_container,
bounds,
w,
h
);
const layers = await Promise.all(
_layers.map((layer) =>
get_canvas_blob(
app.renderer,
layer.composite as DisplayObject,
bounds,
w,
h
)
)
);
const composite = await get_canvas_blob(
app.renderer,
mask_container,
bounds,
w,
h
);
return {
background,
layers,
composite
};
}
return {
layer_container,
renderer: app.renderer,
destroy: () => app.destroy(true),
view: app.view as HTMLCanvasElement & ICanvas,
background_container,
mask_container,
resize,
get_blobs
};
}
/**
* Creates a pixi graphics object.
* @param z_index the z index of the graphics object
* @returns a graphics object
*/
export function make_graphics(z_index: number): Graphics {
const graphics = new Graphics();
graphics.eventMode = "none";
graphics.zIndex = z_index;
return graphics;
}
/**
* Clamps a number between a min and max value.
* @param n The number to clamp.
* @param min The minimum value.
* @param max The maximum value.
* @returns The clamped number.
*/
export function clamp(n: number, min: number, max: number): number {
return n < min ? min : n > max ? max : n;
}
/**
* Generates a blob from a pixi object.
* @param renderer The pixi renderer.
* @param obj The pixi object to generate a blob from.
* @param bounds The bounds of the canvas that we wish to extract
* @param width The full width of the canvas
* @param height The full height of the canvas
* @returns A promise with the blob.
*/
function get_canvas_blob(
renderer: IRenderer,
obj: DisplayObject,
bounds: Rectangle,
width: number,
height: number
): Promise<Blob | null> {
return new Promise((resolve) => {
// for some reason pixi won't extract a cropped canvas without distorting it
// so we have to extract the whole canvas and crop it manually
const src_canvas = renderer.extract.canvas(
obj,
new Rectangle(0, 0, width, height)
);
// Create a new canvas for the cropped area with the appropriate size
let dest_canvas = document.createElement("canvas");
dest_canvas.width = bounds.width;
dest_canvas.height = bounds.height;
let dest_ctx = dest_canvas.getContext("2d");
if (!dest_ctx) {
resolve(null);
throw new Error("Could not create canvas context");
}
// Draw the cropped area onto the destination canvas
dest_ctx.drawImage(
src_canvas as HTMLCanvasElement,
// this is the area of the source that we want to copy (the crop box)
bounds.x,
bounds.y,
bounds.width,
bounds.height,
// this is where we want to draw the crop box on the destination canvas
0,
0,
bounds.width,
bounds.height
);
// we grab a blob here so we can upload it
dest_canvas.toBlob?.((blob) => {
if (!blob) {
resolve(null);
}
resolve(blob);
});
});
}
export interface ImageBlobs {
background: Blob | null;
layers: (Blob | null)[];
composite: Blob | null;
}
|