mirror of
https://github.com/EsotericSoftware/spine-runtimes.git
synced 2025-12-20 09:16:01 +08:00
235 lines
9.0 KiB
TypeScript
235 lines
9.0 KiB
TypeScript
/******************************************************************************
|
|
* Spine Runtimes License Agreement
|
|
* Last updated April 5, 2025. Replaces all prior versions.
|
|
*
|
|
* Copyright (c) 2013-2025, Esoteric Software LLC
|
|
*
|
|
* Integration of the Spine Runtimes into software or otherwise creating
|
|
* derivative works of the Spine Runtimes is permitted under the terms and
|
|
* conditions of Section 2 of the Spine Editor License Agreement:
|
|
* http://esotericsoftware.com/spine-editor-license
|
|
*
|
|
* Otherwise, it is permitted to integrate the Spine Runtimes into software
|
|
* or otherwise create derivative works of the Spine Runtimes (collectively,
|
|
* "Products"), provided that each user of the Products must obtain their own
|
|
* Spine Editor license and redistribution of the Products in any form must
|
|
* include this license and copyright notice.
|
|
*
|
|
* THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
|
|
* BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*****************************************************************************/
|
|
|
|
import { AtlasAttachmentLoader, SkeletonBinary, type SkeletonData, SkeletonJson, TextureAtlas, type TextureAtlasPage } from "@esotericsoftware/spine-core";
|
|
import { C3TextureEditor, C3TextureRuntime } from "./C3Texture";
|
|
|
|
|
|
interface CacheEntry<T> {
|
|
data?: T;
|
|
promise: Promise<T>;
|
|
refCount: number;
|
|
}
|
|
|
|
type ResourceCache<T> = Map<string, CacheEntry<T>>;
|
|
|
|
export class AssetLoader {
|
|
|
|
private static CacheSkeleton: ResourceCache<SkeletonData> = new Map();
|
|
private static CacheAtlas: ResourceCache<TextureAtlas> = new Map();
|
|
private static CacheTexture: ResourceCache<C3TextureRuntime> = new Map();
|
|
|
|
public async loadSkeletonEditor (sid: number, textureAtlas: TextureAtlas, scale = 1, instance: SDK.IWorldInstance) {
|
|
const projectFile = instance.GetProject().GetProjectFileBySID(sid);
|
|
if (!projectFile) return null;
|
|
|
|
const blob = projectFile.GetBlob();
|
|
const atlasLoader = new AtlasAttachmentLoader(textureAtlas);
|
|
|
|
const isBinary = projectFile.GetName().endsWith(".skel");
|
|
if (isBinary) {
|
|
const skeletonFile = await blob.arrayBuffer();
|
|
const skeletonLoader = new SkeletonBinary(atlasLoader);
|
|
skeletonLoader.scale = scale;
|
|
return skeletonLoader.readSkeletonData(skeletonFile);
|
|
}
|
|
|
|
const skeletonFile = await blob.text();
|
|
const skeletonLoader = new SkeletonJson(atlasLoader);
|
|
skeletonLoader.scale = scale;
|
|
return skeletonLoader.readSkeletonData(skeletonFile);
|
|
}
|
|
|
|
public async loadAtlasEditor (sid: number, instance: SDK.IWorldInstance, renderer: SDK.Gfx.IWebGLRenderer) {
|
|
const projectFile = instance.GetProject().GetProjectFileBySID(sid);
|
|
if (!projectFile) throw new Error(`Atlas file not found wit the given SID: ${sid}`);
|
|
|
|
const blob = projectFile.GetBlob();
|
|
const content = await blob.text();
|
|
|
|
const path = projectFile.GetPath();
|
|
const basePath = path.substring(0, path.lastIndexOf("/") + 1);
|
|
const textureAtlas = new TextureAtlas(content);
|
|
await Promise.all(textureAtlas.pages.map(async page => {
|
|
const texture = await this.loadSpineTextureEditor(basePath + page.name, page.pma, instance);
|
|
if (texture) {
|
|
const spineTexture = new C3TextureEditor(texture, renderer, page);
|
|
page.setTexture(spineTexture);
|
|
}
|
|
return texture;
|
|
}));
|
|
|
|
return { basePath, textureAtlas };
|
|
}
|
|
|
|
public async loadSpineTextureEditor (pageName: string, pma = false, instance: SDK.IWorldInstance) {
|
|
const projectFile = instance.GetProject().GetProjectFileByExportPath(pageName);
|
|
if (!projectFile) {
|
|
throw new Error(`An error occured while loading the texture: ${pageName}`);
|
|
}
|
|
|
|
const content = projectFile.GetBlob();
|
|
return AssetLoader.createImageBitmapFromBlob(content, pma);
|
|
}
|
|
|
|
public async loadSkeletonRuntime (path: string, textureAtlas: TextureAtlas, scale = 1, instance: IRuntime) {
|
|
const loadPromise = (async () => {
|
|
const fullPath = await instance.assets.getProjectFileUrl(path);
|
|
if (!fullPath) throw new Error(`Cannot find project file url for: ${path}`);
|
|
|
|
const atlasLoader = new AtlasAttachmentLoader(textureAtlas);
|
|
|
|
let skeletonData: SkeletonData;
|
|
const isBinary = path.endsWith(".skel");
|
|
if (isBinary) {
|
|
const content = await instance.assets.fetchArrayBuffer(fullPath);
|
|
if (!content) throw new Error(`Cannot fetch array buffer for: ${fullPath}`);
|
|
|
|
const skeletonLoader = new SkeletonBinary(atlasLoader);
|
|
skeletonLoader.scale = scale;
|
|
skeletonData = skeletonLoader.readSkeletonData(content);
|
|
} else {
|
|
const content = await instance.assets.fetchJson(fullPath);
|
|
if (!content) throw new Error(`Cannot fetch json for: ${fullPath}`);
|
|
|
|
const skeletonLoader = new SkeletonJson(atlasLoader);
|
|
skeletonLoader.scale = scale;
|
|
skeletonData = skeletonLoader.readSkeletonData(content);
|
|
}
|
|
return skeletonData;
|
|
});
|
|
|
|
return this.loadRuntimeResource(`${path}|scale${scale}`, AssetLoader.CacheSkeleton, loadPromise);
|
|
}
|
|
|
|
public async loadAtlasRuntime (path: string, instance: IRuntime, renderer: IRenderer) {
|
|
const loadPromise = (async () => {
|
|
const fullPath = await instance.assets.getProjectFileUrl(path);
|
|
if (!fullPath) throw new Error(`Cannot find project file url for: ${path}`);
|
|
|
|
const content = await instance.assets.fetchText(fullPath);
|
|
if (!content) throw new Error(`Cannot fetch text for: ${fullPath}`);
|
|
|
|
const basePath = path.substring(0, path.lastIndexOf("/") + 1);
|
|
const textureAtlas = new TextureAtlas(content);
|
|
await Promise.all(textureAtlas.pages.map(async page => {
|
|
const texture = await this.loadSpineTextureRuntime(basePath, page, instance, renderer);
|
|
if (texture) page.setTexture(texture);
|
|
return texture;
|
|
}));
|
|
|
|
return textureAtlas;
|
|
});
|
|
|
|
return this.loadRuntimeResource(path, AssetLoader.CacheAtlas, loadPromise);
|
|
}
|
|
|
|
public async loadSpineTextureRuntime (basePath: string, page: TextureAtlasPage, instance: IRuntime, renderer: IRenderer) {
|
|
const cacheKey = basePath + page.name;
|
|
|
|
const loadPromise = (async () => {
|
|
const fullPath = await instance.assets.getProjectFileUrl(cacheKey);
|
|
if (!fullPath) throw new Error(`Cannot find project file url for: ${cacheKey}`);
|
|
|
|
const content = await instance.assets.fetchBlob(fullPath);
|
|
if (!content) throw new Error(`Cannot fetch blob for: ${fullPath}`);
|
|
|
|
const image = await AssetLoader.createImageBitmapFromBlob(content, page.pma);
|
|
if (!image) throw new Error(`Cannot create image bitmap for: ${fullPath}`);
|
|
|
|
return new C3TextureRuntime(image, renderer, page);
|
|
});
|
|
|
|
return this.loadRuntimeResource(cacheKey, AssetLoader.CacheTexture, loadPromise);
|
|
}
|
|
|
|
public releaseInstanceResources (skeletonPath: string, atlasPath: string, loaderScale: number) {
|
|
this.releaseResource(AssetLoader.CacheSkeleton, `${skeletonPath}|scale${loaderScale}`);
|
|
|
|
const atlasEntry = AssetLoader.CacheAtlas.get(atlasPath);
|
|
if (atlasEntry) {
|
|
this.releaseResource(AssetLoader.CacheAtlas, atlasPath, async () => {
|
|
const basePath = atlasPath.substring(0, atlasPath.lastIndexOf("/") + 1);
|
|
for (const page of (await atlasEntry.promise).pages) {
|
|
const textureKey = basePath + page.name;
|
|
this.releaseResource(AssetLoader.CacheTexture, textureKey, (texture) => {
|
|
texture?.dispose();
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
private releaseResource<T> (cache: ResourceCache<T>, key: string, disposer?: (data?: T) => void) {
|
|
const entry = cache.get(key);
|
|
if (!entry) return;
|
|
|
|
entry.refCount--;
|
|
|
|
if (entry.refCount <= 0) {
|
|
if (disposer) disposer(entry.data);
|
|
cache.delete(key);
|
|
}
|
|
}
|
|
|
|
private async loadRuntimeResource<T> (cacheKey: string, resourceCache: ResourceCache<T>, loader: () => Promise<T>): Promise<T> {
|
|
const entry = this.getFromCache(resourceCache, cacheKey);
|
|
if (entry) return entry.promise;
|
|
const result = loader();
|
|
this.addToCache(resourceCache, cacheKey, result);
|
|
return result;
|
|
}
|
|
|
|
private async addToCache<T> (cache: ResourceCache<T>, cacheKey: string, promise: Promise<T>) {
|
|
const cachEntry: CacheEntry<T> = { promise, refCount: 1 };
|
|
cache.set(cacheKey, cachEntry);
|
|
cachEntry.data = await promise;
|
|
}
|
|
|
|
private getFromCache<T> (cache: ResourceCache<T>, cacheKey: string) {
|
|
const entry = cache.get(cacheKey);
|
|
if (!entry) return undefined;
|
|
|
|
entry.refCount++;
|
|
return entry;
|
|
}
|
|
|
|
static async createImageBitmapFromBlob (blob: Blob, pma: boolean): Promise<ImageBitmap | null> {
|
|
try {
|
|
return createImageBitmap(blob, { premultiplyAlpha: pma ? "none" : "premultiply" });
|
|
} catch (e) {
|
|
console.error("Failed to create ImageBitmap from blob:", e);
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|