@ohos-ports/react-three-drei 10.7.7-beta.0

package/core/useDepthBuffer.js

@@ -0,0 +1,38 @@
+import { DepthTexture, DepthFormat, UnsignedShortType } from 'three';
+import * as React from 'react';
+import { useThree, useFrame } from '@react-three/fiber';
+import { useFBO } from './Fbo.js';
+
+function useDepthBuffer({
+  size = 256,
+  frames = Infinity
+} = {}) {
+  const dpr = useThree(state => state.viewport.dpr);
+  const {
+    width,
+    height
+  } = useThree(state => state.size);
+  const w = size || width * dpr;
+  const h = size || height * dpr;
+  const depthConfig = React.useMemo(() => {
+    const depthTexture = new DepthTexture(w, h);
+    depthTexture.format = DepthFormat;
+    depthTexture.type = UnsignedShortType;
+    return {
+      depthTexture
+    };
+  }, [w, h]);
+  let count = 0;
+  const depthFBO = useFBO(w, h, depthConfig);
+  useFrame(state => {
+    if (frames === Infinity || count < frames) {
+      state.gl.setRenderTarget(depthFBO);
+      state.gl.render(state.scene, state.camera);
+      state.gl.setRenderTarget(null);
+      count++;
+    }
+  });
+  return depthFBO.depthTexture;
+}
+
+export { useDepthBuffer };

package/core/useEnvironment.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@react-three/fiber"),t=require("three"),n=require("three-stdlib"),r=require("@monogrid/gainmap-js"),s=require("../helpers/environment-assets.cjs.js"),o=require("react");const i="https://raw.githack.com/pmndrs/drei-assets/456060a26bbeb8fdf79326f224b6d99b8bcce736/hdri/",p=e=>Array.isArray(e),a=["/px.png","/nx.png","/py.png","/ny.png","/pz.png","/nz.png"];function l({files:n=a,path:r="",preset:l,colorSpace:c,extensions:u}={}){l&&(d(l),n=s.presetsObj[l],r=i);const h=p(n),{extension:f,isCubemap:j}=g(n),m=b(f);if(!m)throw new Error("useEnvironment: Unrecognized file extension: "+n);const x=e.useThree((e=>e.gl));o.useLayoutEffect((()=>{"webp"!==f&&"jpg"!==f&&"jpeg"!==f||x.domElement.addEventListener("webglcontextlost",(function(){e.useLoader.clear(m,h?[n]:n)}),{once:!0})}),[n,x.domElement]);const w=e.useLoader(m,h?[n]:n,(e=>{"webp"!==f&&"jpg"!==f&&"jpeg"!==f||e.setRenderer(x),null==e.setPath||e.setPath(r),u&&u(e)}));let E=h?w[0]:w;var v;"jpg"!==f&&"jpeg"!==f&&"webp"!==f||(E=null==(v=E.renderTarget)?void 0:v.texture);return E.mapping=j?t.CubeReflectionMapping:t.EquirectangularReflectionMapping,E.colorSpace=null!=c?c:j?"srgb":"srgb-linear",E}const c={files:a,path:"",preset:void 0,extensions:void 0};l.preload=t=>{const n={...c,...t};let{files:r,path:o=""}=n;const{preset:a,extensions:l}=n;a&&(d(a),r=s.presetsObj[a],o=i);const{extension:u}=g(r);if("webp"===u||"jpg"===u||"jpeg"===u)throw new Error("useEnvironment: Preloading gainmaps is not supported");const h=b(u);if(!h)throw new Error("useEnvironment: Unrecognized file extension: "+r);e.useLoader.preload(h,p(r)?[r]:r,(e=>{null==e.setPath||e.setPath(o),l&&l(e)}))};const u={files:a,preset:void 0};function d(e){if(!(e in s.presetsObj))throw new Error("Preset must be one of: "+Object.keys(s.presetsObj).join(", "))}function g(e){var t;const n=p(e)&&6===e.length,r=p(e)&&3===e.length&&e.some((e=>e.endsWith("json"))),s=p(e)?e[0]:e;return{extension:n?"cube":r?"webp":s.startsWith("data:application/exr")?"exr":s.startsWith("data:application/hdr")?"hdr":s.startsWith("data:image/jpeg")?"jpg":null==(t=s.split(".").pop())||null==(t=t.split("?"))||null==(t=t.shift())?void 0:t.toLowerCase(),isCubemap:n,isGainmap:r}}function b(e){return"cube"===e?t.CubeTextureLoader:"hdr"===e?n.RGBELoader:"exr"===e?n.EXRLoader:"jpg"===e||"jpeg"===e?r.HDRJPGLoader:"webp"===e?r.GainMapLoader:null}l.clear=t=>{const n={...u,...t};let{files:r}=n;const{preset:o}=n;o&&(d(o),r=s.presetsObj[o]);const{extension:i}=g(r),a=b(i);if(!a)throw new Error("useEnvironment: Unrecognized file extension: "+r);e.useLoader.clear(a,p(r)?[r]:r)},exports.useEnvironment=l;

