@@ -17,6 +17,7 @@ import Texture2d from "./texture2d.ts";
1717// (`on`, not `once`: a re-init — new Application after destroy — must
1818// re-capture the new renderer).
1919let _renderer ;
20+
2021on ( VIDEO_INIT , ( renderer ) => {
2122 /**
2223 * @ignore
@@ -25,6 +26,28 @@ on(VIDEO_INIT, (renderer) => {
2526 _renderer = renderer ;
2627} ) ;
2728
29+ /**
30+ * The stored UVs of the frame at exactly this source rectangle of a page.
31+ * @param {object } page - a page's record from `TextureAtlas#_pageUVs`
32+ * @param {number } x - source x coordinate
33+ * @param {number } y - source y coordinate
34+ * @param {number } w - source width
35+ * @param {number } h - source height
36+ * @returns {Float32Array|undefined } the frame's UVs, if one is there
37+ * @ignore
38+ */
39+ function frameUVs ( page , x , y , w , h ) {
40+ const corner = page . frames . get ( x ) ?. get ( y ) ;
41+ if ( corner !== undefined ) {
42+ for ( const f of corner ) {
43+ if ( f . width === w && f . height === h ) {
44+ return f . uvs ;
45+ }
46+ }
47+ }
48+ return undefined ;
49+ }
50+
2851/**
2952 * additional import for TypeScript
3053 * @import {CompressedImage } from "../../loader/parsers/compressed_textures/compressed_image.js";
@@ -180,11 +203,38 @@ export class TextureAtlas extends Texture2d {
180203 this . activeAtlas = undefined ;
181204
182205 /**
183- * UV lookup cache to avoid per-frame string allocation in drawImage
206+ * Per atlas page: the size its frames' UVs were normalized by, and
207+ * its frames by source rectangle (x, then y, then the frames at that
208+ * corner), kept out of the page dictionary that animation code
209+ * walks. See {@link TextureAtlas#addUVs}.
210+ * @ignore
211+ * @internal
212+ */
213+ this . _pageUVs = new WeakMap ( ) ;
214+
215+ /**
216+ * What {@link TextureAtlas#_quadUVs} writes a computed rectangle into,
217+ * so a draw allocates nothing. Overwritten by the next call.
184218 * @ignore
185219 * @internal
186220 */
187- this . _uvCache = { sx : - 1 , sy : - 1 , sw : - 1 , sh : - 1 , uvs : null } ;
221+ this . _uvScratch = new Float32Array ( 4 ) ;
222+
223+ /**
224+ * The image and page last drawn from, their size, and whether that
225+ * page computes every UV from it, so a draw from the same page
226+ * decides nothing. See {@link TextureAtlas#_quadUVs}.
227+ * @ignore
228+ * @internal
229+ */
230+ this . _uvSizeCheck = {
231+ source : null ,
232+ page : null ,
233+ width : 0 ,
234+ height : 0 ,
235+ fixed : false ,
236+ computed : true ,
237+ } ;
188238
189239 // parse given atlas(es) paremeters
190240 if ( typeof atlases !== "undefined" ) {
@@ -445,49 +495,144 @@ export class TextureAtlas extends Texture2d {
445495 }
446496
447497 /**
448- * return the uvs mapping for the given region
498+ * Return the UVs of a named region, or of a source rectangle of the
499+ * active page.
500+ *
501+ * A rectangle that is one of the active page's frames returns that
502+ * frame's own UVs. Any other rectangle returns a new array, computed from
503+ * the size of the active page's image: nothing is cached and nothing is
504+ * added to the atlas.
449505 * @param {string|number } name - region (or frame) name, or sx when using numeric parameters
450506 * @param {number } [sy] - source y coordinate (when using numeric parameters)
451507 * @param {number } [sw] - source width (when using numeric parameters)
452508 * @param {number } [sh] - source height (when using numeric parameters)
453509 * @returns {Float32Array } region Uvs
510+ * @throws {Error } if no region has that name
454511 */
455512 getUVs ( name , sy , sw , sh ) {
456513 if ( typeof name === "number" ) {
457- const sx = name ;
458- const cache = this . _uvCache ;
459- // fast path: return cached UVs if coordinates match last lookup
460- if (
461- sx === cache . sx &&
462- sy === cache . sy &&
463- sw === cache . sw &&
464- sh === cache . sh
465- ) {
466- return cache . uvs ;
467- }
468- // cache miss: fall back to string-keyed region lookup
469- const key = sx + "," + sy + "," + sw + "," + sh ;
470- let region = this . getRegion ( key ) ;
471- if ( typeof region === "undefined" ) {
472- region = this . addRegion ( key , sx , sy , sw , sh ) ;
473- }
474- cache . sx = sx ;
475- cache . sy = sy ;
476- cache . sw = sw ;
477- cache . sh = sh ;
478- cache . uvs = region . uvs ;
514+ const page = this . _pageUVs . get ( this . getAtlas ( ) ) ;
515+ const frame =
516+ page === undefined ? undefined : frameUVs ( page , name , sy , sw , sh ) ;
517+ return (
518+ frame ??
519+ Float32Array . from ( this . _quadUVs ( this . getTexture ( ) , name , sy , sw , sh ) )
520+ ) ;
521+ }
522+
523+ const region = this . getRegion ( name ) ;
524+ if ( typeof region ?. uvs !== "undefined" ) {
479525 return region . uvs ;
480526 }
527+ throw new Error ( "Texture - region for " + name + " not found" ) ;
528+ }
481529
482- // string-based lookup (named regions)
483- let region = this . getRegion ( name ) ;
530+ /**
531+ * The UVs a renderer draws a source rectangle of the active page with.
532+ *
533+ * Computed, not looked up: four divisions by the page's size. The
534+ * result is written into one scratch array, so a draw allocates nothing
535+ * and the next call overwrites it; read it straight away.
536+ *
537+ * A frame's UVs are normalized by the size its atlas file gives, which
538+ * is the page's own size unless the image was exported or loaded at
539+ * another scale than its file describes. On such a page a frame is drawn
540+ * with its own UVs, as it always was, and anything else with the page's
541+ * real size. Which kind of page this is gets decided once, and again
542+ * when another page or image is drawn from, or when the image's pixels
543+ * are replaced (see {@link TextureAtlas#_decideUVs}).
544+ * @param {HTMLImageElement|HTMLCanvasElement|HTMLVideoElement|ImageBitmap|OffscreenCanvas|CompressedImage } source - the active page's image, as drawn
545+ * @param {number } sx - source x coordinate
546+ * @param {number } sy - source y coordinate
547+ * @param {number } sw - source width
548+ * @param {number } sh - source height
549+ * @returns {Float32Array } the UVs, valid until the next call
550+ * @ignore
551+ * @internal
552+ */
553+ _quadUVs ( source , sx , sy , sw , sh ) {
554+ const check = this . _uvSizeCheck ;
555+ // kept small so engines inline it into the draw: deciding a page and
556+ // reading a frame's own UVs are the rare work, out of line
557+ if (
558+ check . source !== source ||
559+ check . page !== this . activeAtlas ||
560+ ! check . fixed
561+ ) {
562+ this . _decideUVs ( source ) ;
563+ }
564+ if ( ! check . computed ) {
565+ const frame = frameUVs (
566+ this . _pageUVs . get ( this . getAtlas ( ) ) ,
567+ sx ,
568+ sy ,
569+ sw ,
570+ sh ,
571+ ) ;
572+ if ( frame !== undefined ) {
573+ return frame ;
574+ }
575+ }
576+ const width = check . width ;
577+ const height = check . height ;
578+ const uvs = this . _uvScratch ;
579+ uvs [ 0 ] = sx / width ;
580+ uvs [ 1 ] = sy / height ;
581+ uvs [ 2 ] = ( sx + sw ) / width ;
582+ uvs [ 3 ] = ( sy + sh ) / height ;
583+ return uvs ;
584+ }
484585
485- if ( typeof region === "undefined" ) {
486- // see https://github.com/melonjs/melonJS/issues/1281
487- const keys = name . split ( "," ) ;
488- region = this . addRegion ( name , + keys [ 0 ] , + keys [ 1 ] , + keys [ 2 ] , + keys [ 3 ] ) ;
586+ /**
587+ * The out-of-line half of {@link TextureAtlas#_quadUVs}: read the size
588+ * of the image drawn from, and decide whether the active page computes
589+ * every UV from it.
590+ *
591+ * The size is read when the image's pixels go to the GPU: the first
592+ * time it is drawn, and again after {@link TextureAtlas#_sizeChanged},
593+ * which a canvas render target's `invalidate()` calls when it hands the
594+ * GPU new pixels, maybe at a new size. Between those, a resized canvas
595+ * still shows its old pixels on the GPU, and the old size is the one
596+ * that samples them; reading a DOM image's size also costs more than the
597+ * whole computation. A video is read on every draw, as it uploads every
598+ * frame, and so is an image with no size yet, one still loading.
599+ * @param {HTMLImageElement|HTMLCanvasElement|HTMLVideoElement|ImageBitmap|OffscreenCanvas|CompressedImage } source - the active page's image, as drawn
600+ * @ignore
601+ * @internal
602+ */
603+ _decideUVs ( source ) {
604+ const check = this . _uvSizeCheck ;
605+ const width = source . width || source . videoWidth ;
606+ const height = source . height || source . videoHeight ;
607+ if (
608+ check . source === source &&
609+ check . page === this . activeAtlas &&
610+ check . width === width &&
611+ check . height === height
612+ ) {
613+ return ;
489614 }
490- return region . uvs ;
615+ const page = this . _pageUVs . get ( this . getAtlas ( ) ) ;
616+ check . source = source ;
617+ check . page = this . activeAtlas ;
618+ check . width = width ;
619+ check . height = height ;
620+ check . fixed =
621+ width > 0 && height > 0 && typeof source . videoWidth !== "number" ;
622+ check . computed =
623+ page === undefined ||
624+ ( ! page . mixed && page . width === width && page . height === height ) ;
625+ }
626+
627+ /**
628+ * Read the image's size and decide its page again on the next draw:
629+ * the image's pixels are being replaced, maybe at another size, or a
630+ * new frame changed what its page needs.
631+ * @ignore
632+ * @internal
633+ */
634+ _sizeChanged ( ) {
635+ this . _uvSizeCheck . source = null ;
491636 }
492637
493638 /**
@@ -510,17 +655,39 @@ export class TextureAtlas extends Texture2d {
510655 ( s . x + sw ) / w , // u1 (right)
511656 ( s . y + sh ) / h , // v1 (bottom)
512657 ] ) ;
513- // Cache source coordinates
514- // see https://github.com/melonjs/melonJS/issues/1281
515- // keyed by the REGION rect (x, y, width, height) — the same key shape
516- // `getUVs(sx, sy, sw, sh)` builds for coordinate lookups. (Keying by
517- // the texture dimensions instead made the alias unmatchable for any
518- // sub-region AND poisoned full-image lookups whenever a frame sat at
519- // (0,0): "0,0,texW,texH" pointed at that frame, not the whole image.)
520- const key = `${ s . x } ,${ s . y } ,${ sw } ,${ sh } ` ;
521- if ( key !== name ) {
522- atlas [ key ] = atlas [ name ] ;
658+ // Indexed by source rectangle beside the page, not in it: animation
659+ // code walks the page dictionary, and a second key per frame would
660+ // show up there. Also note the size these UVs were normalized by:
661+ // a draw computes its UVs from the page's own size, and only a page
662+ // where that would differ needs a frame's stored UVs.
663+ let page = this . _pageUVs . get ( atlas ) ;
664+ if ( page === undefined ) {
665+ page = { width : w , height : h , mixed : false , frames : new Map ( ) } ;
666+ this . _pageUVs . set ( atlas , page ) ;
667+ } else if ( page . width !== w || page . height !== h ) {
668+ page . mixed = true ;
669+ }
670+ let column = page . frames . get ( s . x ) ;
671+ if ( column === undefined ) {
672+ column = new Map ( ) ;
673+ page . frames . set ( s . x , column ) ;
674+ }
675+ let corner = column . get ( s . y ) ;
676+ if ( corner === undefined ) {
677+ corner = [ ] ;
678+ column . set ( s . y , corner ) ;
679+ }
680+ const entry = { width : sw , height : sh , uvs : atlas [ name ] . uvs } ;
681+ const i = corner . findIndex ( ( f ) => {
682+ return f . width === sw && f . height === sh ;
683+ } ) ;
684+ if ( i === - 1 ) {
685+ corner . push ( entry ) ;
686+ } else {
687+ corner [ i ] = entry ;
523688 }
689+ // a new frame can change whether its page computes every UV
690+ this . _sizeChanged ( ) ;
524691
525692 return atlas [ name ] . uvs ;
526693 }
@@ -639,9 +806,8 @@ export class TextureAtlas extends Texture2d {
639806 const isArray = Array . isArray ( names ) ;
640807 const name = isArray ? names [ i ] : i ;
641808 // in dictionary mode, only iterate real regions: a region's `name`
642- // matches its dictionary key. This skips both the coordinate-alias
643- // keys added by `addUVs` (#1281 — they'd duplicate every frame) and
644- // non-region entries like the aseprite parser's `anims` dictionary
809+ // matches its dictionary key. This skips non-region entries like
810+ // the aseprite parser's `anims` dictionary
645811 // (whose value has no `name`, and which `getRegion` would otherwise
646812 // happily return as a NaN-sized pseudo-region).
647813 if ( ! isArray && ( names [ i ] == null || names [ i ] . name !== i ) ) {
@@ -704,8 +870,8 @@ export class TextureAtlas extends Texture2d {
704870 for ( const i in names ) {
705871 const isArray = Array . isArray ( names ) ;
706872 const name = isArray ? names [ i ] : i ;
707- // dictionary mode: skip coordinate-alias keys and non-region
708- // entries (see getAnimationSettings for the full rationale)
873+ // dictionary mode: skip non-region entries (see
874+ // getAnimationSettings for the full rationale)
709875 if ( ! isArray && ( names [ i ] == null || names [ i ] . name !== i ) ) {
710876 continue ;
711877 }
0 commit comments