Merge branch 'dev' into next

packages/assets/src/loader/parsers/index.ts

@@ -2,10 +2,7 @@ export * from './loadBitmapFont';
 export * from './LoaderParser';
 export * from './loadJson';
 export * from './loadSpritesheet';
-export * from './loadTexture';
 export * from './loadTxt';
 export * from './loadWebFont';
-export * from './loadBasis';
-export * from './loadDDS';
-export * from './loadKTX';
+export * from './textures';
 

packages/assets/src/loader/parsers/textures/index.ts

@@ -0,0 +1,5 @@
+export * from './loadBasis';
+export * from './loadDDS';
+export * from './loadKTX';
+export * from './loadSVG';
+export * from './loadTexture';

packages/assets/src/loader/parsers/loadBasis.ts → packages/assets/src/loader/parsers/textures/loadBasis.ts

@@ -1,27 +1,25 @@
-import { BaseTexture, extensions, ExtensionType, Texture } from '@pixi/core';
+import { checkExtension } from './utils/checkExtension';
+import { createTexture } from './utils/createTexture';
 
-import type { LoaderParser } from './LoaderParser';
-import { BasisParser, BASIS_FORMATS, BASIS_FORMAT_TO_TYPE,  TranscoderWorker } from '@pixi/basis';
+import type { IBaseTextureOptions, Texture } from '@pixi/core';
+import { BaseTexture, ExtensionType, extensions } from '@pixi/core';
+
+import { BasisParser, BASIS_FORMATS, BASIS_FORMAT_TO_TYPE, TranscoderWorker } from '@pixi/basis';
+import { CompressedTextureResource } from '@pixi/compressed-textures';
 import type { TYPES } from '@pixi/constants';
 import { ALPHA_MODES, FORMATS, MIPMAP_MODES } from '@pixi/constants';
-import { CompressedTextureResource } from '@pixi/compressed-textures';
-import type { LoadAsset } from '../types';
-import type { Loader } from '../Loader';
-import type { LoadTextureData } from './loadTexture';
 import { settings } from '@pixi/settings';
-
-const validImages = ['basis'];
+import type { Loader } from '../../Loader';
+import type { LoadAsset } from '../../types';
+import type { LoaderParser } from '../LoaderParser';
 
 /** Load BASIS textures! */
 export const loadBasis = {
     extension: ExtensionType.LoadParser,
 
     test(url: string): boolean
     {
-        const tempURL = url.split('?')[0];
-        const extension = tempURL.split('.').pop();
-
-        return validImages.includes(extension.toLowerCase());
+        return checkExtension(url, 'basis');
     },
 
     async load(url: string, asset: LoadAsset, loader: Loader): Promise<Texture | Texture[]>
@@ -50,15 +48,7 @@ export const loadBasis = {
                 ...asset.data,
             });
 
-            const texture =  new Texture(base);
-
-            // make sure to nuke the promise if a texture is destroyed..
-            texture.baseTexture.on('dispose', () =>
-            {
-                delete loader.promiseCache[url];
-            });
-
-            return texture;
+            return createTexture(base, loader, url);
         });
 
         return textures.length === 1 ? textures[0] : textures;
@@ -76,6 +66,6 @@ export const loadBasis = {
         }
     }
 
-} as LoaderParser<Texture | Texture[], LoadTextureData>;
+} as LoaderParser<Texture | Texture[], IBaseTextureOptions>;
 
 extensions.add(loadBasis);

packages/assets/src/loader/parsers/loadDDS.ts → packages/assets/src/loader/parsers/textures/loadDDS.ts

@@ -1,26 +1,23 @@
-import { BaseTexture, extensions, ExtensionType, Texture } from '@pixi/core';
-import { getResolutionOfUrl } from '@pixi/utils';
 import { parseDDS } from '@pixi/compressed-textures';
-import type { Loader } from '../Loader';
+import type { IBaseTextureOptions, Texture } from '@pixi/core';
+import { BaseTexture, ExtensionType, extensions } from '@pixi/core';
+import { getResolutionOfUrl } from '@pixi/utils';
+import type { Loader } from '../../Loader';
 
-import type { LoaderParser } from './LoaderParser';
-import type { LoadAsset } from '../types';
 import { ALPHA_MODES, MIPMAP_MODES } from '@pixi/constants';
-import type { LoadTextureData } from './loadTexture';
 import { settings } from '@pixi/settings';