package/core/useEnvironment.d.ts

@@ -0,0 +1,17 @@
+import { Texture, Loader, CubeTexture, ColorSpace } from 'three';
+import { PresetsType } from '../helpers/environment-assets';
+export type EnvironmentLoaderProps = {
+    files?: string | string[];
+    path?: string;
+    preset?: PresetsType;
+    extensions?: (loader: Loader) => void;
+    colorSpace?: ColorSpace;
+};
+export declare function useEnvironment({ files, path, preset, colorSpace, extensions, }?: Partial<EnvironmentLoaderProps>): Texture | CubeTexture;
+export declare namespace useEnvironment {
+    var preload: (preloadOptions?: EnvironmentLoaderPreloadOptions) => void;
+    var clear: (clearOptions?: EnvironmentLoaderClearOptions) => void;
+}
+type EnvironmentLoaderPreloadOptions = Omit<EnvironmentLoaderProps, 'encoding'>;
+type EnvironmentLoaderClearOptions = Pick<EnvironmentLoaderProps, 'files' | 'preset'>;
+export {};

package/core/useEnvironment.js

@@ -0,0 +1,150 @@
+import { useThree, useLoader } from '@react-three/fiber';
+import { CubeReflectionMapping, EquirectangularReflectionMapping, CubeTextureLoader } from 'three';
+import { RGBELoader, EXRLoader } from 'three-stdlib';
+import { HDRJPGLoader, GainMapLoader } from '@monogrid/gainmap-js';
+import { presetsObj } from '../helpers/environment-assets.js';
+import { useLayoutEffect } from 'react';
+
+const CUBEMAP_ROOT = 'https://raw.githack.com/pmndrs/drei-assets/456060a26bbeb8fdf79326f224b6d99b8bcce736/hdri/';
+const isArray = arr => Array.isArray(arr);
+const defaultFiles = ['/px.png', '/nx.png', '/py.png', '/ny.png', '/pz.png', '/nz.png'];
+function useEnvironment({
+  files = defaultFiles,
+  path = '',
+  preset = undefined,
+  colorSpace = undefined,
+  extensions
+} = {}) {
+  if (preset) {
+    validatePreset(preset);
+    files = presetsObj[preset];
+    path = CUBEMAP_ROOT;
+  }
+
+  // Everything else
+  const multiFile = isArray(files);
+  const {
+    extension,
+    isCubemap
+  } = getExtension(files);
+  const loader = getLoader(extension);
+  if (!loader) throw new Error('useEnvironment: Unrecognized file extension: ' + files);
+  const gl = useThree(state => state.gl);
+  useLayoutEffect(() => {
+    // Only required for gainmap
+    if (extension !== 'webp' && extension !== 'jpg' && extension !== 'jpeg') return;
+    function clearGainmapTexture() {
+      useLoader.clear(loader, multiFile ? [files] : files);
+    }
+    gl.domElement.addEventListener('webglcontextlost', clearGainmapTexture, {
+      once: true
+    });
+  }, [files, gl.domElement]);
+  const loaderResult = useLoader(loader, multiFile ? [files] : files, loader => {
+    // Gainmap requires a renderer
+    if (extension === 'webp' || extension === 'jpg' || extension === 'jpeg') {
+      // @ts-expect-error
+      loader.setRenderer(gl);
+    }
+    loader.setPath == null || loader.setPath(path);
+    // @ts-expect-error
+    if (extensions) extensions(loader);
+  });
+  let texture = multiFile ?
+  // @ts-ignore
+  loaderResult[0] : loaderResult;
+  if (extension === 'jpg' || extension === 'jpeg' || extension === 'webp') {
+    var _renderTarget;
+    texture = (_renderTarget = texture.renderTarget) == null ? void 0 : _renderTarget.texture;
+  }
+  texture.mapping = isCubemap ? CubeReflectionMapping : EquirectangularReflectionMapping;
+  texture.colorSpace = colorSpace !== null && colorSpace !== void 0 ? colorSpace : isCubemap ? 'srgb' : 'srgb-linear';
+  return texture;
+}
+const preloadDefaultOptions = {
+  files: defaultFiles,
+  path: '',
+  preset: undefined,
+  extensions: undefined
+};
+useEnvironment.preload = preloadOptions => {
+  const options = {
+    ...preloadDefaultOptions,
+    ...preloadOptions
+  };
+  let {
+    files,
+    path = ''
+  } = options;
+  const {
+    preset,
+    extensions
+  } = options;
+  if (preset) {
+    validatePreset(preset);
+    files = presetsObj[preset];
+    path = CUBEMAP_ROOT;
+  }
+  const {
+    extension
+  } = getExtension(files);
+  if (extension === 'webp' || extension === 'jpg' || extension === 'jpeg') {
+    throw new Error('useEnvironment: Preloading gainmaps is not supported');
+  }
+  const loader = getLoader(extension);
+  if (!loader) throw new Error('useEnvironment: Unrecognized file extension: ' + files);
+  useLoader.preload(loader, isArray(files) ? [files] : files, loader => {
+    loader.setPath == null || loader.setPath(path);
+    // @ts-expect-error
+    if (extensions) extensions(loader);
+  });
+};
+const clearDefaultOptins = {
+  files: defaultFiles,
+  preset: undefined
+};
+useEnvironment.clear = clearOptions => {
+  const options = {
+    ...clearDefaultOptins,
+    ...clearOptions
+  };
+  let {
+    files
+  } = options;
+  const {
+    preset
+  } = options;
+  if (preset) {
+    validatePreset(preset);
+    files = presetsObj[preset];
+  }
+  const {
+    extension
+  } = getExtension(files);
+  const loader = getLoader(extension);
+  if (!loader) throw new Error('useEnvironment: Unrecognized file extension: ' + files);
+  useLoader.clear(loader, isArray(files) ? [files] : files);
+};
+function validatePreset(preset) {
+  if (!(preset in presetsObj)) throw new Error('Preset must be one of: ' + Object.keys(presetsObj).join(', '));
+}
+function getExtension(files) {
+  var _firstEntry$split$pop;
+  const isCubemap = isArray(files) && files.length === 6;
+  const isGainmap = isArray(files) && files.length === 3 && files.some(file => file.endsWith('json'));
+  const firstEntry = isArray(files) ? files[0] : files;
+
+  // Everything else
+  const extension = isCubemap ? 'cube' : isGainmap ? 'webp' : firstEntry.startsWith('data:application/exr') ? 'exr' : firstEntry.startsWith('data:application/hdr') ? 'hdr' : firstEntry.startsWith('data:image/jpeg') ? 'jpg' : (_firstEntry$split$pop = firstEntry.split('.').pop()) == null || (_firstEntry$split$pop = _firstEntry$split$pop.split('?')) == null || (_firstEntry$split$pop = _firstEntry$split$pop.shift()) == null ? void 0 : _firstEntry$split$pop.toLowerCase();
+  return {
+    extension,
+    isCubemap,
+    isGainmap
+  };
+}
+function getLoader(extension) {
+  const loader = extension === 'cube' ? CubeTextureLoader : extension === 'hdr' ? RGBELoader : extension === 'exr' ? EXRLoader : extension === 'jpg' || extension === 'jpeg' ? HDRJPGLoader : extension === 'webp' ? GainMapLoader : null;
+  return loader;
+}
+
+export { useEnvironment };

