melonjs 20.10.1 → 20.12.0

package/build/video/webgpu/webgpu_renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webgpu_renderer.d.ts","sourceRoot":"","sources":["../../../src/video/webgpu/webgpu_renderer.js"],"names":[],"mappings":"AA2EA;;;;;;;;;;;;;;;GAeG;AACH,iDANW,OAAO,qBACP,OAAO,GACL;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAC,CAYvD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH;IACC;;OAEG;IACH,qBAFW,mBAAmB,EA8W7B;IAtWA;;;;OAIG;IACH,kBAHU,UAAU,GAAC,SAAS,CAGN;IAExB;;;;OAIG;IACH,iBAHU,SAAS,GAAC,SAAS,CAGN;IAEvB;;;OAGG;IACH,SAFU,gBAAgB,CAEc;IAExC;;;;;OAKG;IACH,0BAHU,MAAM,GAAC,SAAS,CAGM;IAEhC;;;;;;;;;;;;;OAaG;IACH,cAJU,MAAM,GAAC,SAAS,CAIG;IAyC7B;mBACe;IACf,iEAAsC;IAGtC;;;OAGG;IACH,oBAAmC;IAInC,2BAAyD;IAKzD;mBACe;IACf,qBAA2B;IAG3B;mBACe;IACf;;;QAEE;IACF;mBACe;IACf,iBAAmB;IAEnB;mBACe;IACf,iBAA4B;IAE5B;mBACe;IACf,uBAAuB;IAEvB;;;;;OAKG;IACH,UAJU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAIJ;IAEzB;;;;OAIG;IACH,oBAA0B;IAG1B;mBACe;IACf,0CAAyB;IACzB;mBACe;IACf,sCAAuB;IAEvB;mBACe;IACf,qCAAsB;IACtB;mBACe;IACf,sCAAuB;IACvB;mBACe;IACf,wCAAwB;IAGxB;mBACe;IACf,yCAA0B;IAC1B;mBACe;IACf,wCAAsB;IAGtB;mBACe;IACf,+CAA+B;IAE/B;;;;;;;;;;;;;;;;;;OAkBG;IACH,8CAAqC;IACrC;;;OAGG;IACH,2BAAsC;IACtC;;;OAGG;IACH,qDAAqC;IACrC;;;OAGG;IACH,4BAA+B;IAC/B;;;OAGG;IACH,2BAA2B;IAC3B;;;OAGG;IACH,gDAAgC;IAChC;;;OAGG;IACH,+BAAqC;IAGrC;mBACe;IACf,2BAA8B;IAC9B;mBACe;IACf,uBAA6B;IAC7B;mBACe;IACf,6BAAgC;IAKhC;mBACe;IACf,2BAA8B;IAI9B;mBACe;IACf,yBAA4B;IAG5B;mBACe;IACf;;;;;aAAwB;IAGxB;mBACe;IACf,0BAA6B;IAG7B;mBACe;IACf,gCAAwB;IAExB;mBACe;IACf,oBAA+B;IAG/B;mBACe;IACf,+BAAuB;IAEvB;mBACe;IACf,6BAA+B;IAC/B;mBACe;IACf,wBAAwB;IAExB;mBACe;IACf,6CAA8B;IAG9B;mBACe;IACf,gBAAgB;IAIhB;mBACe;IACf,uBAAyB;IAIzB;mBACe;IACf,8BAA8B;IAC9B;mBACe;IACf,wCAA4B;IAC5B;mBACe;IACf,kBAAwB;IAMxB;mBACe;IACf,0BAA0B;IAC1B;mBACe;IACf,oCAA4B;IAC5B;mBACe;IACf,qCAAyB;IACzB;mBACe;IACf,sBAA4B;IAC5B;mBACe;IACf,qBAA2B;IAC3B;mBACe;IACf;;;aAA+B;IAC/B;mBACe;IACf,uBAA0B;IAE1B;mBACe;IACf,4BAA8B;IAE9B;mBACe;IACf,oBAAyB;IAMzB,wBAEC;IAID,2BAUC;IAmFA,8BAAyC;IAqF3C;;;;;;;;;OASG;IACH,2BALW,MAAM,WACN,MAAM,8BA6BhB;IAED;;;;;;;OAOG;IACH,8BALW,MAAM,UACN,MAAM,QAsBhB;IA+DD;;;;;;OAMG;IACH,iBAJW,MAAM,QAsHhB;IAED;;;;;;OAMG;IACH,iBAJa,CAAC,MAAM,EAAE,MAAM,CAAC,CAW5B;IAED;;;;;;;;;;OAUG;IACH,wBANW,OAAO,uCAAuC,EAAE,OAAO,GAAC,IAAI,YAEpE;QAA0B,KAAK;KAC/B,QAsBF;IAED;;;;;;;;OAQG;IACH,uBAJW,UAAU,QAUpB;IAED;;;;;;;;;OASG;IACH,qBAJW,SAAS,QAMnB;IAED;;;;;;OAMG;IACH,sBAJa,cAAc,CAqB1B;IAHC,mDAAoD;IAKtD;;;;;;;;;;;;;OAaG;IACH,wBANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAehB;IAED;;;;;OAKG;IACH,sBA0BC;IAeD;;;;;;;;;;OAUG;IACH,gBAJa,OAAO,2BAA2B,EAAE,kBAAkB,GAAC,IAAI,CAMvE;IA4CD;;;OAGG;IACH,mCAmHC;IAED;;;;;OAKG;IACH,mBAJa,gBAAgB,CA8B5B;IAED;;;;;;;OAOG;IACH,sBALW,YAAY,GACV,MAAM,CAalB;IAoID;;;;;;;;OAQG;IACH,iBAJa,KAAK,CAAC,KAAK,CAAC,MAAM,GAAC,MAAM,CAAC,CAAC,CASvC;IAED;;;;;OAKG;IACH,YAJa,OAAO,CAUnB;IAED;;;;;;OAMG;IACH,sBALW,MAAM,GACJ,MAAM,GAAC,SAAS,CAQ5B;IAED;;;;;;;;OAQG;IACH,wBANW,MAAM,UACN,YAAY,SACZ,KAAK,CAAC,KAAK,CAAC,MAAM,GAAC,MAAM,CAAC,CAAC,QA8BrC;IAED;;;;;;;;;;OAUG;IACH,oBANW,MAAM,UACN,MAAM,SACN,KAAK,CAAC,KAAK,CAAC,MAAM,GAAC,MAAM,CAAC,CAAC,QAUrC;IAED;;;;;;;;OAQG;IACH,uBAPW,MAAM,UACN,MAAM,SACN,KAAK,CAAC,KAAK,CAAC,MAAM,GAAC,MAAM,CAAC,CAAC,OAC3B,OAAO,QAkDjB;IA+CD;;;;;;;;;;;;;;;OAeG;IACH,yBALW,MAAM,SACN,KAAK,CAAC,KAAK,CAAC,MAAM,GAAC,MAAM,CAAC,CAAC,QAgDrC;IAuPD;;;;;;;;;;;;;;OAcG;IACH,4BATW,OAAO,uCAAuC,EAAE,OAAO,KACvD,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,YAAY,cACZ,OAAO,QAoBjB;IAED;;;;;;;;OAQG;IACH,iCAJW,MAAM,QAahB;IAED;;;;;OAKG;IACH,4BAIC;IAED;;;;;;;OAOG;IACH,sBALa,OAAO,CAyDnB;IAED;;;;;OAKG;IACH,4BAgCC;IAED;;;;;;;OAOG;IACH,0CAUC;IAmHD;;;;;OAKG;IACH,qBAuCC;IAED;;;;;OAKG;IACH,+BAOC;IAED;;;;OAIG;IACH,qBAiBC;IAED;;;;;;;;;;;;OAYG;IACH,mBAHW,KAAK,GAAC,MAAM,WACZ,OAAO,QA0CjB;IAED;;;;;;;OAOG;IACH,aALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAShB;IAED;;;;;;;;OAQG;IACH,8BAJW,MAAM,QACN,MAAM,QAiBhB;IAED;;;;;OAKG;IACH,oBAJW,aAAa,SACb,MAAM,aACN,OAAO,QAkBjB;IAED;;;;;;;OAOG;IACH,kBAHW,MAAM,GACJ,aAAa,CAsCzB;IAED;;;;;;;;;;;;;;OAcG;IACH;;;;;;;;OAQG;IACH,0BANW,aAAa,gBACb,QAAQ,QACR,MAAM,QAchB;IAED,4CAoLC;IA7CC,2CAAiC;IA+CnC;;;;OAIG;IACH,yBAFW,MAAM,QAUhB;IAyCD;;;;;;;;;OASG;IACH,aAPW,QAAQ,GAAC,QAAQ,GAAC,MAAM,MACxB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAkBhB;IAED;;;;;;;;OAQG;IACH,gBAPW,QAAQ,GAAC,QAAQ,GAAC,MAAM,MACxB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAKhB;IAqDD;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAmBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACH,oBAJW,MAAM,uBACN,OAAO,GACL,MAAM,CAkClB;IAmBD;;;;;OAKG;IACH,yBAMC;IAED;;;;;;;;;;;OAWG;IACH,iBAVW,gBAAgB,GAAC,iBAAiB,GAAC,gBAAgB,GAAC,WAAW,GAAC,eAAe,GAAC,UAAU,MAC1F,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,QA6EhB;IAED;;;;;;;;;OASG;IACH,iDAHa,MAAM,CA0ElB;IAHC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAuC;IAKzC;;;;;;;;;OASG;IACH,kCANW,GAAG,CAAC,OAAO,CAAC,GAAC,KAAK,CAAC,OAAO,CAAC,WAC3B,KAAK,eACL,MAAM,eACN,MAAM,QAmBhB;IAdC,0FAAuD;IAgBzD;;;;;;OAMG;IACH,0BAHW,OAAO,QAyBjB;IApBC,8CAAiD;IAsBnD;;;;;;;;;;;;OAYG;IACH,sBAJa,YAAY,CAqBxB;IAPC,0CAIC;IAKH;;;;;;OAMG;IACH,iBAJa,YAAY,CAwBxB;IAPC,qCAIC;IAKH;;;;;;;OAOG;IACH,qBANW,YAAY,KACZ,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAiBhB;IAED;;;;;OAKG;IACH,qBAJW,gBAAgB,GAAC,eAAe,GAAC,gBAAgB,GAAC,iBAAiB,GAAC,WAAW,GAAC,eAAe,GAAC,UAAU,WAC1G,MAAM,GACJ,YAAY,CAUxB;IAwDD;;;;;;;;;;OAUG;IACH,mBAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAsChB;IAsCE,mCAA2C;IA8D3C,qCAA2B;IAkC9B;;;;;;;;;;;;;;;OAeG;IACH,mEAgEC;IAED;;;;;;;;;OASG;IACH,aARW,MAAM,KACN,MAAM,UACN,MAAM,SACN,MAAM,OACN,MAAM,kBACN,OAAO,SACP,OAAO,QAWjB;IAED;;;;;;;;OAQG;IACH,WAPW,MAAM,KACN,MAAM,UACN,MAAM,SACN,MAAM,OACN,MAAM,kBACN,OAAO,QAqCjB;IA2ED;;;;;;OAMG;IACH,iBALW,MAAM,UACN,MAAM,QACN,MAAM,QACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,OAAO,SACP,OAAO,QAkDjB;IAED;;;OAGG;IACH,kBAFW,OAAO,QAuDjB;IAoFD;;;;;;;;OAQG;IACH,mBAPW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,MAAM,SACN,OAAO,QAWjB;IAED;;;;;;;OAOG;IACH,iBANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,MAAM,QAyFhB;IAED;;;;OAIG;IACH,eAHW,MAAM,KACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,aAHW,MAAM,KACN,MAAM,QAIhB;IAED;;OAEG;IACH,kBAEC;IAED;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAIhB;IAED;;;;;;OAMG;IACH,sBALW,MAAM,OACN,MAAM,KACN,MAAM,KACN,MAAM,QAIhB;IAED;;;;;;;;OAQG;IACH,oBAPW,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,KACN,MAAM,KACN,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,UANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,QAIhB;IAED;;;;;;OAMG;IACH,QALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,aANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,SACN,MAAM,QAIhB;IAED;;OAEG;IACH,kBAEC;IA6FD;;;;;;;;;;;;;;;;OAgBG;IACH,yBAmCC;IATC;;;OAGG;IACH,6CAAmC;IAOrC;;;;;;;;;;OAUG;IACH,4BAuCC;IApBA;;;;;OAKG;IACH,iCAAkE;IAgCnE;;;;;OAKG;IACH,+BA6CC;IAED;;;OAGG;IACH,cAFa,gBAAgB,CAI5B;CA6FD;qBAn9IoB,gBAAgB;0CA0BK,oCAAoC;yBAtBrD,qBAAqB;yBA1BrB,wBAAwB;uBAC1B,yBAAyB;gCA8CU,qBAAqB;8BAHjD,mBAAmB;8BACnB,yBAAyB;+BAMxB,oBAAoB;+BA3BpB,uCAAuC;wBAN9C,2BAA2B;6BAKtB,uCAAuC;8BAwCvC,4BAA4B;sBAhExB,qBAAqB;0BA4C5B,8BAA8B;8BAgB7B,wBAAwB;yBAF3B,2BAA2B;iCArClB,8BAA8B;6BAKrB,qBAAqB;6BAmCrC,6BAA6B;yCALjB,+BAA+B"}
+{"version":3,"file":"webgpu_renderer.d.ts","sourceRoot":"","sources":["../../../src/video/webgpu/webgpu_renderer.js"],"names":[],"mappings":"AA+EA;;;;;;;;;;;;;;;GAeG;AACH,iDANW,OAAO,qBACP,OAAO,GACL;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAC,CAYvD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH;IACC;;OAEG;IACH,qBAFW,mBAAmB,EA8W7B;IAtWA;;;;OAIG;IACH,kBAHU,UAAU,GAAC,SAAS,CAGN;IAExB;;;;OAIG;IACH,iBAHU,SAAS,GAAC,SAAS,CAGN;IAEvB;;;OAGG;IACH,SAFU,gBAAgB,CAEc;IAExC;;;;;OAKG;IACH,0BAHU,MAAM,GAAC,SAAS,CAGM;IAEhC;;;;;;;;;;;;;OAaG;IACH,cAJU,MAAM,GAAC,SAAS,CAIG;IAyC7B;mBACe;IACf,iEAAsC;IAGtC;;;OAGG;IACH,oBAAmC;IAInC,2BAAyD;IAKzD;mBACe;IACf,qBAA2B;IAG3B;mBACe;IACf;;;QAEE;IACF;mBACe;IACf,iBAAmB;IAEnB;mBACe;IACf,iBAA4B;IAE5B;mBACe;IACf,uBAAuB;IAEvB;;;;;OAKG;IACH,UAJU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAIJ;IAEzB;;;;OAIG;IACH,oBAA0B;IAG1B;mBACe;IACf,0CAAyB;IACzB;mBACe;IACf,sCAAuB;IAEvB;mBACe;IACf,qCAAsB;IACtB;mBACe;IACf,sCAAuB;IACvB;mBACe;IACf,wCAAwB;IAGxB;mBACe;IACf,yCAA0B;IAC1B;mBACe;IACf,wCAAsB;IAGtB;mBACe;IACf,+CAA+B;IAE/B;;;;;;;;;;;;;;;;;;OAkBG;IACH,8CAAqC;IACrC;;;OAGG;IACH,2BAAsC;IACtC;;;OAGG;IACH,qDAAqC;IACrC;;;OAGG;IACH,4BAA+B;IAC/B;;;OAGG;IACH,2BAA2B;IAC3B;;;OAGG;IACH,gDAAgC;IAGhC;mBACe;IACf,2BAA8B;IAC9B;mBACe;IACf,uBAA6B;IAC7B;mBACe;IACf,6BAAgC;IAKhC;mBACe;IACf,2BAA8B;IAI9B;mBACe;IACf,yBAA4B;IAG5B;mBACe;IACf;;;;;aAAwB;IAGxB;mBACe;IACf,gCAAwB;IAExB;mBACe;IACf,oBAA+B;IAG/B;mBACe;IACf,+BAAuB;IAEvB;mBACe;IACf,6BAA+B;IAE/B;;;;;;;OAOG;IACH,kBAJU,MAAM,EAAE,CAIQ;IAC1B;mBACe;IACf,wBAAwB;IAExB;mBACe;IACf,6CAA8B;IAG9B;mBACe;IACf,gBAAgB;IAIhB;mBACe;IACf,uBAAyB;IAIzB;mBACe;IACf,8BAA8B;IAC9B;mBACe;IACf,wCAA4B;IAC5B;mBACe;IACf,kBAAwB;IAMxB;mBACe;IACf,0BAA0B;IAC1B;mBACe;IACf,oCAA4B;IAC5B;mBACe;IACf,qCAAyB;IACzB;mBACe;IACf,sBAA4B;IAC5B;mBACe;IACf,qBAA2B;IAC3B;mBACe;IACf;;;aAA+B;IAC/B;mBACe;IACf,uBAA0B;IAE1B;mBACe;IACf,4BAA8B;IAE9B;mBACe;IACf,oBAAyB;IAMzB,wBAEC;IAID,2BAUC;IAmFA,8BAAyC;IAqF3C;;;;;;;;;OASG;IACH,2BALW,MAAM,WACN,MAAM,8BA6BhB;IAED;;;;;;;OAOG;IACH,8BALW,MAAM,UACN,MAAM,QAsBhB;IA+DD;;;;;;OAMG;IACH,iBAJW,MAAM,QAsHhB;IAED;;;;;;OAMG;IACH,iBAJa,CAAC,MAAM,EAAE,MAAM,CAAC,CAW5B;IAED;;;;;;;;;;OAUG;IACH,wBANW,OAAO,uCAAuC,EAAE,OAAO,GAAC,IAAI,YAEpE;QAA0B,KAAK;KAC/B,QAsBF;IAED;;;;;;;;OAQG;IACH,uBAJW,UAAU,QAUpB;IAED;;;;;;;;;OASG;IACH,qBAJW,SAAS,QAMnB;IAED;;;;;;OAMG;IACH,sBAJa,cAAc,CAqB1B;IAHC,mDAAoD;IAKtD;;;;;;;;;;;;;OAaG;IACH,wBANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAehB;IAED;;;;;OAKG;IACH,sBA0BC;IAeD;;;;;;;;;;OAUG;IACH,gBAJa,OAAO,2BAA2B,EAAE,kBAAkB,GAAC,IAAI,CAMvE;IA4CD;;;OAGG;IACH,mCAmHC;IAED;;;;;OAKG;IACH,mBAJa,gBAAgB,CA8B5B;IAED;;;;;;;OAOG;IACH,sBALW,YAAY,GACV,MAAM,CAalB;IAoID;;;;;;;;OAQG;IACH,iBAJa,KAAK,CAAC,KAAK,CAAC,MAAM,GAAC,MAAM,CAAC,CAAC,CASvC;IAED;;;;;OAKG;IACH,YAJa,OAAO,CAUnB;IAED;;;;;;OAMG;IACH,sBALW,MAAM,GACJ,MAAM,GAAC,SAAS,CAQ5B;IAED;;;;;;;;OAQG;IACH,wBANW,MAAM,UACN,YAAY,SACZ,KAAK,CAAC,KAAK,CAAC,MAAM,GAAC,MAAM,CAAC,CAAC,QA8BrC;IAED;;;;;;;;;;OAUG;IACH,oBANW,MAAM,UACN,MAAM,SACN,KAAK,CAAC,KAAK,CAAC,MAAM,GAAC,MAAM,CAAC,CAAC,QAUrC;IAED;;;;;;;;OAQG;IACH,uBAPW,MAAM,UACN,MAAM,SACN,KAAK,CAAC,KAAK,CAAC,MAAM,GAAC,MAAM,CAAC,CAAC,OAC3B,OAAO,QAkDjB;IAED;;;;;;;;;;;OAWG;IACH,kBALW,OAAO,SACP,KAAK,CAAC,KAAK,CAAC,MAAM,GAAC,MAAM,CAAC,CAAC,QA8BrC;IAoDD;;;;;;;;;;;;;;;OAeG;IACH,yBALW,MAAM,SACN,KAAK,CAAC,KAAK,CAAC,MAAM,GAAC,MAAM,CAAC,CAAC,QAgDrC;IAkRD;;;;;;;;;;;;;;;OAeG;IACH,4BAVW,OAAO,uCAAuC,EAAE,OAAO,KACvD,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,YAAY,cACZ,OAAO,UACP,MAAM,QA6BhB;IAED;;;;;;;;OAQG;IACH,iCAJW,MAAM,QAQhB;IAED;;;;;OAKG;IACH,4BAIC;IAED;;;;;;;OAOG;IACH,sBALa,OAAO,CAyDnB;IAED;;;;;OAKG;IACH,4BAgCC;IAED;;;;;;;OAOG;IACH,0CAUC;IAmHD;;;;;OAKG;IACH,qBAuCC;IAED;;;;;OAKG;IACH,+BAOC;IAED;;;;OAIG;IACH,qBAiBC;IAED;;;;;;;;;;;;OAYG;IACH,mBAHW,KAAK,GAAC,MAAM,WACZ,OAAO,QA0CjB;IAED;;;;;;;OAOG;IACH,aALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAShB;IAED;;;;;;;;OAQG;IACH,8BAJW,MAAM,QACN,MAAM,QAiBhB;IAqBD;;;;;;;OAOG;IACH,oBAJW,OAAO,QAajB;IAED;;;;;OAKG;IACH,oBAJW,aAAa,SACb,MAAM,aACN,OAAO,QAkBjB;IAED;;;;;;;OAOG;IACH,kBAHW,MAAM,GACJ,aAAa,CAsCzB;IAED;;;;;;;;;;;;;;OAcG;IACH;;;;;;;;OAQG;IACH,0BANW,aAAa,gBACb,QAAQ,QACR,MAAM,QAchB;IAED,4CAuLC;IAED;;;;OAIG;IACH,yBAFW,MAAM,QAUhB;IAqCD;;;;;;;;;OASG;IACH,aAPW,QAAQ,GAAC,QAAQ,GAAC,MAAM,MACxB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAYhB;IAED;;;;;;;;OAQG;IACH,gBAPW,QAAQ,GAAC,QAAQ,GAAC,MAAM,MACxB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAKhB;IAqDD;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAmBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACH,oBAJW,MAAM,uBACN,OAAO,GACL,MAAM,CAkClB;IAmBD;;;;;OAKG;IACH,yBAOC;IAED;;;;;;;;;;;OAWG;IACH,iBAVW,gBAAgB,GAAC,iBAAiB,GAAC,gBAAgB,GAAC,WAAW,GAAC,eAAe,GAAC,UAAU,MAC1F,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,QA0EhB;IAED;;;;;;;;;OASG;IACH,iDAHa,MAAM,CA0ElB;IAHC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAuC;IAKzC;;;;;;;;;OASG;IACH,kCANW,GAAG,CAAC,OAAO,CAAC,GAAC,KAAK,CAAC,OAAO,CAAC,WAC3B,KAAK,eACL,MAAM,eACN,MAAM,QAmBhB;IAdC,0FAAuD;IAgBzD;;;;;;OAMG;IACH,0BAHW,OAAO,QAyBjB;IApBC,8CAAiD;IAsBnD;;;;;OAKG;IACH,yFA4BC;IA1BC,+CAAkD;IA4BpD;;;;;;;;;;;;OAYG;IACH,sBAJa,YAAY,CAqBxB;IAPC,0CAIC;IAKH;;;;;;OAMG;IACH,iBAJa,YAAY,CAwBxB;IAPC,qCAIC;IAKH;;;;;;;OAOG;IACH,qBANW,YAAY,KACZ,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAqBhB;IAED;;;;;OAKG;IACH,qBAJW,gBAAgB,GAAC,eAAe,GAAC,gBAAgB,GAAC,iBAAiB,GAAC,WAAW,GAAC,eAAe,GAAC,UAAU,WAC1G,MAAM,GACJ,YAAY,CAUxB;IA4DD;;;;;;;;OAQG;IACH,yBAKC;IAED;;;;;;;;;;OAUG;IACH,mBAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAsChB;IAsCE,mCAA2C;IA2F9C;;;;;;;;;;;;;;;OAeG;IACH,mEAgEC;IAED;;;;;;;;;OASG;IACH,aARW,MAAM,KACN,MAAM,UACN,MAAM,SACN,MAAM,OACN,MAAM,kBACN,OAAO,SACP,OAAO,QAoBjB;IAED;;;;;;;;OAQG;IACH,WAPW,MAAM,KACN,MAAM,UACN,MAAM,SACN,MAAM,OACN,MAAM,kBACN,OAAO,QA6CjB;IAgGD;;;;;;OAMG;IACH,iBALW,MAAM,UACN,MAAM,QACN,MAAM,QACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,OAAO,SACP,OAAO,QA6DjB;IAED;;;OAGG;IACH,kBAFW,OAAO,QAiEjB;IAgGD;;;;;;;;OAQG;IACH,mBAPW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,MAAM,SACN,OAAO,QAoBjB;IAED;;;;;;;OAOG;IACH,iBANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,MAAM,QA4FhB;IAED;;;;OAIG;IACH,eAHW,MAAM,KACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,aAHW,MAAM,KACN,MAAM,QAIhB;IAED;;OAEG;IACH,kBAEC;IAED;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAIhB;IAED;;;;;;OAMG;IACH,sBALW,MAAM,OACN,MAAM,KACN,MAAM,KACN,MAAM,QAIhB;IAED;;;;;;;;OAQG;IACH,oBAPW,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,KACN,MAAM,KACN,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,UANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,QAIhB;IAED;;;;;;OAMG;IACH,QALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,aANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,SACN,MAAM,QAIhB;IAED;;OAEG;IACH,kBAEC;IA6FD;;;;;;;;;;;;;;;;OAgBG;IACH,yBA8BC;IAED;;;;;;;;;;OAUG;IACH,4BAuCC;IApBA;;;;;OAKG;IACH,iCAAkE;IA4CnE;;;;;OAKG;IACH,+BA6CC;IAED;;;OAGG;IACH,cAFa,gBAAgB,CAI5B;CAoGD;qBArtJoB,gBAAgB;0CA2BK,oCAAoC;yBAvBrD,qBAAqB;yBA5BrB,wBAAwB;uBAC1B,yBAAyB;gCAiDU,qBAAqB;8BAHjD,mBAAmB;8BACnB,yBAAyB;+BAMxB,oBAAoB;+BA5BpB,uCAAuC;wBAP9C,2BAA2B;6BAMtB,uCAAuC;8BAwCvC,4BAA4B;oBApErC,2BAA2B;sBAEd,qBAAqB;0BA+C5B,8BAA8B;8BAe7B,wBAAwB;iCAxClB,8BAA8B;+BAHhC,4BAA4B;6BASjB,qBAAqB;6BAmCrC,6BAA6B;yCAJjB,+BAA+B"}