-
-const validImages = ['dds'];
+import type { LoadAsset } from '../../types';
+import type { LoaderParser } from '../LoaderParser';
+import { checkExtension } from './utils/checkExtension';
+import { createTexture } from './utils/createTexture';
 
 /** Load our DDS textures! */
 export const loadDDS: LoaderParser = {
     extension: ExtensionType.LoadParser,
 
     test(url: string): boolean
     {
-        const tempURL = url.split('?')[0];
-        const extension = tempURL.split('.').pop();
-
-        return validImages.includes(extension.toLowerCase());
+        return checkExtension(url, 'dds');
     },
 
     async load(url: string, asset: LoadAsset, loader: Loader): Promise<Texture | Texture[]>
@@ -41,14 +38,7 @@ export const loadDDS: LoaderParser = {
                 ...asset.data,
             });
 
-            const texture = new Texture(base);
-
-            texture.baseTexture.on('dispose', () =>
-            {
-                delete loader.promiseCache[url];
-            });
-
-            return texture;
+            return createTexture(base, loader, url);
         });
 
         return textures.length === 1 ? textures[0] : textures;
@@ -66,6 +56,6 @@ export const loadDDS: LoaderParser = {
         }
     }
 
-} as LoaderParser<Texture | Texture[], LoadTextureData>;
+} as LoaderParser<Texture | Texture[], IBaseTextureOptions>;
 
 extensions.add(loadDDS);

packages/assets/src/loader/parsers/loadKTX.ts → packages/assets/src/loader/parsers/textures/loadKTX.ts

@@ -1,27 +1,24 @@
-import { BaseTexture, extensions, ExtensionType, Texture } from '@pixi/core';
 import { parseKTX } from '@pixi/compressed-textures';
-import type { Loader } from '../Loader';
+import type { IBaseTextureOptions, Texture } from '@pixi/core';
+import { BaseTexture, ExtensionType, extensions } from '@pixi/core';
+import type { Loader } from '../../Loader';
 
-import type { LoaderParser } from './LoaderParser';
+import type { LoaderParser } from '../LoaderParser';
 
-import { getResolutionOfUrl } from '@pixi/utils';
-import type { LoadAsset } from '../types';
 import { ALPHA_MODES, MIPMAP_MODES } from '@pixi/constants';
-import type { LoadTextureData } from './loadTexture';
 import { settings } from '@pixi/settings';
-
-const validImages = ['ktx'];
+import { getResolutionOfUrl } from '@pixi/utils';
+import type { LoadAsset } from '../../types';
+import { checkExtension } from './utils/checkExtension';
+import { createTexture } from './utils/createTexture';
 
 /** Loads KTX textures! */
 export const loadKTX = {
     extension: ExtensionType.LoadParser,
 
     test(url: string): boolean
     {
-        const tempURL = url.split('?')[0];
-        const extension = tempURL.split('.').pop();
-
-        return validImages.includes(extension.toLowerCase());
+        return checkExtension(url, 'ktx');
     },
 
     async load(url: string, asset: LoadAsset, loader: Loader): Promise<Texture | Texture[]>
@@ -56,14 +53,7 @@ export const loadKTX = {
 
             base.ktxKeyValueData = kvData;
 
-            const texture = new Texture(base);
-
-            texture.baseTexture.on('dispose', () =>
-            {
-                delete loader.promiseCache[url];
-            });
-
-            return texture;
+            return createTexture(base, loader, url);
         });
 
         return textures.length === 1 ? textures[0] : textures;
@@ -81,6 +71,6 @@ export const loadKTX = {
         }
     }
 
-} as LoaderParser<Texture | Texture[], LoadTextureData>;
+} as LoaderParser<Texture | Texture[], IBaseTextureOptions>;
 
 extensions.add(loadKTX);

packages/assets/src/loader/parsers/textures/loadSVG.ts

@@ -0,0 +1,57 @@
+import type { IBaseTextureOptions, Texture } from '@pixi/core';
+import { BaseTexture, ExtensionType, SVGResource } from '@pixi/core';
+import { settings } from '@pixi/settings';
+import { getResolutionOfUrl } from '@pixi/utils';
+import { extname } from '../../../utils';
+import type { Loader } from '../../Loader';
+import type { LoadAsset } from '../../types';
+
+import type { LoaderParser } from '../LoaderParser';
+import { loadTextures } from './loadTexture';
+import { createTexture } from './utils/createTexture';
+
+/** Loads SVG's into Textures */
+export const loadSVG = {
+    extension: ExtensionType.LoadParser,
+
+    test(url: string): boolean
+    {
+        return (extname(url).includes('.svg'));
+    },
+
+    async testParse(data: string): Promise<boolean>
+    {
+        return SVGResource.test(data);
+    },
+
+    async parse(asset: string, data: LoadAsset<IBaseTextureOptions>, loader: Loader): Promise<Texture>
+    {
+        const src = new SVGResource(asset, data?.data?.resourceOptions);
+
+        const base = new BaseTexture(src, {
+            resolution: getResolutionOfUrl(asset),
+            ...data?.data,
+        });
+
+        base.resource.src = asset;
+
+        const texture = createTexture(base, loader, asset);
+
+        if (!data?.data?.resourceOptions?.autoLoad)
+        {
+            await src.load();
+        }
+
+        return texture;
+    },
+
+    async load(url: string, _options: LoadAsset): Promise<string>
+    {
+        const response = await settings.ADAPTER.fetch(url);
+
+        return response.text();
+    },
+
+    unload: loadTextures.unload,
+
+} as LoaderParser<Texture | string, IBaseTextureOptions>;