package/core/useFont.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three-stdlib"),r=require("suspend-react");let t=null;async function n(r){const n=await async function(e){return"string"==typeof e?await(await fetch(e)).json():e}(r);return a=n,t||(t=new e.FontLoader),t.parse(a);var a}function a(e){return r.suspend(n,[e])}a.preload=e=>r.preload(n,[e]),a.clear=e=>r.clear([e]),exports.useFont=a;

package/core/useFont.d.ts

@@ -0,0 +1,24 @@
+export type Glyph = {
+    _cachedOutline: string[];
+    ha: number;
+    o: string;
+};
+export type FontData = {
+    boundingBox: {
+        yMax: number;
+        yMin: number;
+    };
+    familyName: string;
+    glyphs: {
+        [k: string]: Glyph;
+    };
+    resolution: number;
+    underlineThickness: number;
+};
+type FontInput = string | FontData;
+export declare function useFont(font: FontInput): import("three-stdlib").Font;
+export declare namespace useFont {
+    var preload: (font: FontInput) => undefined;
+    var clear: (font: FontInput) => void;
+}
+export {};

package/core/useFont.js

@@ -0,0 +1,24 @@
+import { FontLoader } from 'three-stdlib';
+import { suspend, preload, clear } from 'suspend-react';
+
+let fontLoader = null;
+async function loadFontData(font) {
+  return typeof font === 'string' ? await (await fetch(font)).json() : font;
+}
+function parseFontData(fontData) {
+  if (!fontLoader) {
+    fontLoader = new FontLoader();
+  }
+  return fontLoader.parse(fontData);
+}
+async function loader(font) {
+  const data = await loadFontData(font);
+  return parseFontData(data);
+}
+function useFont(font) {
+  return suspend(loader, [font]);
+}
+useFont.preload = font => preload(loader, [font]);
+useFont.clear = font => clear([font]);
+
+export { useFont };