package/package.json

@@ -1,31 +1,33 @@
 {
 	"name": "melonjs",
-	"version": "20.10.1",
-	"description": "melonJS Game Engine",
-	"homepage": "http://www.melonjs.org/",
+	"version": "20.12.0",
+	"description": "A modern & fully featured HTML5 game engine (2D & 3D) for JavaScript/TypeScript, with WebGL/WebGPU rendering, built-in physics, Tiled map & glTF support and WebAudio.",
+	"homepage": "https://www.melonjs.org/",
 	"type": "module",
 	"sideEffects": [
 		"./src/polyfill/**"
 	],
 	"keywords": [
-		"2D",
-		"HTML5",
-		"javascript",
-		"TypeScript",
-		"es6",
-		"Canvas",
-		"WebGL",
-		"WebGL2",
-		"WebAudio",
+		"game-engine",
+		"html5-game-engine",
+		"javascript-game-engine",
+		"gamedev",
 		"game",
-		"engine",
+		"2d",
+		"3d",
+		"html5",
+		"javascript",
+		"typescript",
+		"webgpu",
+		"webgl",
+		"webgl2",
+		"canvas",
+		"webaudio",
+		"physics",
 		"tiled",
-		"tileset",
-		"mapeditor",
-		"browser",
-		"electron",
-		"mobile",
-		"cordova"
+		"tilemap",
+		"gltf",
+		"glb"
 	],
 	"repository": {
 		"type": "git",

package/skills/AGENTS.md

@@ -64,4 +64,5 @@ Before hand-rolling: `ParticleEmitter`, `Trail`, `Tween`, the built-in
 Companion packages cover the rest: `@melonjs/planck-adapter` and
 `@melonjs/matter-adapter` (physics), `@melonjs/spine-plugin` (skeletal
 animation), `@melonjs/tiled-inflate-plugin` (**required** for compressed Tiled
-maps), `@melonjs/debug-plugin`, `@melonjs/capacitor-plugin`.
+maps), `@melonjs/debug-plugin`, `@melonjs/gamepad-plugin` (touch controls
+reported as a gamepad), `@melonjs/capacitor-plugin`.

package/skills/melonjs/SKILL.md

@@ -112,6 +112,7 @@ Tiled inflate plugin are *required* for their use cases, not merely convenient.
 | [`@melonjs/tiled-inflate-plugin`](https://www.npmjs.com/package/@melonjs/tiled-inflate-plugin) | **Required** to load gzip-, zlib- or zstd-compressed Tiled maps. Without it, parsing such a map throws `No inflate function set`. |
 | [`@melonjs/spine-plugin`](https://www.npmjs.com/package/@melonjs/spine-plugin) | Skeletal animation authored in Spine, as a melonJS renderable. |
 | [`@melonjs/debug-plugin`](https://www.npmjs.com/package/@melonjs/debug-plugin) | An in-game debug panel — FPS, draw counts, collision-shape and bounds overlays. Register it after `app.init()`. |
+| [`@melonjs/gamepad-plugin`](https://www.npmjs.com/package/@melonjs/gamepad-plugin) | On-screen touch controls for phones and tablets: sticks and buttons reported as a gamepad, so the game's `bindGamepad` bindings drive it. Use it rather than writing virtual controls. |
 | [`@melonjs/capacitor-plugin`](https://www.npmjs.com/package/@melonjs/capacitor-plugin) | Wrapping a game as a native iOS/Android app: it bridges Capacitor's lifecycle — pause/resume, the hardware back button, orientation lock, splash screen. |
 | [`create-melonjs`](https://www.npmjs.com/package/create-melonjs) | Scaffolding a new project — start here rather than assembling a build by hand. |
 

package/skills/melonjs-audio/SKILL.md

@@ -100,7 +100,27 @@ await loader.preload([{
 audio.play("sfx", { sprite: "jump" });
 ```
 
-The optional third element marks a region as looping. `play()`'s second argument
+### A loop with no gap
+
+An MP3 encoder pads the end of its file. Chrome and Firefox trim the padding when
+they decode it, Safari keeps it, so a looping MP3 has a short silence at every
+loop there (27 ms on a 12 s clip at 22 kHz, measured). Declare a region of the
+loop's exact length and loop on that: the voice never reaches the padding.
+
+```js
+await loader.preload([{
+    name: "ambience", type: "audio", src: "data/sfx/",
+    sprite: { loop: [0, 12000] },
+}]);
+audio.playTrack("ambience", { sprite: "loop", volume: 0.6 });
+// or, as a plain clip: audio.play("ambience", { sprite: "loop", loop: true })
+```
+
+Ogg Vorbis carries no such padding.
+
+The optional third element marks a region as looping: it loops unless `play()` is
+told `loop: false` (before 20.11 it only looped when `loop: true` was passed as
+well). `play()`'s second argument
 takes either the original `loop` boolean or a `PlayOptions` object
 (`sprite`, `loop`, `onend`, `volume`, plus the spatial `follow`, `at` and
 `stopWithTarget`) — both forms work. Object fields win over the positional
@@ -265,7 +285,7 @@ alone; reach for `position()` (or `follow` / `at`) when distance falloff
 matters.
 
 **Spatial audio is WebAudio-only.** On a clip loaded with `stream: true` (or
-`html5: true`) `stereo` / `position` / `orientation` return early and do
+`html5: true`, or `preload: false`) `stereo` / `position` / `orientation` return early and do
 nothing — which is exactly the case for the long music tracks people reach for
 first. `follow` and `at` are equally inert on a streamed clip.
 
@@ -399,7 +419,7 @@ very next line.
   mute: false,
   loop: false,
   autoplay: false,
-  preload: true,      // or "metadata"
+  preload: true,      // false: fetched on first play, then streamed; or "metadata"
   format: "mp3",      // explicit hint when the URL has no usable extension
   stream: true,       // long music: stream rather than decode into memory
   on: { play() {}, end() {}, stop() {}, unlock() {} },
@@ -417,6 +437,25 @@ same switch under its backend name.) `on` accepts the full lifecycle set:
 `play`, `pause`, `stop`, `end`, `fade`, `seek`, `rate`, `volume`, `mute`,
 `unlock`.
 
+**`preload: false` keeps a clip out of the preload.** Nothing is downloaded for
+it until it is first played (`audio.play`, `audio.playTrack`, or `autoplay`).
+That play fetches it and streams it, as `stream: true` does, so the sound starts
+as soon as enough of the file has arrived, not once all of it has; a clip never
+played is never downloaded. Use it for music a player may never reach (a boss
+theme, the ending) to shorten the wait before the game starts.
+
+- The loader reports such a clip done at once: `audio.state(name)` is
+  `"unloaded"` until its first play, then `"loading"`, then `"loaded"`.
+- It starts with the short delay of a stream on its first play. Keep a sound
+  effect that must sound the instant it is triggered preloaded.
+- Being streamed, it has the limits of `stream: true`: positional sound does
+  not apply to it, and it ignores `withCredentials` (see below).
+- Before 20.12.0 such a clip was never fetched at all, and stayed silent.
+
+`stream: true` alone still fetches the clip during the preload; combine it with
+`preload: false` to defer that too. `preload: "metadata"` only matters for a
+streamed clip: the preload fetches just enough to know its duration.
+
 Outside a preload, `audio.load(asset, onload?, onerror?)` takes the same
 descriptor and loads one clip at runtime — for a level's sounds fetched when
 the level starts. The loader calls the same function, so the same rules apply.
@@ -427,7 +466,8 @@ Re-preloading a manifest that already contains a loaded clip is a no-op —
 **Credentials use the same global switch as every other asset type** —
 `loader.setOptions({ withCredentials: true })`, not an audio-specific option.
 Buffered audio fetches through the shared loader path, so it honours it exactly
-as an image or a JSON file does. A `stream: true` clip does not: it plays
+as an image or a JSON file does. A streamed clip (`stream: true`, or
+`preload: false`) does not: it plays
 through an `<audio>` element, which needs a `crossorigin` attribute rather than
 fetch credentials. Preload a clip buffered if it sits behind a login.
 
@@ -455,7 +495,8 @@ either way — blank screen, empty console.
 | music keeps playing after leaving a scene | used `play` instead of `playTrack`, or no `stopTrack` in teardown |
 | two music tracks playing at once, and `stopTrack()` only silences one | melonJS before 20.9.0: `playTrack` did not stop the previous track, so the scene that started it had to `stopTrack()` on the way out |
 | the music restarts when returning to a screen | `playTrack` with the track already playing restarts it; don't call it again if the bed should carry on |
-| `stereo` / `position` do nothing | the clip was loaded with `stream: true` — spatial is WebAudio-only |
+| `stereo` / `position` do nothing | the clip was loaded with `stream: true` or `preload: false` — spatial is WebAudio-only |
+| a `preload: false` clip never plays, and `audio.state()` stays `"unloaded"` | melonJS before 20.12.0 never fetched such a clip; preload it, or update |
 | one format works, another does not | that codec is not in the `audio.init()` list |
 | audio behind a login fails, or the preload hangs | `loader.setOptions({ withCredentials: true })` — the same switch every asset type uses |
 | a streamed clip ignores `withCredentials` | `stream: true` plays through an `<audio>` element; preload it buffered instead |
@@ -467,6 +508,7 @@ either way — blank screen, empty console.
 | a looping sound outlives the entity that owns it | `follow` without `stopWithTarget: true` |
 | a voice panned with `stereo()` loses its 3D placement, or the reverse | one panner node per voice and last writer wins — pick one per voice and stay with it |
 | a reverb / compressor on the master gain does not affect the music | the music is `stream: true`, which bypasses the master gain — preload it buffered |
+| a looping MP3 drops out for a moment at every loop, in Safari only | Safari keeps the encoder's padding at the end of the file: loop a sprite region of the clip's exact length (see "A loop with no gap") |
 | sound effects keep playing after the window loses focus | `pauseOnBlur` and `stopOnBlur` are both off, so the engine is deliberately leaving the game running in the background |
 
 ## Related skills

package/skills/melonjs-camera-and-drawing/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: melonjs-camera-and-drawing
-description: "Use this skill for camera control and immediate-mode drawing in melonJS — following a target, viewport bounds, shake and fade, secondary cameras, and drawing shapes, lines and gradients inside a custom draw(). Covers world versus screen coordinate conversion, clipping and masking, baking with CanvasRenderTarget, and reading pixels back. Triggers on: Camera2d, viewport, follow, setBounds, shake, fadeIn, fadeOut, worldToLocal, localToWorld, colorMatrix, renderer.fill, renderer.stroke, Rect, Ellipse, Polygon, Line, Gradient, clipRect, mask, CanvasRenderTarget, NoiseTexture2d, lookAt, setBasis, toImageData, getImageData, toBlob, toDataURL, screenshot, read pixels."
+description: "Use this skill for camera control and immediate-mode drawing in melonJS — following a target, viewport bounds, shake and fade, secondary cameras and what each one draws, and drawing shapes, lines and gradients inside a custom draw(). Covers world versus screen coordinate conversion, clipping and masking, baking with CanvasRenderTarget, and reading pixels back. Triggers on: Camera2d, viewport, follow, offset, look ahead, setBounds, minimap, second camera, split screen, cullMask, visibilityLayer, hide from a camera, shake, fadeIn, fadeOut, worldToLocal, localToWorld, colorMatrix, renderer.fill, renderer.stroke, Rect, Ellipse, Polygon, Line, Gradient, clipRect, mask, CanvasRenderTarget, NoiseTexture2d, lookAt, setBasis, toImageData, getImageData, toBlob, toDataURL, screenshot, read pixels."
 license: MIT
 ---
 
@@ -24,6 +24,24 @@ frame-rate independent since 19.7. `AXIS.HORIZONTAL` / `AXIS.VERTICAL` /
 
 Call it from the followed entity's `onActivateEvent`, using `this.parentApp`.
 
+**To frame the target off centre, set `offset`; do not follow a helper
+object.** It shifts the view without moving the camera, in world units, and is
+applied after following and the bounds, so the view can show past them:
+
+```js
+app.viewport.follow(player, app.viewport.AXIS.BOTH, 0.1);
+app.viewport.offset.set(0, -70);   // look a little above the feet
+
+// or ahead of where the player faces, eased (see math.damp below)
+const ahead = facingLeft ? -80 : 80;
+app.viewport.offset.x = math.damp(app.viewport.offset.x, ahead, 4, dt / 1000);
+```
+
+Culling, tile layers, parallax `ImageLayer`s, lights and the pointer
+(`localToWorld`, `worldToLocal`) all count it. `shake()` adds its jitter on top
+and gives the value back when it ends, so setting it before or during a shake
+is fine. `reset()` clears it.
+
 **For anything that is NOT the camera, the same smoothing is `math.damp`.**
 `follow()` is frame-rate independent for you; a value you smooth yourself is
 not, and `lerp(current, target, alpha)` once per frame moves further on a slow
@@ -191,6 +209,37 @@ View state is per camera, not per scene: a `Camera3d` carries its own distance
 fog (`setFog`), so a minimap or split-screen view fogs independently of the main
 one — and a `Camera2d` never fogs. See `melonjs-3d`.
 
+### What each camera draws: `visibilityLayer` and `cullMask`
+
+Every camera draws the whole world. To keep something off one camera only, put
+it on a layer that camera leaves out. A renderable's `visibilityLayer` is the
+layers it is on, as bits (1, 2, 4...); a camera's `cullMask` is the layers it
+draws. A camera draws a renderable only if the two share a bit:
+
+```js
+const PARTICLES = 2;
+emitter.visibilityLayer = PARTICLES;   // the particles go on layer 2
+minimap.cullMask = ~PARTICLES;         // the minimap draws every layer but 2
+```
+
+- By default every renderable is on layer 1 and every camera draws every layer
+  (`cullMask` is `-1`), so nothing changes until a game sets one.
+- A container left out is left out with everything inside it, however deep:
+  set it on an emitter and none of its particles are drawn. The world itself
+  obeys it too, and so does what it contains: a child is drawn only if it and
+  every container above it share a bit with the camera.
+- A renderable on layer `0` is drawn by no camera; a `cullMask` of `0` draws
+  nothing.
+- It decides drawing only: what a camera leaves out still updates, collides and
+  receives pointer events.
+- A `Light2d` a camera leaves out, itself or a container it is in, neither
+  glows, nor cuts its hole in the darkness, nor lights normal-mapped sprites in
+  that camera. A `Light3d` lights the meshes of every camera.
+- It adds to the floating rule: a floating renderable is drawn by a secondary
+  camera only with `visibleInAllCameras`, and only if the layers match as well.
+- On a Tiled object, set it as an `int` custom property named
+  `visibilityLayer`.
+
 ## Immediate-mode drawing
 
 Inside a custom `draw(renderer)` you can draw shapes directly. Remember the two
@@ -269,6 +318,14 @@ Pass `rt.canvas`, never `rt` — a `CanvasRenderTarget` is a wrapper, not a
 drawable, and the engine's own bakes (the particle emitter's default texture)
 hand `.canvas` on for exactly that reason.
 
+**Create it once and keep it.** On a GPU backend, once drawn, its texture stays
+on the GPU for as long as the renderer lives: a stage change does not release
+it, and no public call does. A target made for every level, every restart or
+every spawned object leaks one texture each time, so make it once (at module
+level, say) and clear it for reuse. If you paint into it again after it has
+been drawn, call `rt.invalidate(renderer)` before the next draw so the GPU copy
+is refreshed.
+
 This is the sanctioned performance idiom before reaching for a custom shader.
 
 **For a solid fill you do not need a canvas at all.** `Renderer.getWhitePixel()`
@@ -338,7 +395,12 @@ const data = await rt.toImageData(0, 0, w, h);
 | baked target draws nothing / throws | passed the `CanvasRenderTarget`, not its `.canvas` |
 | `getImageData()` throws on one machine but not another | that one is on the WebGPU renderer, which cannot read back synchronously — `await toImageData()` instead |
 | frame rate drops with many static draws | bake into a `CanvasRenderTarget` instead |
+| GPU memory grows with every level or restart | a `CanvasRenderTarget` created each time: make one and reuse it |
+| a repainted `CanvasRenderTarget` still shows the old pixels | call `rt.invalidate(renderer)` after painting |
 | a 3D camera cannot be given an arbitrary up | `Camera3d#lookAt(target, up)` or `setBasis(right, up, forward)`; see `melonjs-3d` |
+| particles or effects clutter a minimap | every camera draws everything: put them on their own `visibilityLayer` and leave it out of the minimap's `cullMask` |
+| something is missing from one camera only | its `visibilityLayer`, or a container's above it, shares no bit with that camera's `cullMask` |
+| a renderable shows in no camera at all | its `visibilityLayer` is `0`, or the world's own layer is left out |
 
 ## Related skills
 

package/skills/melonjs-display-and-scaling/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: melonjs-display-and-scaling
-description: "Use this skill when a melonJS game looks blurry, soft, shimmering or cropped, or when choosing how the canvas fills its page. Covers the design resolution, scale and scaleMethod, scaleTarget, scaleRounding for pixel-perfect integer scaling, antiAlias, textureFilter, subPixel, devicePixelRatio, and which setting does which job. Triggers on: blurry, soft, fuzzy, shimmering, pixel art, pixel perfect, crisp, nearest, linear, scale, scaleMethod, scaleTarget, scaleRounding, integer scaling, antiAlias, textureFilter, subPixel, devicePixelRatio, retina, hidpi, design resolution, canvas size, canvas cropped, letterbox, image-rendering, upscale, resolution."
+description: "Use this skill when a melonJS game looks blurry, soft, shimmering or cropped, or when choosing how the canvas fills its page. Covers the design resolution, scale and scaleMethod, scaleTarget, scaleRounding for pixel-perfect integer scaling, antiAlias, textureFilter and linear-mipmap for what is drawn small, subPixel, syncToDisplay for steady motion, devicePixelRatio, and which setting does which job. Triggers on: blurry, soft, fuzzy, shimmering, pixel art, pixel perfect, crisp, nearest, linear, scale, scaleMethod, scaleTarget, scaleRounding, integer scaling, antiAlias, textureFilter, linear-mipmap, mipmaps, minimap shimmer, zoomed out, subPixel, syncToDisplay, stutter, judder, uneven scrolling, devicePixelRatio, retina, hidpi, design resolution, canvas size, canvas cropped, letterbox, image-rendering, upscale, resolution."
 license: MIT
 ---
 
@@ -23,7 +23,9 @@ separate decisions. Knowing which setting owns which is most of the work.
 | how a texture is sampled | `antiAlias`, `textureFilter` | nearest or linear, and the CSS upscale filter |
 
 `subPixel` is a fifth, orthogonal to all of them: it decides whether a
-renderable may sit on a fractional position WITHIN the frame.
+renderable may sit on a fractional position WITHIN the frame. `syncToDisplay`
+is about the frames in a row rather than one frame: whether motion advances
+by the same amount on each.
 
 ## Design resolution
 
@@ -155,19 +157,121 @@ can have smooth model edges and nearest-sampled sprites. The presentation half
 is not separable: there is no way to get MSAA silhouettes and a hard-edged
 upscale at the same time.
 
+## Drawn small: `textureFilter: "linear-mipmap"`
+
+A sprite drawn much smaller than its texture (a zoomed-out camera, a minimap,
+a scaled-down sprite) shimmers as it moves, even with linear sampling: each
+screen pixel covers many texels and linear sampling blends only four of them.
+`"linear-mipmap"` samples the texture's mipmaps, smaller copies averaged in
+advance, wherever something is drawn below its size:
+
+```js
+const app = new Application(1280, 720, { textureFilter: "linear-mipmap" });
+```
+
+At its size or larger a texture draws as it does under `"linear"`, so a game
+whose main view is at its size and whose minimap is zoomed out gets a smooth
+minimap and an unchanged view. It covers sprites, text and tile layers, not a
+video nor a texture the engine renders into, and a `nearest` texture keeps to
+its full size. GPU backends only; on WebGPU each texture it applies to takes
+about a third more memory.
+
+A small mipmap level's texels span many of the art's pixels, so a sample near
+the edge of a frame would reach into the next frame of the atlas. Under
+`"linear-mipmap"` every sprite and tile keeps its samples half a texel of the
+level it reads inside its own frame, so the next frame no longer streaks along
+its edges. Two limits:
+
+- a level's texel is an average of a square of the art, 2, 4, 8 pixels a side
+  and so on. Where a frame's edge falls inside such a square, its outermost
+  texel already holds some of the neighbour: drawn very small, a frame of an
+  atlas packed edge to edge can show a faint line of it. Frames on a grid of
+  a power of two (a 32 or 64 px sheet) are free of it, and a padding of a few
+  pixels between frames removes it elsewhere;
+- a sprite drawn through a `ShaderEffect` samples the texture in the effect's
+  own program, which is not kept to the frame.
+
+A repeating pattern is left to wrap.
+
 ## `subPixel` is about position, not scale
 
-`subPixel: false` (the default) truncates a renderable's translation to whole
-pixels inside the frame. It is `|0`, so it truncates **toward zero** rather
-than rounding, which is worth knowing when something travels a short distance:
-an offset that should swing between -3 and +3 lands on -2 and +2, and parks at
-the extremes for longer than it should.
+`subPixel: false` (the default) draws everything on whole pixels. The snap
+happens **once, where a draw lands**, the same on every renderer: each edge of
+a sprite, a shape or a clip is rounded to the nearest pixel after every
+translation and scale it is drawn under. So:
+
+- nested containers add their positions up exactly first (10.6 then -6.5
+  lands on 4, the pixel 4.1 is in);
+- a flipped sprite covers the pixels it covers unflipped;
+- a sprite and a `fillRect` at the same position cover the same pixels, and a
+  shape has no half-grey edge on the Canvas renderer;
+- a position floating point error leaves a hair short of a pixel, such as a
+  body resting on the floor at `223.99999999999997` after a collision
+  push-out, draws on that pixel (224), so it does not shake every other frame.
+
+The camera's view starts on a whole pixel too, in world units (zoomed 2x, it
+moves in 2 px steps), and culling and the pointer use that same position:
+things standing still stay still against each other while the view scrolls,
+and a click lands on what is drawn under it. A rotated draw, and anything a
+`Camera3d` draws, is left where it is.
 
 It does nothing about how the frame reaches the screen. A game that carefully
 snaps positions and is then scaled by 2.667 has thrown that work away at the
 last step, which is the contradiction `scaleRounding: "integer"` exists to
 resolve.
 
+`subPixel: true` alone does not make motion smooth: with nearest sampling a
+sprite between two pixels is still drawn on one of them, so a scene moving
+4.5 pixels a frame jumps by 4 and 5 in turn. Rendered art (not pixel art)
+moves smoothly with `textureFilter: "linear"` as well, which blends it across
+the two, while the upscale stays crisp (`antiAlias: true` would also smooth the
+whole canvas as it is scaled up, which is what makes it look blurry). A still
+scene is only sharp when the camera rests on a whole pixel, so give it a
+target on whole pixels:
+
+```js
+const app = new Application(1280, 720, {
+	scale: "auto",
+	subPixel: true,
+	textureFilter: "linear",
+	syncToDisplay: true,
+});
+// the camera follows a point on whole pixels, kept on the hero: it glides
+// between pixels while following, and comes to rest on one
+const focus = new Vector2d();
+app.viewport.follow(focus, app.viewport.AXIS.BOTH, 0.12);
+
+// in the hero's update(dt)
+focus.set(Math.round(this.pos.x), Math.round(this.pos.y));
+```
+
+## `syncToDisplay` is about steady motion
+
+The game updates in fixed steps, 60 a second by default, as many as the time
+since the last frame holds. Browsers report that time with up to a millisecond
+of jitter, so on a 60 Hz display a frame now and then gets no update and the
+next one gets two: the world holds still for a frame, then moves twice as far.
+Scrolling, and anything else moving steadily, stutters while the frame rate
+reads a solid 60.
+
+```js
+const app = new Application(1280, 720, { scale: "auto", syncToDisplay: true });
+```
+
+With it on, frame times are counted in whole display frames and what is
+rounded off is carried to the next frame: one update every frame at 60 Hz, one
+every other frame at 120 Hz, and the game keeps its speed. A display within 2%
+of `timer.maxfps` (60 by default), or of 2, 3 or 4 times it, or a half, a third
+or a quarter of it, is counted at exactly that rate, so a 59.94 Hz screen runs
+the game 0.1% slower than the wall clock; leave it off when the updates must
+keep to the wall clock exactly. The display's rate is learned as the game runs,
+and again when it changes (the window moved to another screen). At a refresh
+that is no multiple of the update rate (144 Hz, 165 Hz) the steps cannot fall
+evenly however the time is counted.
+
+It is off by default. It sets `timer.syncToDisplay` when the application is
+initialized, which a game can also switch at any time.
+
 ## Soft text next to crisp sprites
 
 If everything is crisp EXCEPT the text, the scale factor is not the cause: a
@@ -266,6 +370,12 @@ const app = new Application(1024, 576, {
 | the canvas is cropped or overflows its box | automatic scaling measured the wrong element; name it with `scaleTarget` |
 | the canvas grows on every resize | the measured ancestor is auto-sized around the canvas itself |
 | things shimmer as they move | fractional positions; check `subPixel`, and that the scale factor is whole |
+| scrolling stutters while the frame rate reads 60 | a frame now and then runs no update and the next two; set `syncToDisplay: true` |
+| moving rendered art jumps by whole pixels with `subPixel: true` | nearest sampling still draws it on one pixel; add `textureFilter: "linear"` |
+| the whole game looks blurry with `antiAlias: true` | it also smooths the canvas as it is scaled up; use `textureFilter: "linear"` instead |
+| a minimap or a zoomed-out view shimmers as it moves | linear sampling blends 4 texels where a pixel covers many; use `textureFilter: "linear-mipmap"` |
+| faint lines along sprites drawn small, from the next frame of the atlas | under `"linear-mipmap"` the built-in sprite shaders keep to the frame, but not a `ShaderEffect`'s own sample, and the smallest levels still mix a frame not on a power-of-two grid with its neighbour: pad the atlas |
+| a still scene looks a little soft with linear sampling | the camera rests between two pixels; follow a target rounded to whole pixels |
 | 3D model edges are jagged | `antiAlias: false` also disables MSAA; turn it on and use `textureFilter` for textures |
 | textures are smoothed when they should be blocky | `antiAlias: true` makes the default texture filter linear; set `textureFilter: "nearest"` |
 | `scaleRounding: "integer"` changes nothing | it applies to `scaleMethod: "fit"` only; the others resize the renderer |