packages/assets/src/loader/parsers/loadTexture.ts → packages/assets/src/loader/parsers/textures/loadTexture.ts

@@ -1,11 +1,14 @@
-import { BaseTexture, extensions, ExtensionType, Texture } from '@pixi/core';
+import type { IBaseTextureOptions, Texture } from '@pixi/core';
+import { BaseTexture, extensions, ExtensionType } from '@pixi/core';
 import { settings } from '@pixi/settings';
 import { getResolutionOfUrl } from '@pixi/utils';
-import type { Loader } from '../Loader';
-import type { LoadAsset } from '../types';
+import type { Loader } from '../../Loader';
+import type { LoadAsset } from '../../types';
 
-import type { LoaderParser } from './LoaderParser';
-import { WorkerManager } from './WorkerManager';
+import type { LoaderParser } from '../LoaderParser';
+import { WorkerManager } from '../WorkerManager';
+import { checkExtension } from './utils/checkExtension';
+import { createTexture } from './utils/createTexture';
 
 const validImages = ['jpg', 'png', 'jpeg', 'avif', 'webp'];
 
@@ -24,10 +27,6 @@ export async function loadImageBitmap(url: string): Promise<ImageBitmap>
     return imageBitmap;
 }
 
-export type LoadTextureData = {
-    baseTexture: BaseTexture;
-};
-
 /**
  * Loads our textures!
  * this makes use of imageBitmaps where available.
@@ -43,13 +42,10 @@ export const loadTextures = {
 
     test(url: string): boolean
     {
-        const tempURL = url.split('?')[0];
-        const extension = tempURL.split('.').pop();
-
-        return validImages.includes(extension);
+        return checkExtension(url, validImages);
     },
 
-    async load(url: string, asset: LoadAsset<LoadTextureData>, loader: Loader): Promise<Texture>
+    async load(url: string, asset: LoadAsset<IBaseTextureOptions>, loader: Loader): Promise<Texture>
     {
         let src: any = null;
 
@@ -86,22 +82,13 @@ export const loadTextures = {
 
         base.resource.src = url;
 
-        const texture = new Texture(base);
-
-        // make sure to nuke the promise if a texture is destroyed..
-        texture.baseTexture.on('dispose', () =>
-        {
-            delete loader.promiseCache[url];
-        });
-
-        return texture;
+        return createTexture(base, loader, url);
     },
 
     unload(texture: Texture): void
     {
         texture.destroy(true);
     }
-
-} as LoaderParser<Texture, LoadTextureData>;
+} as LoaderParser<Texture, IBaseTextureOptions>;
 
 extensions.add(loadTextures);

packages/assets/src/loader/parsers/textures/utils/checkExtension.ts

@@ -0,0 +1,12 @@
+export function checkExtension(url: string, extension: string | string[]): boolean
+{
+    const tempURL = url.split('?')[0];
+    const extensionSplit = tempURL.split('.').pop();
+
+    if (Array.isArray(extension))
+    {
+        return extension.includes(extensionSplit.toLowerCase());
+    }
+
+    return extensionSplit.toLowerCase() === extension;
+}

packages/assets/src/loader/parsers/textures/utils/createTexture.ts

@@ -0,0 +1,16 @@
+import type { BaseTexture } from '@pixi/core';
+import { Texture } from '@pixi/core';
+import type { Loader } from '../../../Loader';
+
+export function createTexture(base: BaseTexture, loader: Loader, url: string)
+{
+    const texture = new Texture(base);
+
+    // make sure to nuke the promise if a texture is destroyed..
+    texture.baseTexture.on('dispose', () =>
+    {
+        delete loader.promiseCache[url];
+    });
+
+    return texture;
+}