package/core/useIntersect.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("react"),r=require("@react-three/fiber");function t(e){if(e&&e.__esModule)return e;var r=Object.create(null);return e&&Object.keys(e).forEach((function(t){if("default"!==t){var n=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(r,t,n.get?n:{enumerable:!0,get:function(){return e[t]}})}})),r.default=e,Object.freeze(r)}var n=t(e);exports.useIntersect=function(e){const t=n.useRef(null),u=n.useRef(!1),c=n.useRef(!1),f=n.useRef(e);return n.useLayoutEffect((()=>{f.current=e}),[e]),n.useEffect((()=>{const e=t.current;if(e){const t=r.addEffect((()=>(u.current=!1,!0))),n=e.onBeforeRender;e.onBeforeRender=()=>u.current=!0;const o=r.addAfterEffect((()=>(u.current!==c.current&&(null==f.current||f.current(c.current=u.current)),!0)));return()=>{e.onBeforeRender=n,t(),o()}}}),[]),t};

package/core/useIntersect.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+import { Object3D } from 'three';
+export declare function useIntersect<T extends Object3D>(onChange: (visible: boolean) => void): React.RefObject<T>;

package/core/useIntersect.js

@@ -0,0 +1,36 @@
+import * as React from 'react';
+import { addEffect, addAfterEffect } from '@react-three/fiber';
+
+function useIntersect(onChange) {
+  const ref = React.useRef(null);
+  const check = React.useRef(false);
+  const temp = React.useRef(false);
+  const callback = React.useRef(onChange);
+  React.useLayoutEffect(() => void (callback.current = onChange), [onChange]);
+  React.useEffect(() => {
+    const obj = ref.current;
+    if (obj) {
+      // Stamp out frustum check pre-emptively
+      const unsub1 = addEffect(() => {
+        check.current = false;
+        return true;
+      });
+      // If the object is inside the frustum three will call onRender
+      const oldOnRender = obj.onBeforeRender;
+      obj.onBeforeRender = () => check.current = true;
+      // Compare the check value against the temp value, if it differs set state
+      const unsub2 = addAfterEffect(() => {
+        if (check.current !== temp.current) callback.current == null || callback.current(temp.current = check.current);
+        return true;
+      });
+      return () => {
+        obj.onBeforeRender = oldOnRender;
+        unsub1();
+        unsub2();
+      };
+    }
+  }, []);
+  return ref;
+}
+
+export { useIntersect };

package/core/useSpriteLoader.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three"),r=require("@react-three/fiber"),t=require("react");function a(e){if(e&&e.__esModule)return e;var r=Object.create(null);return e&&Object.keys(e).forEach((function(t){if("default"!==t){var a=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(r,t,a.get?a:{enumerable:!0,get:function(){return e[t]}})}})),r.default=e,Object.freeze(r)}var n=a(e),s=a(t);const o=(e,r)=>{if(Array.isArray(e))return e[0];return e[null!=r?r:Object.keys(e)[0]][0]},u=e=>{for(let r=3;r<e.length;r+=4)if(0!==e[r])return!1;return!0};function c(a,c,i,f,l,m){const h=s.useRef(r.useThree((e=>e.viewport))),d=s.useRef(null),w=s.useRef(0),p=s.useRef(a),y=s.useRef(c),g=s.useRef(i),[b,x]=t.useState(null),[A,S]=s.useState(new n.Texture),L=s.useMemo((()=>new n.TextureLoader),[]),[C,O]=t.useState(null),j=s.useCallback(((e,r,t)=>{const a=r*(h.current.aspect>e/r?h.current.width/e:h.current.height/r),s=e*(h.current.aspect>e/r?h.current.width/e:h.current.height/r)*t,o=a*t;let u=Math.min(1,s),c=Math.min(1,o);return s>1&&(u=1,c=o/s*1),new n.Vector3(u,c,1)}),[]),k=s.useCallback(((e,r)=>{if(e.image){const t=document.createElement("canvas"),a=t.getContext("2d",m);if(!a)throw new Error("Failed to get 2d context");t.width=e.image.width,t.height=e.image.height,a.drawImage(e.image,0,0);const n=e.image.width,s=e.image.height,o=Math.round(Math.sqrt(r*(n/s))),c=Math.round(r/o),i=n/o,f=s/c,l=[];for(let e=0;e<c;e++)for(let t=0;t<o;t++){if(e*o+t>=r){l.push({row:e,col:t});continue}const n=a.getImageData(t*i,e*f,i,f).data;u(n)&&l.push({row:e,col:t})}return{rows:c,columns:o,frameWidth:i,frameHeight:f,emptyFrames:l}}return{rows:0,columns:0,frameWidth:0,frameHeight:0,emptyFrames:[]}}),[m]),v=s.useCallback((e=>{const r=e=>{let r=null;for(const t of e){const{w:e,h:a}=t.frame,n=e*a;(!r||n>r.area)&&(r={w:e,h:a,area:n})}return e.map((e=>{const{w:t,h:a}=e.frame,n=t*a,s=r?n===r.area?1:Math.sqrt(n/r.area):1;return{...e,scaleRatio:s}}))};if(Array.isArray(e))return r(e);{const t={};for(const a in e)t[a]=r(e[a]);return t}}),[]),z=s.useCallback((()=>{const e={},r=d.current,t=g.current;if(r){if(t&&Array.isArray(r.frames)){for(let a=0;a<t.length;a++){e[t[a]]=[];for(const n of r.frames){const r=n.frame,s=n.sourceSize.w,o=n.sourceSize.h;"string"==typeof n.filename&&-1!==n.filename.toLowerCase().indexOf(t[a].toLowerCase())&&e[t[a]].push({...n,frame:r,sourceSize:{w:s,h:o}})}}for(const r in e){const t=v(e[r]);Array.isArray(t)&&(e[r]=t)}return e}if(t&&"object"==typeof r.frames){for(let a=0;a<t.length;a++){e[t[a]]=[];for(const n in r.frames){const s=r.frames[n],o=s.frame,u=s.sourceSize.w,c=s.sourceSize.h;"string"==typeof n&&-1!==n.toLowerCase().indexOf(t[a].toLowerCase())&&e[t[a]].push({...s,frame:o,sourceSize:{w:u,h:c}})}}for(const r in e){const t=v(e[r]);Array.isArray(t)&&(e[r]=t)}return e}{let e=[];return null!=r&&r.frames&&(e=Array.isArray(r.frames)?r.frames.map((e=>({...e,x:e.frame.x,y:e.frame.y,w:e.frame.w,h:e.frame.h}))):Object.values(r.frames).flat().map((e=>({...e,x:e.frame.x,y:e.frame.y,w:e.frame.w,h:e.frame.h})))),v(e)}}return[]}),[v,d]),R=s.useCallback(((e,r)=>{let t=new n.Vector3(1,1,1);if(null===e){if(r&&f){const e=r.image.width,a=r.image.height;w.current=f;const{rows:n,columns:s,frameWidth:o,frameHeight:u,emptyFrames:c}=k(r,f),i={frames:[],meta:{version:"1.0",size:{w:e,h:a},rows:n,columns:s,frameWidth:o,frameHeight:u,scale:"1"}};for(let e=0;e<n;e++)for(let r=0;r<s;r++){(null!=c?c:[]).some((t=>t.row===e&&t.col===r))||Array.isArray(i.frames)&&i.frames.push({frame:{x:r*o,y:e*u,w:o,h:u},scaleRatio:1,rotated:!1,trimmed:!1,spriteSourceSize:{x:0,y:0,w:o,h:u},sourceSize:{w:o,h:u}})}t=j(o,u,.1),d.current=i}d.current&&d.current.frames&&(d.current.frames=v(d.current.frames))}else if(r){d.current=e,d.current.frames=z(),w.current=Array.isArray(e.frames)?e.frames.length:Object.keys(e.frames).length;const{w:r,h:a}=o(e.frames).sourceSize;t=j(r,a,.1)}x(d.current),"encoding"in r?r.encoding=3001:"colorSpace"in r&&(r.colorSpace=n.SRGBColorSpace),S(r),O({spriteTexture:r,spriteData:d.current,aspect:t})}),[k,f,z,j,v]),E=s.useCallback(((e,r,t)=>{const a=fetch(e).then((e=>e.json())),n=new Promise((e=>{L.load(r,e)}));Promise.all([a,n]).then((e=>{t(e[0],e[1])}))}),[L]),M=s.useCallback((e=>{if(!e&&!p.current)throw new Error("Either textureUrl or input must be provided");const r=null!=e?e:p.current;if(!r)throw new Error("A valid texture URL must be provided");L.load(r,(e=>R(null,e)))}),[L,R]),T=s.useCallback(((e,r)=>{r&&e?E(r,e,R):M(e)}),[E,M,R]);return s.useLayoutEffect((()=>{y.current&&p.current?E(y.current,p.current,R):p.current&&M();const t=p.current;return()=>{t&&r.useLoader.clear(e.TextureLoader,t)}}),[E,M,R]),s.useLayoutEffect((()=>{null==l||l(A,null!=b?b:null)}),[A,b,l]),{spriteObj:C,loadJsonAndTexture:T}}c.preload=t=>r.useLoader.preload(e.TextureLoader,t),c.clear=t=>r.useLoader.clear(e.TextureLoader,t),exports.checkIfFrameIsEmpty=u,exports.getFirstFrame=o,exports.useSpriteLoader=c;

package/core/useSpriteLoader.d.ts

@@ -0,0 +1,57 @@
+import { Texture } from 'three';
+import { Vector3 } from '@react-three/fiber';
+import * as THREE from 'three';
+export type Size = {
+    w: number;
+    h: number;
+};
+export type FrameData = {
+    frame: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    scaleRatio?: number;
+    rotated: boolean;
+    trimmed: boolean;
+    spriteSourceSize: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    sourceSize: Size;
+};
+export type MetaData = {
+    version: string;
+    size: {
+        w: number;
+        h: number;
+    };
+    rows: number;
+    columns: number;
+    frameWidth: number;
+    frameHeight: number;
+    scale: string;
+};
+type Frames = Record<string, FrameData[]> | FrameData[];
+export type SpriteData = {
+    frames: Frames;
+    meta: MetaData;
+};
+export declare const getFirstFrame: (frames: SpriteData["frames"], frameName?: string) => FrameData;
+export declare const checkIfFrameIsEmpty: (frameData: Uint8ClampedArray) => boolean;
+export declare function useSpriteLoader<Url extends string>(input: Url | null, json?: string | null, animationNames?: string[] | null, numberOfFrames?: number | null, onLoad?: (texture: Texture, textureData?: SpriteData | null) => void, canvasRenderingContext2DSettings?: CanvasRenderingContext2DSettings): {
+    spriteObj: {
+        spriteTexture: THREE.Texture;
+        spriteData: SpriteData | null;
+        aspect: Vector3;
+    } | null;
+    loadJsonAndTexture: (textureUrl: string, jsonUrl?: string) => void;
+};
+export declare namespace useSpriteLoader {
+    var preload: (url: string) => void;
+    var clear: (input: string) => void;
+}
+export {};