@galacean/engine-ui 0.0.0-experimental-2.0-migrate.6 → 0.0.0-experimental-2.0-migrate.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/main.js CHANGED
@@ -42,32 +42,552 @@ function _create_class(Constructor, protoProps, staticProps) {
42
42
  return Constructor;
43
43
  }
44
44
 
45
- /******************************************************************************
46
- Copyright (c) Microsoft Corporation.
47
-
48
- Permission to use, copy, modify, and/or distribute this software for any
49
- purpose with or without fee is hereby granted.
50
-
51
- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
52
- REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
53
- AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
54
- INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
55
- LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
56
- OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
57
- PERFORMANCE OF THIS SOFTWARE.
58
- ***************************************************************************** */
59
-
60
- function __decorate(decorators, target, key, desc) {
61
- var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
62
- if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
63
- else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
64
- return c > 3 && r && Object.defineProperty(target, key, r), r;
65
- }
45
+ /* @minVersion 7.20.0 */
66
46
 
67
- typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
68
- var e = new Error(message);
69
- return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
70
- };
47
+ /**
48
+ Enums are used in this file, but not assigned to vars to avoid non-hoistable values
49
+
50
+ CONSTRUCTOR = 0;
51
+ PUBLIC = 1;
52
+ PRIVATE = 2;
53
+
54
+ FIELD = 0;
55
+ ACCESSOR = 1;
56
+ METHOD = 2;
57
+ GETTER = 3;
58
+ SETTER = 4;
59
+
60
+ STATIC = 5;
61
+
62
+ CLASS = 10; // only used in assertValidReturnValue
63
+ */
64
+
65
+ function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
66
+ function createAddInitializerMethod(initializers, decoratorFinishedRef) {
67
+ return function addInitializer(initializer) {
68
+ assertNotFinished(decoratorFinishedRef, "addInitializer");
69
+ assertCallable(initializer, "An initializer");
70
+ initializers.push(initializer);
71
+ };
72
+ }
73
+
74
+ function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
75
+ var kindStr;
76
+
77
+ switch (kind) {
78
+ case 1 /* ACCESSOR */:
79
+ kindStr = "accessor";
80
+ break;
81
+ case 2 /* METHOD */:
82
+ kindStr = "method";
83
+ break;
84
+ case 3 /* GETTER */:
85
+ kindStr = "getter";
86
+ break;
87
+ case 4 /* SETTER */:
88
+ kindStr = "setter";
89
+ break;
90
+ default:
91
+ kindStr = "field";
92
+ }
93
+
94
+ var ctx = { kind: kindStr, name: isPrivate ? "#" + name : name, static: isStatic, private: isPrivate, metadata: metadata };
95
+
96
+ var decoratorFinishedRef = { v: false };
97
+
98
+ ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
99
+
100
+ var get, set;
101
+ if (kind === 0 /* FIELD */) {
102
+ if (isPrivate) {
103
+ get = desc.get;
104
+ set = desc.set;
105
+ } else {
106
+ get = function() {
107
+ return this[name];
108
+ };
109
+ set = function(v) {
110
+ this[name] = v;
111
+ };
112
+ }
113
+ } else if (kind === 2 /* METHOD */) {
114
+ get = function() {
115
+ return desc.value;
116
+ };
117
+ } else {
118
+ // replace with values that will go through the final getter and setter
119
+ if (kind === 1 /* ACCESSOR */ || kind === 3 /* GETTER */) {
120
+ get = function() {
121
+ return desc.get.call(this);
122
+ };
123
+ }
124
+
125
+ if (kind === 1 /* ACCESSOR */ || kind === 4 /* SETTER */) {
126
+ set = function(v) {
127
+ desc.set.call(this, v);
128
+ };
129
+ }
130
+ }
131
+ ctx.access = get && set ? { get: get, set: set } : get ? { get: get } : { set: set };
132
+
133
+ try {
134
+ return dec(value, ctx);
135
+ } finally {
136
+ decoratorFinishedRef.v = true;
137
+ }
138
+ }
139
+
140
+ function assertNotFinished(decoratorFinishedRef, fnName) {
141
+ if (decoratorFinishedRef.v) {
142
+ throw new Error("attempted to call " + fnName + " after decoration was finished");
143
+ }
144
+ }
145
+
146
+ function assertCallable(fn, hint) {
147
+ if (typeof fn !== "function") {
148
+ throw new TypeError(hint + " must be a function");
149
+ }
150
+ }
151
+
152
+ function assertValidReturnValue(kind, value) {
153
+ var type = typeof value;
154
+
155
+ if (kind === 1 /* ACCESSOR */) {
156
+ if (type !== "object" || value === null) {
157
+ throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
158
+ }
159
+ if (value.get !== undefined) {
160
+ assertCallable(value.get, "accessor.get");
161
+ }
162
+ if (value.set !== undefined) {
163
+ assertCallable(value.set, "accessor.set");
164
+ }
165
+ if (value.init !== undefined) {
166
+ assertCallable(value.init, "accessor.init");
167
+ }
168
+ } else if (type !== "function") {
169
+ var hint;
170
+ if (kind === 0 /* FIELD */) {
171
+ hint = "field";
172
+ } else if (kind === 10 /* CLASS */) {
173
+ hint = "class";
174
+ } else {
175
+ hint = "method";
176
+ }
177
+ throw new TypeError(hint + " decorators must return a function or void 0");
178
+ }
179
+ }
180
+
181
+ function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
182
+ var decs = decInfo[0];
183
+
184
+ var desc, init, value;
185
+
186
+ if (isPrivate) {
187
+ if (kind === 0 /* FIELD */ || kind === 1 /* ACCESSOR */) {
188
+ desc = { get: decInfo[3], set: decInfo[4] };
189
+ } else if (kind === 3 /* GETTER */) {
190
+ desc = { get: decInfo[3] };
191
+ } else if (kind === 4 /* SETTER */) {
192
+ desc = { set: decInfo[3] };
193
+ } else {
194
+ desc = { value: decInfo[3] };
195
+ }
196
+ } else if (kind !== 0 /* FIELD */) {
197
+ desc = Object.getOwnPropertyDescriptor(base, name);
198
+ }
199
+
200
+ if (kind === 1 /* ACCESSOR */) {
201
+ value = { get: desc.get, set: desc.set };
202
+ } else if (kind === 2 /* METHOD */) {
203
+ value = desc.value;
204
+ } else if (kind === 3 /* GETTER */) {
205
+ value = desc.get;
206
+ } else if (kind === 4 /* SETTER */) {
207
+ value = desc.set;
208
+ }
209
+
210
+ var newValue, get, set;
211
+
212
+ if (typeof decs === "function") {
213
+ newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
214
+
215
+ if (newValue !== void 0) {
216
+ assertValidReturnValue(kind, newValue);
217
+
218
+ if (kind === 0 /* FIELD */) {
219
+ init = newValue;
220
+ } else if (kind === 1 /* ACCESSOR */) {
221
+ init = newValue.init;
222
+ get = newValue.get || value.get;
223
+ set = newValue.set || value.set;
224
+
225
+ value = { get: get, set: set };
226
+ } else {
227
+ value = newValue;
228
+ }
229
+ }
230
+ } else {
231
+ for (var i = decs.length - 1; i >= 0; i--) {
232
+ var dec = decs[i];
233
+
234
+ newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
235
+
236
+ if (newValue !== void 0) {
237
+ assertValidReturnValue(kind, newValue);
238
+ var newInit;
239
+
240
+ if (kind === 0 /* FIELD */) {
241
+ newInit = newValue;
242
+ } else if (kind === 1 /* ACCESSOR */) {
243
+ newInit = newValue.init;
244
+ get = newValue.get || value.get;
245
+ set = newValue.set || value.set;
246
+
247
+ value = { get: get, set: set };
248
+ } else {
249
+ value = newValue;
250
+ }
251
+
252
+ if (newInit !== void 0) {
253
+ if (init === void 0) {
254
+ init = newInit;
255
+ } else if (typeof init === "function") {
256
+ init = [init, newInit];
257
+ } else {
258
+ init.push(newInit);
259
+ }
260
+ }
261
+ }
262
+ }
263
+ }
264
+
265
+ if (kind === 0 /* FIELD */ || kind === 1 /* ACCESSOR */) {
266
+ if (init === void 0) {
267
+ // If the initializer was void 0, sub in a dummy initializer
268
+ init = function(instance, init) {
269
+ return init;
270
+ };
271
+ } else if (typeof init !== "function") {
272
+ var ownInitializers = init;
273
+
274
+ init = function(instance, init) {
275
+ var value = init;
276
+
277
+ for (var i = 0; i < ownInitializers.length; i++) value = ownInitializers[i].call(instance, value);
278
+
279
+ return value;
280
+ };
281
+ } else {
282
+ var originalInitializer = init;
283
+
284
+ init = function(instance, init) {
285
+ return originalInitializer.call(instance, init);
286
+ };
287
+ }
288
+
289
+ ret.push(init);
290
+ }
291
+
292
+ if (kind !== 0 /* FIELD */) {
293
+ if (kind === 1 /* ACCESSOR */) {
294
+ desc.get = value.get;
295
+ desc.set = value.set;
296
+ } else if (kind === 2 /* METHOD */) {
297
+ desc.value = value;
298
+ } else if (kind === 3 /* GETTER */) {
299
+ desc.get = value;
300
+ } else if (kind === 4 /* SETTER */) {
301
+ desc.set = value;
302
+ }
303
+
304
+ if (isPrivate) {
305
+ if (kind === 1 /* ACCESSOR */) {
306
+ ret.push(function(instance, args) {
307
+ return value.get.call(instance, args);
308
+ });
309
+ ret.push(function(instance, args) {
310
+ return value.set.call(instance, args);
311
+ });
312
+ } else if (kind === 2 /* METHOD */) {
313
+ ret.push(value);
314
+ } else {
315
+ ret.push(function(instance, args) {
316
+ return value.call(instance, args);
317
+ });
318
+ }
319
+ } else {
320
+ Object.defineProperty(base, name, desc);
321
+ }
322
+ }
323
+ }
324
+
325
+ function applyMemberDecs(Class, decInfos, metadata) {
326
+ var ret = [];
327
+ var protoInitializers;
328
+ var staticInitializers;
329
+
330
+ var existingProtoNonFields = new Map();
331
+ var existingStaticNonFields = new Map();
332
+
333
+ for (var i = 0; i < decInfos.length; i++) {
334
+ var decInfo = decInfos[i];
335
+
336
+ // skip computed property names
337
+ if (!Array.isArray(decInfo)) continue;
338
+
339
+ var kind = decInfo[1];
340
+ var name = decInfo[2];
341
+ var isPrivate = decInfo.length > 3;
342
+
343
+ var isStatic = kind >= 5; /* STATIC */
344
+ var base;
345
+ var initializers;
346
+
347
+ if (isStatic) {
348
+ base = Class;
349
+ kind = kind - 5 /* STATIC */;
350
+ // initialize staticInitializers when we see a non-field static member
351
+ staticInitializers = staticInitializers || [];
352
+ initializers = staticInitializers;
353
+ } else {
354
+ base = Class.prototype;
355
+ // initialize protoInitializers when we see a non-field member
356
+ protoInitializers = protoInitializers || [];
357
+ initializers = protoInitializers;
358
+ }
359
+
360
+ if (kind !== 0 /* FIELD */ && !isPrivate) {
361
+ var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
362
+
363
+ var existingKind = existingNonFields.get(name) || 0;
364
+
365
+ if (existingKind === true || (existingKind === 3 /* GETTER */ && kind !== 4) /* SETTER */ || (existingKind === 4 /* SETTER */ && kind !== 3) /* GETTER */) {
366
+ throw new Error(
367
+ "Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: "
368
+ + name
369
+ );
370
+ } else if (!existingKind && kind > 2 /* METHOD */) {
371
+ existingNonFields.set(name, kind);
372
+ } else {
373
+ existingNonFields.set(name, true);
374
+ }
375
+ }
376
+
377
+ applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
378
+ }
379
+
380
+ pushInitializers(ret, protoInitializers);
381
+ pushInitializers(ret, staticInitializers);
382
+ return ret;
383
+ }
384
+
385
+ function pushInitializers(ret, initializers) {
386
+ if (initializers) {
387
+ ret.push(function(instance) {
388
+ for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
389
+ return instance;
390
+ });
391
+ }
392
+ }
393
+
394
+ function applyClassDecs(targetClass, classDecs, metadata) {
395
+ if (classDecs.length > 0) {
396
+ var initializers = [];
397
+ var newClass = targetClass;
398
+ var name = targetClass.name;
399
+
400
+ for (var i = classDecs.length - 1; i >= 0; i--) {
401
+ var decoratorFinishedRef = { v: false };
402
+
403
+ try {
404
+ var nextNewClass = classDecs[i](newClass, { kind: "class", name: name, addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef), metadata });
405
+ } finally {
406
+ decoratorFinishedRef.v = true;
407
+ }
408
+
409
+ if (nextNewClass !== undefined) {
410
+ assertValidReturnValue(10, /* CLASS */ nextNewClass);
411
+ newClass = nextNewClass;
412
+ }
413
+ }
414
+
415
+ return [defineMetadata(newClass, metadata), function() {
416
+ for (var i = 0; i < initializers.length; i++) initializers[i].call(newClass);
417
+ }];
418
+ }
419
+ // The transformer will not emit assignment when there are no class decorators,
420
+ // so we don't have to return an empty array here.
421
+ }
422
+
423
+ function defineMetadata(Class, metadata) {
424
+ return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), { configurable: true, enumerable: true, value: metadata });
425
+ }
426
+
427
+ /**
428
+ Basic usage:
429
+
430
+ applyDecs(
431
+ Class,
432
+ [
433
+ // member decorators
434
+ [
435
+ dec, // dec or array of decs
436
+ 0, // kind of value being decorated
437
+ 'prop', // name of public prop on class containing the value being decorated,
438
+ '#p', // the name of the private property (if is private, void 0 otherwise),
439
+ ]
440
+ ],
441
+ [
442
+ // class decorators
443
+ dec1, dec2
444
+ ]
445
+ )
446
+ ```
447
+
448
+ Fully transpiled example:
449
+
450
+ ```js
451
+ @dec
452
+ class Class {
453
+ @dec
454
+ a = 123;
455
+
456
+ @dec
457
+ #a = 123;
458
+
459
+ @dec
460
+ @dec2
461
+ accessor b = 123;
462
+
463
+ @dec
464
+ accessor #b = 123;
465
+
466
+ @dec
467
+ c() { console.log('c'); }
468
+
469
+ @dec
470
+ #c() { console.log('privC'); }
471
+
472
+ @dec
473
+ get d() { console.log('d'); }
474
+
475
+ @dec
476
+ get #d() { console.log('privD'); }
477
+
478
+ @dec
479
+ set e(v) { console.log('e'); }
480
+
481
+ @dec
482
+ set #e(v) { console.log('privE'); }
483
+ }
484
+
485
+
486
+ // becomes
487
+ let initializeInstance;
488
+ let initializeClass;
489
+
490
+ let initA;
491
+ let initPrivA;
492
+
493
+ let initB;
494
+ let initPrivB, getPrivB, setPrivB;
495
+
496
+ let privC;
497
+ let privD;
498
+ let privE;
499
+
500
+ let Class;
501
+ class _Class {
502
+ static {
503
+ let ret = applyDecs(
504
+ this,
505
+ [
506
+ [dec, 0, 'a'],
507
+ [dec, 0, 'a', (i) => i.#a, (i, v) => i.#a = v],
508
+ [[dec, dec2], 1, 'b'],
509
+ [dec, 1, 'b', (i) => i.#privBData, (i, v) => i.#privBData = v],
510
+ [dec, 2, 'c'],
511
+ [dec, 2, 'c', () => console.log('privC')],
512
+ [dec, 3, 'd'],
513
+ [dec, 3, 'd', () => console.log('privD')],
514
+ [dec, 4, 'e'],
515
+ [dec, 4, 'e', () => console.log('privE')],
516
+ ],
517
+ [
518
+ dec
519
+ ]
520
+ )
521
+
522
+ initA = ret[0];
523
+
524
+ initPrivA = ret[1];
525
+
526
+ initB = ret[2];
527
+
528
+ initPrivB = ret[3];
529
+ getPrivB = ret[4];
530
+ setPrivB = ret[5];
531
+
532
+ privC = ret[6];
533
+
534
+ privD = ret[7];
535
+
536
+ privE = ret[8];
537
+
538
+ initializeInstance = ret[9];
539
+
540
+ Class = ret[10]
541
+
542
+ initializeClass = ret[11];
543
+ }
544
+
545
+ a = (initializeInstance(this), initA(this, 123));
546
+
547
+ #a = initPrivA(this, 123);
548
+
549
+ #bData = initB(this, 123);
550
+ get b() { return this.#bData }
551
+ set b(v) { this.#bData = v }
552
+
553
+ #privBData = initPrivB(this, 123);
554
+ get #b() { return getPrivB(this); }
555
+ set #b(v) { setPrivB(this, v); }
556
+
557
+ c() { console.log('c'); }
558
+
559
+ #c(...args) { return privC(this, ...args) }
560
+
561
+ get d() { console.log('d'); }
562
+
563
+ get #d() { return privD(this); }
564
+
565
+ set e(v) { console.log('e'); }
566
+
567
+ set #e(v) { privE(this, v); }
568
+ }
569
+
570
+ initializeClass(Class);
571
+ */
572
+
573
+ _apply_decs_2203_r = function(targetClass, memberDecs, classDecs, parentClass) {
574
+ if (parentClass !== void 0) {
575
+ var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
576
+ }
577
+ var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
578
+ var e = applyMemberDecs(targetClass, memberDecs, metadata);
579
+ if (!classDecs.length) defineMetadata(targetClass, metadata);
580
+ return {
581
+ e: e,
582
+ // Lazily apply class decorations so that member init locals can be properly bound.
583
+ get c() {
584
+ return applyClassDecs(targetClass, classDecs, metadata);
585
+ }
586
+ };
587
+ };
588
+
589
+ return _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass);
590
+ }
71
591
 
72
592
  function _instanceof(left, right) {
73
593
  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
@@ -75,6 +595,10 @@ function _instanceof(left, right) {
75
595
  } else return left instanceof right;
76
596
  }
77
597
 
598
+ function _identity(x) {
599
+ return x;
600
+ }
601
+
78
602
  /**
79
603
  * @internal
80
604
  * Visual-layering driven UI batching: solve visual correctness first, batching falls out for free.
@@ -274,13 +798,14 @@ var SortEntry = function SortEntry() {
274
798
  return VerticalAlignmentMode;
275
799
  }({});
276
800
 
801
+ var _init__size, _init__pivot;
277
802
  /**
278
803
  * The Transform component exclusive to the UI element.
279
804
  */ var UITransform = /*#__PURE__*/ function(Transform) {
280
805
  _inherits(UITransform, Transform);
281
806
  function UITransform(entity) {
282
807
  var _this;
283
- _this = Transform.call(this, entity) || this, _this._size = new engine.Vector2(100, 100), _this._pivot = new engine.Vector2(0.5, 0.5), _this._rect = new engine.Rect(-50, -50, 100, 100), _this._alignLeft = 0, _this._alignRight = 0, _this._alignCenter = 0, _this._alignTop = 0, _this._alignBottom = 0, _this._alignMiddle = 0, _this._horizontalAlignment = HorizontalAlignmentMode.None, _this._verticalAlignment = VerticalAlignmentMode.None;
808
+ _this = Transform.call(this, entity) || this, _this._size = _init__size(_this, new engine.Vector2(100, 100)), _this._pivot = _init__pivot(_this, new engine.Vector2(0.5, 0.5)), _this._rect = new engine.Rect(-50, -50, 100, 100), _this._alignLeft = 0, _this._alignRight = 0, _this._alignCenter = 0, _this._alignTop = 0, _this._alignBottom = 0, _this._alignMiddle = 0, _this._horizontalAlignment = HorizontalAlignmentMode.None, _this._verticalAlignment = VerticalAlignmentMode.None;
284
809
  _this._onSizeChanged = _this._onSizeChanged.bind(_this);
285
810
  _this._onPivotChanged = _this._onPivotChanged.bind(_this);
286
811
  // @ts-ignore
@@ -654,24 +1179,19 @@ var SortEntry = function SortEntry() {
654
1179
  ]);
655
1180
  return UITransform;
656
1181
  }(engine.Transform);
657
- __decorate([
658
- engine.ignoreClone
659
- ], UITransform.prototype, "_size", void 0);
660
- __decorate([
661
- engine.ignoreClone
662
- ], UITransform.prototype, "_pivot", void 0);
663
- __decorate([
664
- engine.ignoreClone
665
- ], UITransform.prototype, "_onPositionChanged", null);
666
- __decorate([
667
- engine.ignoreClone
668
- ], UITransform.prototype, "_onWorldPositionChanged", null);
669
- __decorate([
670
- engine.ignoreClone
671
- ], UITransform.prototype, "_onSizeChanged", null);
672
- __decorate([
673
- engine.ignoreClone
674
- ], UITransform.prototype, "_onPivotChanged", null);
1182
+ var ref$5, ref1$5;
1183
+ ref$5 = _apply_decs_2203_r(UITransform, [
1184
+ [
1185
+ engine.ignoreClone,
1186
+ 0,
1187
+ "_size"
1188
+ ],
1189
+ [
1190
+ engine.ignoreClone,
1191
+ 0,
1192
+ "_pivot"
1193
+ ]
1194
+ ], []), ref1$5 = ref$5.e, _init__size = ref1$5[0], _init__pivot = ref1$5[1];
675
1195
  /**
676
1196
  * @internal
677
1197
  * extends TransformModifyFlags
@@ -681,139 +1201,155 @@ __decorate([
681
1201
  return UITransformModifyFlags;
682
1202
  }({});
683
1203
 
684
- exports.RectMask2D = /*#__PURE__*/ function(Component) {
685
- _inherits(RectMask2D, Component);
686
- function RectMask2D(entity) {
1204
+ var _class$3;
1205
+ var _dec$3, _initClass$3, _Component$1;
1206
+ exports.RectMask2D = void 0;
1207
+ _dec$3 = engine.dependentComponents(UITransform, engine.DependentMode.AutoAdd);
1208
+ new (_class$3 = /*#__PURE__*/ function(_identity) {
1209
+ _inherits(_class, _identity);
1210
+ function _class() {
687
1211
  var _this;
688
- _this = Component.call(this, entity) || this, _this._softness = new engine.Vector2(0, 0), _this._alphaClip = false;
689
- _this._onSoftnessChanged = _this._onSoftnessChanged.bind(_this);
690
- // @ts-ignore
691
- _this._softness._onValueChanged = _this._onSoftnessChanged;
1212
+ _this = _identity.apply(this, arguments) || this, _initClass$3();
692
1213
  return _this;
693
1214
  }
694
- var _proto = RectMask2D.prototype;
695
- /**
1215
+ return _class;
1216
+ }(_identity), function() {
1217
+ var RectMask2D = /*#__PURE__*/ function(_superClass) {
1218
+ _inherits(RectMask2D, _superClass);
1219
+ function RectMask2D(entity) {
1220
+ var _this;
1221
+ _this = _superClass.call(this, entity) || this, _this._softness = new engine.Vector2(0, 0), _this._alphaClip = false;
1222
+ _this._onSoftnessChanged = _this._onSoftnessChanged.bind(_this);
1223
+ // @ts-ignore
1224
+ _this._softness._onValueChanged = _this._onSoftnessChanged;
1225
+ return _this;
1226
+ }
1227
+ var _proto = RectMask2D.prototype;
1228
+ /**
696
1229
  * @internal
697
1230
  */ _proto._getWorldRect = function _getWorldRect(out) {
698
- var transform = this.entity.transform;
699
- var _transform_size = transform.size, width = _transform_size.x, height = _transform_size.y;
700
- if (!width || !height) {
701
- return false;
702
- }
703
- var _transform_pivot = transform.pivot, pivotX = _transform_pivot.x, pivotY = _transform_pivot.y;
704
- var left = -width * pivotX;
705
- var right = width * (1 - pivotX);
706
- var bottom = -height * pivotY;
707
- var top = height * (1 - pivotY);
708
- var worldMatrix = transform.worldMatrix;
709
- var corner0 = RectMask2D._tempCorner0;
710
- var corner1 = RectMask2D._tempCorner1;
711
- var corner2 = RectMask2D._tempCorner2;
712
- var corner3 = RectMask2D._tempCorner3;
713
- engine.Vector3.transformCoordinate(corner0.set(left, bottom, 0), worldMatrix, corner0);
714
- engine.Vector3.transformCoordinate(corner1.set(left, top, 0), worldMatrix, corner1);
715
- engine.Vector3.transformCoordinate(corner2.set(right, bottom, 0), worldMatrix, corner2);
716
- engine.Vector3.transformCoordinate(corner3.set(right, top, 0), worldMatrix, corner3);
717
- var minX = Math.min(corner0.x, corner1.x, corner2.x, corner3.x);
718
- var minY = Math.min(corner0.y, corner1.y, corner2.y, corner3.y);
719
- var maxX = Math.max(corner0.x, corner1.x, corner2.x, corner3.x);
720
- var maxY = Math.max(corner0.y, corner1.y, corner2.y, corner3.y);
721
- out.set(minX, minY, maxX, maxY);
722
- return true;
723
- };
724
- /**
1231
+ var transform = this.entity.transform;
1232
+ var _transform_size = transform.size, width = _transform_size.x, height = _transform_size.y;
1233
+ if (!width || !height) {
1234
+ return false;
1235
+ }
1236
+ var _transform_pivot = transform.pivot, pivotX = _transform_pivot.x, pivotY = _transform_pivot.y;
1237
+ var left = -width * pivotX;
1238
+ var right = width * (1 - pivotX);
1239
+ var bottom = -height * pivotY;
1240
+ var top = height * (1 - pivotY);
1241
+ var worldMatrix = transform.worldMatrix;
1242
+ var corner0 = RectMask2D._tempCorner0;
1243
+ var corner1 = RectMask2D._tempCorner1;
1244
+ var corner2 = RectMask2D._tempCorner2;
1245
+ var corner3 = RectMask2D._tempCorner3;
1246
+ engine.Vector3.transformCoordinate(corner0.set(left, bottom, 0), worldMatrix, corner0);
1247
+ engine.Vector3.transformCoordinate(corner1.set(left, top, 0), worldMatrix, corner1);
1248
+ engine.Vector3.transformCoordinate(corner2.set(right, bottom, 0), worldMatrix, corner2);
1249
+ engine.Vector3.transformCoordinate(corner3.set(right, top, 0), worldMatrix, corner3);
1250
+ var minX = Math.min(corner0.x, corner1.x, corner2.x, corner3.x);
1251
+ var minY = Math.min(corner0.y, corner1.y, corner2.y, corner3.y);
1252
+ var maxX = Math.max(corner0.x, corner1.x, corner2.x, corner3.x);
1253
+ var maxY = Math.max(corner0.y, corner1.y, corner2.y, corner3.y);
1254
+ out.set(minX, minY, maxX, maxY);
1255
+ return true;
1256
+ };
1257
+ /**
725
1258
  * @internal
726
1259
  */ _proto._containsWorldPoint = function _containsWorldPoint(worldPoint) {
727
- var worldRect = RectMask2D._tempRect;
728
- if (!this._getWorldRect(worldRect)) {
729
- return false;
730
- }
731
- var x = worldPoint.x, y = worldPoint.y;
732
- return x >= worldRect.x && x <= worldRect.z && y >= worldRect.y && y <= worldRect.w;
733
- };
734
- // @ts-ignore
735
- _proto._onEnableInScene = function _onEnableInScene() {
736
- this.entity._updateUIHierarchyVersion(exports.UICanvas._hierarchyCounter);
737
- };
738
- // @ts-ignore
739
- _proto._onDisableInScene = function _onDisableInScene() {
740
- this.entity._updateUIHierarchyVersion(exports.UICanvas._hierarchyCounter);
741
- };
742
- _proto._onClone = function _onClone(target) {
743
- // RectMask2D extends Component directly, so it has no parent clone hook to call.
744
- var targetSoftness = target._softness;
745
- // @ts-ignore
746
- targetSoftness._onValueChanged = null;
747
- targetSoftness.copyFrom(this._softness);
748
- target._clampSoftness();
1260
+ var worldRect = RectMask2D._tempRect;
1261
+ if (!this._getWorldRect(worldRect)) {
1262
+ return false;
1263
+ }
1264
+ var x = worldPoint.x, y = worldPoint.y;
1265
+ return x >= worldRect.x && x <= worldRect.z && y >= worldRect.y && y <= worldRect.w;
1266
+ };
749
1267
  // @ts-ignore
750
- targetSoftness._onValueChanged = target._onSoftnessChanged;
751
- };
752
- _proto._onDestroy = function _onDestroy() {
1268
+ _proto._onEnableInScene = function _onEnableInScene() {
1269
+ this.entity._updateUIHierarchyVersion(exports.UICanvas._hierarchyCounter);
1270
+ };
753
1271
  // @ts-ignore
754
- this._softness._onValueChanged = null;
755
- this._softness = null;
756
- Component.prototype._onDestroy.call(this);
757
- };
758
- _proto._onSoftnessChanged = function _onSoftnessChanged() {
759
- this._clampSoftness();
760
- };
761
- _proto._clampSoftness = function _clampSoftness() {
762
- var softness = this._softness;
763
- if (softness.x < 0) {
764
- softness.x = 0;
765
- }
766
- if (softness.y < 0) {
767
- softness.y = 0;
768
- }
769
- };
770
- _create_class(RectMask2D, [
771
- {
772
- key: "softness",
773
- get: /**
1272
+ _proto._onDisableInScene = function _onDisableInScene() {
1273
+ this.entity._updateUIHierarchyVersion(exports.UICanvas._hierarchyCounter);
1274
+ };
1275
+ _proto._onClone = function _onClone(target) {
1276
+ // RectMask2D extends Component directly, so it has no parent clone hook to call.
1277
+ var targetSoftness = target._softness;
1278
+ // @ts-ignore
1279
+ targetSoftness._onValueChanged = null;
1280
+ targetSoftness.copyFrom(this._softness);
1281
+ target._clampSoftness();
1282
+ // @ts-ignore
1283
+ targetSoftness._onValueChanged = target._onSoftnessChanged;
1284
+ };
1285
+ _proto._onDestroy = function _onDestroy() {
1286
+ // @ts-ignore
1287
+ this._softness._onValueChanged = null;
1288
+ this._softness = null;
1289
+ _superClass.prototype._onDestroy.call(this);
1290
+ };
1291
+ _proto._onSoftnessChanged = function _onSoftnessChanged() {
1292
+ this._clampSoftness();
1293
+ };
1294
+ _proto._clampSoftness = function _clampSoftness() {
1295
+ var softness = this._softness;
1296
+ if (softness.x < 0) {
1297
+ softness.x = 0;
1298
+ }
1299
+ if (softness.y < 0) {
1300
+ softness.y = 0;
1301
+ }
1302
+ };
1303
+ _create_class(RectMask2D, [
1304
+ {
1305
+ key: "softness",
1306
+ get: /**
774
1307
  * Soft clipping width on X/Y axis in world space.
775
1308
  */ function get() {
776
- return this._softness;
777
- },
778
- set: function set(value) {
779
- var softness = this._softness;
780
- if (softness === value) {
781
- return;
782
- }
783
- if (softness.x !== value.x || softness.y !== value.y) {
784
- softness.copyFrom(value);
785
- this._clampSoftness();
1309
+ return this._softness;
1310
+ },
1311
+ set: function set(value) {
1312
+ var softness = this._softness;
1313
+ if (softness === value) {
1314
+ return;
1315
+ }
1316
+ if (softness.x !== value.x || softness.y !== value.y) {
1317
+ softness.copyFrom(value);
1318
+ this._clampSoftness();
1319
+ }
786
1320
  }
787
- }
788
- },
789
- {
790
- key: "alphaClip",
791
- get: /**
1321
+ },
1322
+ {
1323
+ key: "alphaClip",
1324
+ get: /**
792
1325
  * Whether to enable hard clip (discard) when outside the rect.
793
1326
  */ function get() {
794
- return this._alphaClip;
795
- },
796
- set: function set(value) {
797
- this._alphaClip = value;
1327
+ return this._alphaClip;
1328
+ },
1329
+ set: function set(value) {
1330
+ this._alphaClip = value;
1331
+ }
798
1332
  }
799
- }
800
- ]);
801
- return RectMask2D;
802
- }(engine.Component);
803
- exports.RectMask2D._tempRect = new engine.Vector4();
804
- exports.RectMask2D._tempCorner0 = new engine.Vector3();
805
- exports.RectMask2D._tempCorner1 = new engine.Vector3();
806
- exports.RectMask2D._tempCorner2 = new engine.Vector3();
807
- exports.RectMask2D._tempCorner3 = new engine.Vector3();
808
- exports.RectMask2D = __decorate([
809
- engine.dependentComponents(UITransform, engine.DependentMode.AutoAdd)
810
- ], exports.RectMask2D);
1333
+ ]);
1334
+ return RectMask2D;
1335
+ }(_Component$1 = engine.Component);
1336
+ var ref, ref1;
1337
+ ref = _apply_decs_2203_r(RectMask2D, [], [
1338
+ _dec$3
1339
+ ], _Component$1), ref1 = ref.c, exports.RectMask2D = ref1[0], _initClass$3 = ref1[1];
1340
+ RectMask2D._tempRect = new engine.Vector4();
1341
+ RectMask2D._tempCorner0 = new engine.Vector3();
1342
+ RectMask2D._tempCorner1 = new engine.Vector3();
1343
+ RectMask2D._tempCorner2 = new engine.Vector3();
1344
+ RectMask2D._tempCorner3 = new engine.Vector3();
1345
+ }(), _class$3)();
811
1346
 
1347
+ var /** @internal */ _init__indexInGroup$2, /** @internal */ _init__indexInRootCanvas$3, /** @internal */ _init__globalAlpha, /** @internal */ _init__globalInteractive$1, /** @internal */ _init__rootCanvasListeningEntities$3, /** @internal */ _init__groupListeningEntities$2, /** @internal */ _init__isRootCanvasDirty$3, /** @internal */ _init__isGroupDirty$2, /** @internal */ _init__groupDirtyFlags;
812
1348
  var UIGroup = /*#__PURE__*/ function(Component) {
813
1349
  _inherits(UIGroup, Component);
814
1350
  function UIGroup(entity) {
815
1351
  var _this;
816
- _this = Component.call(this, entity) || this, /** @internal */ _this._indexInGroup = -1, /** @internal */ _this._indexInRootCanvas = -1, /** @internal */ _this._disorderedElements = new engine.DisorderedArray(), /** @internal */ _this._globalAlpha = 1, /** @internal */ _this._globalInteractive = true, _this._alpha = 1, _this._interactive = true, _this._ignoreParentGroup = false, /** @internal */ _this._rootCanvasListeningEntities = [], /** @internal */ _this._groupListeningEntities = [], /** @internal */ _this._isRootCanvasDirty = false, /** @internal */ _this._isGroupDirty = false, /** @internal */ _this._groupDirtyFlags = 0;
1352
+ _this = Component.call(this, entity) || this, _this._indexInGroup = _init__indexInGroup$2(_this, -1), _this._indexInRootCanvas = _init__indexInRootCanvas$3(_this, -1), /** @internal */ _this._disorderedElements = new engine.DisorderedArray(), _this._globalAlpha = _init__globalAlpha(_this, 1), _this._globalInteractive = _init__globalInteractive$1(_this, true), _this._alpha = 1, _this._interactive = true, _this._ignoreParentGroup = false, _this._rootCanvasListeningEntities = _init__rootCanvasListeningEntities$3(_this, []), _this._groupListeningEntities = _init__groupListeningEntities$2(_this, []), _this._isRootCanvasDirty = _init__isRootCanvasDirty$3(_this, false), _this._isGroupDirty = _init__isGroupDirty$2(_this, false), _this._groupDirtyFlags = _init__groupDirtyFlags(_this, 0);
817
1353
  _this._rootCanvasListener = _this._rootCanvasListener.bind(_this);
818
1354
  _this._groupListener = _this._groupListener.bind(_this);
819
1355
  return _this;
@@ -965,39 +1501,54 @@ var UIGroup = /*#__PURE__*/ function(Component) {
965
1501
  ]);
966
1502
  return UIGroup;
967
1503
  }(engine.Component);
968
- __decorate([
969
- engine.ignoreClone
970
- ], UIGroup.prototype, "_indexInGroup", void 0);
971
- __decorate([
972
- engine.ignoreClone
973
- ], UIGroup.prototype, "_indexInRootCanvas", void 0);
974
- __decorate([
975
- engine.ignoreClone
976
- ], UIGroup.prototype, "_globalAlpha", void 0);
977
- __decorate([
978
- engine.ignoreClone
979
- ], UIGroup.prototype, "_globalInteractive", void 0);
980
- __decorate([
981
- engine.ignoreClone
982
- ], UIGroup.prototype, "_rootCanvasListeningEntities", void 0);
983
- __decorate([
984
- engine.ignoreClone
985
- ], UIGroup.prototype, "_groupListeningEntities", void 0);
986
- __decorate([
987
- engine.ignoreClone
988
- ], UIGroup.prototype, "_isRootCanvasDirty", void 0);
989
- __decorate([
990
- engine.ignoreClone
991
- ], UIGroup.prototype, "_isGroupDirty", void 0);
992
- __decorate([
993
- engine.ignoreClone
994
- ], UIGroup.prototype, "_groupDirtyFlags", void 0);
995
- __decorate([
996
- engine.ignoreClone
997
- ], UIGroup.prototype, "_groupListener", null);
998
- __decorate([
999
- engine.ignoreClone
1000
- ], UIGroup.prototype, "_rootCanvasListener", null);
1504
+ var ref$4, ref1$4;
1505
+ ref$4 = _apply_decs_2203_r(UIGroup, [
1506
+ [
1507
+ engine.ignoreClone,
1508
+ 0,
1509
+ "_indexInGroup"
1510
+ ],
1511
+ [
1512
+ engine.ignoreClone,
1513
+ 0,
1514
+ "_indexInRootCanvas"
1515
+ ],
1516
+ [
1517
+ engine.ignoreClone,
1518
+ 0,
1519
+ "_globalAlpha"
1520
+ ],
1521
+ [
1522
+ engine.ignoreClone,
1523
+ 0,
1524
+ "_globalInteractive"
1525
+ ],
1526
+ [
1527
+ engine.ignoreClone,
1528
+ 0,
1529
+ "_rootCanvasListeningEntities"
1530
+ ],
1531
+ [
1532
+ engine.ignoreClone,
1533
+ 0,
1534
+ "_groupListeningEntities"
1535
+ ],
1536
+ [
1537
+ engine.ignoreClone,
1538
+ 0,
1539
+ "_isRootCanvasDirty"
1540
+ ],
1541
+ [
1542
+ engine.ignoreClone,
1543
+ 0,
1544
+ "_isGroupDirty"
1545
+ ],
1546
+ [
1547
+ engine.ignoreClone,
1548
+ 0,
1549
+ "_groupDirtyFlags"
1550
+ ]
1551
+ ], []), ref1$4 = ref$4.e, _init__indexInGroup$2 = ref1$4[0], _init__indexInRootCanvas$3 = ref1$4[1], _init__globalAlpha = ref1$4[2], _init__globalInteractive$1 = ref1$4[3], _init__rootCanvasListeningEntities$3 = ref1$4[4], _init__groupListeningEntities$2 = ref1$4[5], _init__isRootCanvasDirty$3 = ref1$4[6], _init__isGroupDirty$2 = ref1$4[7], _init__groupDirtyFlags = ref1$4[8];
1001
1552
  var GroupModifyFlags = /*#__PURE__*/ function(GroupModifyFlags) {
1002
1553
  GroupModifyFlags[GroupModifyFlags["None"] = 0] = "None";
1003
1554
  GroupModifyFlags[GroupModifyFlags["GlobalAlpha"] = 1] = "GlobalAlpha";
@@ -1006,409 +1557,440 @@ var GroupModifyFlags = /*#__PURE__*/ function(GroupModifyFlags) {
1006
1557
  return GroupModifyFlags;
1007
1558
  }({});
1008
1559
 
1009
- exports.UIRenderer = /*#__PURE__*/ function(Renderer) {
1010
- _inherits(UIRenderer, Renderer);
1011
- function UIRenderer(entity) {
1560
+ var _class$2;
1561
+ var _dec$2, _initClass$2, _Renderer, /** @internal */ _init__indexInRootCanvas$2, /** @internal */ _init__isRootCanvasDirty$2, /** @internal */ _init__rootCanvasListeningEntities$2, /** @internal */ _init__indexInGroup$1, /** @internal */ _init__isGroupDirty$1, /** @internal */ _init__groupListeningEntities$1, /** @internal */ _init__subChunk, /** @internal */ _init__rectMasks, /** @internal */ _init__rectMaskRect, /** @internal */ _init__rectMaskEnabled, /** @internal */ _init__rectMaskSoftness, /** @internal */ _init__rectMaskHardClip;
1562
+ exports.UIRenderer = void 0;
1563
+ _dec$2 = engine.dependentComponents(UITransform, engine.DependentMode.AutoAdd);
1564
+ new (_class$2 = /*#__PURE__*/ function(_identity) {
1565
+ _inherits(_class, _identity);
1566
+ function _class() {
1012
1567
  var _this;
1013
- _this = Renderer.call(this, entity) || this, /**
1014
- * Custom boundary for raycast detection.
1015
- * @remarks this is based on `this.entity.transform`.
1016
- */ _this.raycastPadding = new engine.Vector4(0, 0, 0, 0), /** @internal */ _this._indexInRootCanvas = -1, /** @internal */ _this._isRootCanvasDirty = false, /** @internal */ _this._rootCanvasListeningEntities = [], /** @internal */ _this._indexInGroup = -1, /** @internal */ _this._isGroupDirty = false, /** @internal */ _this._groupListeningEntities = [], /** @internal */ _this._rectMasks = [], /** @internal */ _this._rectMaskRect = new engine.Vector4(), /** @internal */ _this._rectMaskEnabled = false, /** @internal */ _this._rectMaskSoftness = new engine.Vector4(), /** @internal */ _this._rectMaskHardClip = false, _this._raycastEnabled = false, _this._color = new engine.Color(1, 1, 1, 1);
1017
- _this._dirtyUpdateFlag = engine.RendererUpdateFlags.WorldVolume | 2;
1018
- _this._onColorChanged = _this._onColorChanged.bind(_this);
1019
- //@ts-ignore
1020
- _this._color._onValueChanged = _this._onColorChanged;
1021
- _this._groupListener = _this._groupListener.bind(_this);
1022
- _this._rootCanvasListener = _this._rootCanvasListener.bind(_this);
1023
- _this.shaderData.setFloat(UIRenderer._rectClipEnabledProperty, 0);
1024
- _this.shaderData.setVector4(UIRenderer._rectClipSoftnessProperty, _this._rectMaskSoftness);
1025
- _this.shaderData.setFloat(UIRenderer._rectClipHardClipProperty, 0);
1568
+ _this = _identity.apply(this, arguments) || this, _initClass$2();
1026
1569
  return _this;
1027
1570
  }
1028
- var _proto = UIRenderer.prototype;
1029
- // @ts-ignore
1030
- _proto._canBatch = function _canBatch(preElement, curElement) {
1031
- return engine.VertexMergeBatcher.canBatchSprite(preElement, curElement);
1032
- };
1033
- // @ts-ignore
1034
- _proto._batch = function _batch(preElement, curElement) {
1035
- engine.VertexMergeBatcher.batch(preElement, curElement);
1036
- };
1037
- // @ts-ignore
1038
- _proto._updateTransformShaderData = function _updateTransformShaderData(context, onlyMVP) {
1571
+ return _class;
1572
+ }(_identity), function() {
1573
+ var UIRenderer = /*#__PURE__*/ function(_superClass) {
1574
+ _inherits(UIRenderer, _superClass);
1575
+ function UIRenderer(entity) {
1576
+ var _this;
1577
+ _this = _superClass.call(this, entity) || this, /**
1578
+ * Custom boundary for raycast detection.
1579
+ * @remarks this is based on `this.entity.transform`.
1580
+ */ _this.raycastPadding = new engine.Vector4(0, 0, 0, 0), _this._indexInRootCanvas = _init__indexInRootCanvas$2(_this, -1), _this._isRootCanvasDirty = _init__isRootCanvasDirty$2(_this, false), _this._rootCanvasListeningEntities = _init__rootCanvasListeningEntities$2(_this, []), _this._indexInGroup = _init__indexInGroup$1(_this, -1), _this._isGroupDirty = _init__isGroupDirty$1(_this, false), _this._groupListeningEntities = _init__groupListeningEntities$1(_this, []), _this._subChunk = _init__subChunk(_this), _this._rectMasks = _init__rectMasks(_this, []), _this._rectMaskRect = _init__rectMaskRect(_this, new engine.Vector4()), _this._rectMaskEnabled = _init__rectMaskEnabled(_this, false), _this._rectMaskSoftness = _init__rectMaskSoftness(_this, new engine.Vector4()), _this._rectMaskHardClip = _init__rectMaskHardClip(_this, false), _this._raycastEnabled = false, _this._color = new engine.Color(1, 1, 1, 1);
1581
+ _this._dirtyUpdateFlag = engine.RendererUpdateFlags.WorldVolume | 2;
1582
+ _this._onColorChanged = _this._onColorChanged.bind(_this);
1583
+ //@ts-ignore
1584
+ _this._color._onValueChanged = _this._onColorChanged;
1585
+ _this._groupListener = _this._groupListener.bind(_this);
1586
+ _this._rootCanvasListener = _this._rootCanvasListener.bind(_this);
1587
+ _this.shaderData.setFloat(UIRenderer._rectClipEnabledProperty, 0);
1588
+ _this.shaderData.setVector4(UIRenderer._rectClipSoftnessProperty, _this._rectMaskSoftness);
1589
+ _this.shaderData.setFloat(UIRenderer._rectClipHardClipProperty, 0);
1590
+ return _this;
1591
+ }
1592
+ var _proto = UIRenderer.prototype;
1039
1593
  // @ts-ignore
1040
- this._updateWorldSpaceTransformShaderData(context, onlyMVP);
1041
- };
1042
- // @ts-ignore
1043
- _proto._prepareRender = function _prepareRender(context) {
1044
- // Update once per frame per renderer, not influenced by batched
1045
- if (this._renderFrameCount !== this.engine.time.frameCount) {
1046
- this._update(context);
1047
- }
1048
- this._updateRectMaskClipState();
1049
- this._render(context);
1050
- // union camera global macro and renderer macro.
1051
- engine.ShaderMacroCollection.unionCollection(context.camera._globalShaderMacro, // @ts-ignore
1052
- this.shaderData._macroCollection, //@ts-ignore
1053
- this._globalShaderMacro);
1054
- };
1055
- // @ts-ignore
1056
- _proto._onEnableInScene = function _onEnableInScene() {
1594
+ _proto._canBatch = function _canBatch(preElement, curElement) {
1595
+ return engine.VertexMergeBatcher.canBatchSprite(preElement, curElement);
1596
+ };
1057
1597
  // @ts-ignore
1058
- this._overrideUpdate && this.scene._componentsManager.addOnUpdateRenderers(this);
1059
- this.entity._updateUIHierarchyVersion(exports.UICanvas._hierarchyCounter);
1060
- Utils.setRootCanvasDirty(this);
1061
- Utils.setGroupDirty(this);
1062
- };
1063
- // @ts-ignore
1064
- _proto._onDisableInScene = function _onDisableInScene() {
1598
+ _proto._batch = function _batch(preElement, curElement) {
1599
+ engine.VertexMergeBatcher.batch(preElement, curElement);
1600
+ };
1065
1601
  // @ts-ignore
1066
- this._overrideUpdate && this.scene._componentsManager.removeOnUpdateRenderers(this);
1067
- this.entity._updateUIHierarchyVersion(exports.UICanvas._hierarchyCounter);
1068
- Utils.cleanRootCanvas(this);
1069
- Utils.cleanGroup(this);
1070
- };
1071
- /**
1602
+ _proto._updateTransformShaderData = function _updateTransformShaderData(context, onlyMVP) {
1603
+ // @ts-ignore
1604
+ this._updateWorldSpaceTransformShaderData(context, onlyMVP);
1605
+ };
1606
+ // @ts-ignore
1607
+ _proto._prepareRender = function _prepareRender(context) {
1608
+ // Update once per frame per renderer, not influenced by batched
1609
+ if (this._renderFrameCount !== this.engine.time.frameCount) {
1610
+ this._update(context);
1611
+ }
1612
+ this._updateRectMaskClipState();
1613
+ this._render(context);
1614
+ // union camera global macro and renderer macro.
1615
+ engine.ShaderMacroCollection.unionCollection(context.camera._globalShaderMacro, // @ts-ignore
1616
+ this.shaderData._macroCollection, //@ts-ignore
1617
+ this._globalShaderMacro);
1618
+ };
1619
+ // @ts-ignore
1620
+ _proto._onEnableInScene = function _onEnableInScene() {
1621
+ // @ts-ignore
1622
+ this._overrideUpdate && this.scene._componentsManager.addOnUpdateRenderers(this);
1623
+ this.entity._updateUIHierarchyVersion(exports.UICanvas._hierarchyCounter);
1624
+ Utils.setRootCanvasDirty(this);
1625
+ Utils.setGroupDirty(this);
1626
+ };
1627
+ // @ts-ignore
1628
+ _proto._onDisableInScene = function _onDisableInScene() {
1629
+ // @ts-ignore
1630
+ this._overrideUpdate && this.scene._componentsManager.removeOnUpdateRenderers(this);
1631
+ this.entity._updateUIHierarchyVersion(exports.UICanvas._hierarchyCounter);
1632
+ Utils.cleanRootCanvas(this);
1633
+ Utils.cleanGroup(this);
1634
+ };
1635
+ /**
1072
1636
  * @internal
1073
1637
  */ _proto._getGlobalAlpha = function _getGlobalAlpha() {
1074
- var _this__getGroup;
1075
- var _this__getGroup__getGlobalAlpha;
1076
- return (_this__getGroup__getGlobalAlpha = (_this__getGroup = this._getGroup()) == null ? void 0 : _this__getGroup._getGlobalAlpha()) != null ? _this__getGroup__getGlobalAlpha : 1;
1077
- };
1078
- /**
1638
+ var _this__getGroup;
1639
+ var _this__getGroup__getGlobalAlpha;
1640
+ return (_this__getGroup__getGlobalAlpha = (_this__getGroup = this._getGroup()) == null ? void 0 : _this__getGroup._getGlobalAlpha()) != null ? _this__getGroup__getGlobalAlpha : 1;
1641
+ };
1642
+ /**
1079
1643
  * @internal
1080
1644
  */ _proto._getRootCanvas = function _getRootCanvas() {
1081
- this._isRootCanvasDirty && Utils.setRootCanvas(this, Utils.searchRootCanvasInParents(this));
1082
- return this._rootCanvas;
1083
- };
1084
- /**
1645
+ this._isRootCanvasDirty && Utils.setRootCanvas(this, Utils.searchRootCanvasInParents(this));
1646
+ return this._rootCanvas;
1647
+ };
1648
+ /**
1085
1649
  * @internal
1086
1650
  */ _proto._getGroup = function _getGroup() {
1087
- this._isGroupDirty && Utils.setGroup(this, Utils.searchGroupInParents(this));
1088
- return this._group;
1089
- };
1090
- /**
1651
+ this._isGroupDirty && Utils.setGroup(this, Utils.searchGroupInParents(this));
1652
+ return this._group;
1653
+ };
1654
+ /**
1091
1655
  * @internal
1092
1656
  */ _proto._groupListener = function _groupListener(flag) {
1093
- if (flag === engine.EntityModifyFlags.Parent || flag === EntityUIModifyFlags.GroupEnableInScene) {
1094
- Utils.setGroupDirty(this);
1095
- }
1096
- };
1097
- /**
1657
+ if (flag === engine.EntityModifyFlags.Parent || flag === EntityUIModifyFlags.GroupEnableInScene) {
1658
+ Utils.setGroupDirty(this);
1659
+ }
1660
+ };
1661
+ /**
1098
1662
  * @internal
1099
1663
  */ _proto._rootCanvasListener = function _rootCanvasListener(flag, entity) {
1100
- switch(flag){
1101
- case engine.EntityModifyFlags.Parent:
1102
- Utils.setRootCanvasDirty(this);
1103
- Utils.setGroupDirty(this);
1104
- case engine.EntityModifyFlags.Child:
1105
- entity._updateUIHierarchyVersion(exports.UICanvas._hierarchyCounter);
1106
- break;
1107
- }
1108
- };
1109
- /**
1664
+ switch(flag){
1665
+ case engine.EntityModifyFlags.Parent:
1666
+ Utils.setRootCanvasDirty(this);
1667
+ Utils.setGroupDirty(this);
1668
+ case engine.EntityModifyFlags.Child:
1669
+ entity._updateUIHierarchyVersion(exports.UICanvas._hierarchyCounter);
1670
+ break;
1671
+ }
1672
+ };
1673
+ /**
1110
1674
  * @internal
1111
1675
  */ _proto._onGroupModify = function _onGroupModify(flags) {
1112
- if (flags & GroupModifyFlags.GlobalAlpha) {
1676
+ if (flags & GroupModifyFlags.GlobalAlpha) {
1677
+ this._dirtyUpdateFlag |= 2;
1678
+ }
1679
+ };
1680
+ _proto._onColorChanged = function _onColorChanged() {
1113
1681
  this._dirtyUpdateFlag |= 2;
1114
- }
1115
- };
1116
- _proto._onColorChanged = function _onColorChanged() {
1117
- this._dirtyUpdateFlag |= 2;
1118
- };
1119
- /**
1682
+ };
1683
+ /**
1120
1684
  * @internal
1121
1685
  */ _proto._getChunkManager = function _getChunkManager() {
1122
- // @ts-ignore
1123
- return this.engine._batcherManager.primitiveChunkManagerUI;
1124
- };
1125
- /**
1686
+ // @ts-ignore
1687
+ return this.engine._batcherManager.primitiveChunkManagerUI;
1688
+ };
1689
+ /**
1126
1690
  * @internal
1127
1691
  */ _proto._setRectMasks = function _setRectMasks(rectMasks, count) {
1128
- var targetMasks = this._rectMasks;
1129
- targetMasks.length = count;
1130
- for(var i = 0; i < count; i++){
1131
- targetMasks[i] = rectMasks[i];
1132
- }
1133
- };
1134
- /**
1692
+ var targetMasks = this._rectMasks;
1693
+ targetMasks.length = count;
1694
+ for(var i = 0; i < count; i++){
1695
+ targetMasks[i] = rectMasks[i];
1696
+ }
1697
+ };
1698
+ /**
1135
1699
  * @internal
1136
1700
  */ _proto._raycast = function _raycast(ray, out, distance) {
1137
- if (distance === void 0) distance = Number.MAX_SAFE_INTEGER;
1138
- var plane = UIRenderer._tempPlane;
1139
- var transform = this._transformEntity.transform;
1140
- var normal = plane.normal.copyFrom(transform.worldForward);
1141
- plane.distance = -engine.Vector3.dot(normal, transform.worldPosition);
1142
- var curDistance = ray.intersectPlane(plane);
1143
- if (curDistance >= 0 && curDistance < distance) {
1144
- var hitPointWorld = ray.getPoint(curDistance, UIRenderer._tempVec30);
1145
- var worldMatrixInv = UIRenderer._tempMat;
1146
- engine.Matrix.invert(transform.worldMatrix, worldMatrixInv);
1147
- var localPosition = UIRenderer._tempVec31;
1148
- engine.Vector3.transformCoordinate(hitPointWorld, worldMatrixInv, localPosition);
1149
- if (this._hitTest(localPosition) && this._isRaycastVisibleByRectMask(hitPointWorld) && this._isRaycastVisibleByMask(hitPointWorld)) {
1150
- out.component = this;
1151
- out.distance = curDistance;
1152
- out.entity = this.entity;
1153
- out.normal.copyFrom(normal);
1154
- out.point.copyFrom(hitPointWorld);
1701
+ if (distance === void 0) distance = Number.MAX_SAFE_INTEGER;
1702
+ var plane = UIRenderer._tempPlane;
1703
+ var transform = this._transformEntity.transform;
1704
+ var normal = plane.normal.copyFrom(transform.worldForward);
1705
+ plane.distance = -engine.Vector3.dot(normal, transform.worldPosition);
1706
+ var curDistance = ray.intersectPlane(plane);
1707
+ if (curDistance >= 0 && curDistance < distance) {
1708
+ var hitPointWorld = ray.getPoint(curDistance, UIRenderer._tempVec30);
1709
+ var worldMatrixInv = UIRenderer._tempMat;
1710
+ engine.Matrix.invert(transform.worldMatrix, worldMatrixInv);
1711
+ var localPosition = UIRenderer._tempVec31;
1712
+ engine.Vector3.transformCoordinate(hitPointWorld, worldMatrixInv, localPosition);
1713
+ if (this._hitTest(localPosition) && this._isRaycastVisibleByRectMask(hitPointWorld) && this._isRaycastVisibleByMask(hitPointWorld)) {
1714
+ out.component = this;
1715
+ out.distance = curDistance;
1716
+ out.entity = this.entity;
1717
+ out.normal.copyFrom(normal);
1718
+ out.point.copyFrom(hitPointWorld);
1719
+ return true;
1720
+ }
1721
+ }
1722
+ return false;
1723
+ };
1724
+ _proto._hitTest = function _hitTest(localPosition) {
1725
+ var x = localPosition.x, y = localPosition.y;
1726
+ var uiTransform = this._transformEntity.transform;
1727
+ var _uiTransform_size = uiTransform.size, width = _uiTransform_size.x, height = _uiTransform_size.y;
1728
+ var _uiTransform_pivot = uiTransform.pivot, pivotX = _uiTransform_pivot.x, pivotY = _uiTransform_pivot.y;
1729
+ var _this_raycastPadding = this.raycastPadding, paddingLeft = _this_raycastPadding.x, paddingBottom = _this_raycastPadding.y, paddingRight = _this_raycastPadding.z, paddingTop = _this_raycastPadding.w;
1730
+ return x >= -width * pivotX + paddingLeft && x <= width * (1 - pivotX) - paddingRight && y >= -height * pivotY + paddingTop && y <= height * (1 - pivotY) - paddingBottom;
1731
+ };
1732
+ _proto._isRaycastVisibleByMask = function _isRaycastVisibleByMask(hitPointWorld) {
1733
+ var maskInteraction = this._maskInteraction;
1734
+ if (maskInteraction === engine.SpriteMaskInteraction.None) {
1155
1735
  return true;
1156
1736
  }
1157
- }
1158
- return false;
1159
- };
1160
- _proto._hitTest = function _hitTest(localPosition) {
1161
- var x = localPosition.x, y = localPosition.y;
1162
- var uiTransform = this._transformEntity.transform;
1163
- var _uiTransform_size = uiTransform.size, width = _uiTransform_size.x, height = _uiTransform_size.y;
1164
- var _uiTransform_pivot = uiTransform.pivot, pivotX = _uiTransform_pivot.x, pivotY = _uiTransform_pivot.y;
1165
- var _this_raycastPadding = this.raycastPadding, paddingLeft = _this_raycastPadding.x, paddingBottom = _this_raycastPadding.y, paddingRight = _this_raycastPadding.z, paddingTop = _this_raycastPadding.w;
1166
- return x >= -width * pivotX + paddingLeft && x <= width * (1 - pivotX) - paddingRight && y >= -height * pivotY + paddingTop && y <= height * (1 - pivotY) - paddingBottom;
1167
- };
1168
- _proto._isRaycastVisibleByMask = function _isRaycastVisibleByMask(hitPointWorld) {
1169
- var maskInteraction = this._maskInteraction;
1170
- if (maskInteraction === engine.SpriteMaskInteraction.None) {
1737
+ // @ts-ignore
1738
+ return this.scene._maskManager.isVisibleByMask(maskInteraction, this._maskLayer, hitPointWorld);
1739
+ };
1740
+ _proto._isRaycastVisibleByRectMask = function _isRaycastVisibleByRectMask(hitPointWorld) {
1741
+ var rectMasks = this._rectMasks;
1742
+ for(var i = 0, n = rectMasks.length; i < n; i++){
1743
+ var rectMask = rectMasks[i];
1744
+ if (!rectMask.enabled || !rectMask.entity.isActiveInHierarchy) {
1745
+ continue;
1746
+ }
1747
+ if (!rectMask._containsWorldPoint(hitPointWorld)) {
1748
+ return false;
1749
+ }
1750
+ }
1171
1751
  return true;
1172
- }
1173
- // @ts-ignore
1174
- return this.scene._maskManager.isVisibleByMask(maskInteraction, this._maskLayer, hitPointWorld);
1175
- };
1176
- _proto._isRaycastVisibleByRectMask = function _isRaycastVisibleByRectMask(hitPointWorld) {
1177
- var rectMasks = this._rectMasks;
1178
- for(var i = 0, n = rectMasks.length; i < n; i++){
1179
- var rectMask = rectMasks[i];
1180
- if (!rectMask.enabled || !rectMask.entity.isActiveInHierarchy) {
1181
- continue;
1182
- }
1183
- if (!rectMask._containsWorldPoint(hitPointWorld)) {
1184
- return false;
1752
+ };
1753
+ _proto._updateRectMaskClipState = function _updateRectMaskClipState() {
1754
+ var rectMasks = this._rectMasks;
1755
+ var count = rectMasks.length;
1756
+ if (count <= 0) {
1757
+ this._resetRectMaskClipState();
1758
+ return;
1185
1759
  }
1186
- }
1187
- return true;
1188
- };
1189
- _proto._updateRectMaskClipState = function _updateRectMaskClipState() {
1190
- var rectMasks = this._rectMasks;
1191
- var count = rectMasks.length;
1192
- if (count <= 0) {
1193
- this._resetRectMaskClipState();
1194
- return;
1195
- }
1196
- var minX = Number.NEGATIVE_INFINITY;
1197
- var minY = Number.NEGATIVE_INFINITY;
1198
- var maxX = Number.POSITIVE_INFINITY;
1199
- var maxY = Number.POSITIVE_INFINITY;
1200
- var clipSoftnessLeft = 0;
1201
- var clipSoftnessBottom = 0;
1202
- var clipSoftnessRight = 0;
1203
- var clipSoftnessTop = 0;
1204
- var clipHardClip = false;
1205
- var hasActiveMask = false;
1206
- var tempRect = UIRenderer._tempRect;
1207
- for(var i = 0; i < count; i++){
1208
- var rectMask = rectMasks[i];
1209
- if (!rectMask.enabled || !rectMask.entity.isActiveInHierarchy) {
1210
- continue;
1211
- }
1212
- hasActiveMask = true;
1213
- var softness = rectMask.softness;
1214
- if (!clipHardClip && rectMask.alphaClip) {
1215
- clipHardClip = true;
1216
- }
1217
- if (!rectMask._getWorldRect(tempRect)) {
1760
+ var minX = Number.NEGATIVE_INFINITY;
1761
+ var minY = Number.NEGATIVE_INFINITY;
1762
+ var maxX = Number.POSITIVE_INFINITY;
1763
+ var maxY = Number.POSITIVE_INFINITY;
1764
+ var clipSoftnessLeft = 0;
1765
+ var clipSoftnessBottom = 0;
1766
+ var clipSoftnessRight = 0;
1767
+ var clipSoftnessTop = 0;
1768
+ var clipHardClip = false;
1769
+ var hasActiveMask = false;
1770
+ var tempRect = UIRenderer._tempRect;
1771
+ for(var i = 0; i < count; i++){
1772
+ var rectMask = rectMasks[i];
1773
+ if (!rectMask.enabled || !rectMask.entity.isActiveInHierarchy) {
1774
+ continue;
1775
+ }
1776
+ hasActiveMask = true;
1777
+ var softness = rectMask.softness;
1778
+ if (!clipHardClip && rectMask.alphaClip) {
1779
+ clipHardClip = true;
1780
+ }
1781
+ if (!rectMask._getWorldRect(tempRect)) {
1782
+ minX = 1;
1783
+ minY = 1;
1784
+ maxX = 0;
1785
+ maxY = 0;
1786
+ break;
1787
+ }
1788
+ if (tempRect.x > minX) {
1789
+ minX = tempRect.x;
1790
+ clipSoftnessLeft = softness.x;
1791
+ }
1792
+ if (tempRect.y > minY) {
1793
+ minY = tempRect.y;
1794
+ clipSoftnessBottom = softness.y;
1795
+ }
1796
+ if (tempRect.z < maxX) {
1797
+ maxX = tempRect.z;
1798
+ clipSoftnessRight = softness.x;
1799
+ }
1800
+ if (tempRect.w < maxY) {
1801
+ maxY = tempRect.w;
1802
+ clipSoftnessTop = softness.y;
1803
+ }
1804
+ }
1805
+ if (!hasActiveMask) {
1806
+ this._resetRectMaskClipState();
1807
+ return;
1808
+ }
1809
+ if (minX >= maxX || minY >= maxY) {
1218
1810
  minX = 1;
1219
1811
  minY = 1;
1220
1812
  maxX = 0;
1221
1813
  maxY = 0;
1222
- break;
1814
+ clipSoftnessLeft = 0;
1815
+ clipSoftnessBottom = 0;
1816
+ clipSoftnessRight = 0;
1817
+ clipSoftnessTop = 0;
1223
1818
  }
1224
- if (tempRect.x > minX) {
1225
- minX = tempRect.x;
1226
- clipSoftnessLeft = softness.x;
1819
+ var rectMaskRect = this._rectMaskRect;
1820
+ if (rectMaskRect.x !== minX || rectMaskRect.y !== minY || rectMaskRect.z !== maxX || rectMaskRect.w !== maxY) {
1821
+ rectMaskRect.set(minX, minY, maxX, maxY);
1822
+ this.shaderData.setVector4(UIRenderer._rectClipRectProperty, rectMaskRect);
1227
1823
  }
1228
- if (tempRect.y > minY) {
1229
- minY = tempRect.y;
1230
- clipSoftnessBottom = softness.y;
1824
+ var rectMaskSoftness = this._rectMaskSoftness;
1825
+ if (rectMaskSoftness.x !== clipSoftnessLeft || rectMaskSoftness.y !== clipSoftnessBottom || rectMaskSoftness.z !== clipSoftnessRight || rectMaskSoftness.w !== clipSoftnessTop) {
1826
+ rectMaskSoftness.set(clipSoftnessLeft, clipSoftnessBottom, clipSoftnessRight, clipSoftnessTop);
1827
+ this.shaderData.setVector4(UIRenderer._rectClipSoftnessProperty, rectMaskSoftness);
1231
1828
  }
1232
- if (tempRect.z < maxX) {
1233
- maxX = tempRect.z;
1234
- clipSoftnessRight = softness.x;
1829
+ if (this._rectMaskHardClip !== clipHardClip) {
1830
+ this._rectMaskHardClip = clipHardClip;
1831
+ this.shaderData.setFloat(UIRenderer._rectClipHardClipProperty, clipHardClip ? 1 : 0);
1235
1832
  }
1236
- if (tempRect.w < maxY) {
1237
- maxY = tempRect.w;
1238
- clipSoftnessTop = softness.y;
1833
+ if (!this._rectMaskEnabled) {
1834
+ this._rectMaskEnabled = true;
1835
+ this.shaderData.setFloat(UIRenderer._rectClipEnabledProperty, 1);
1239
1836
  }
1240
- }
1241
- if (!hasActiveMask) {
1242
- this._resetRectMaskClipState();
1243
- return;
1244
- }
1245
- if (minX >= maxX || minY >= maxY) {
1246
- minX = 1;
1247
- minY = 1;
1248
- maxX = 0;
1249
- maxY = 0;
1250
- clipSoftnessLeft = 0;
1251
- clipSoftnessBottom = 0;
1252
- clipSoftnessRight = 0;
1253
- clipSoftnessTop = 0;
1254
- }
1255
- var rectMaskRect = this._rectMaskRect;
1256
- if (rectMaskRect.x !== minX || rectMaskRect.y !== minY || rectMaskRect.z !== maxX || rectMaskRect.w !== maxY) {
1257
- rectMaskRect.set(minX, minY, maxX, maxY);
1258
- this.shaderData.setVector4(UIRenderer._rectClipRectProperty, rectMaskRect);
1259
- }
1260
- var rectMaskSoftness = this._rectMaskSoftness;
1261
- if (rectMaskSoftness.x !== clipSoftnessLeft || rectMaskSoftness.y !== clipSoftnessBottom || rectMaskSoftness.z !== clipSoftnessRight || rectMaskSoftness.w !== clipSoftnessTop) {
1262
- rectMaskSoftness.set(clipSoftnessLeft, clipSoftnessBottom, clipSoftnessRight, clipSoftnessTop);
1263
- this.shaderData.setVector4(UIRenderer._rectClipSoftnessProperty, rectMaskSoftness);
1264
- }
1265
- if (this._rectMaskHardClip !== clipHardClip) {
1266
- this._rectMaskHardClip = clipHardClip;
1267
- this.shaderData.setFloat(UIRenderer._rectClipHardClipProperty, clipHardClip ? 1 : 0);
1268
- }
1269
- if (!this._rectMaskEnabled) {
1270
- this._rectMaskEnabled = true;
1271
- this.shaderData.setFloat(UIRenderer._rectClipEnabledProperty, 1);
1272
- }
1273
- };
1274
- _proto._resetRectMaskClipState = function _resetRectMaskClipState() {
1275
- if (this._rectMaskEnabled) {
1276
- this._rectMaskEnabled = false;
1277
- this.shaderData.setFloat(UIRenderer._rectClipEnabledProperty, 0);
1278
- }
1279
- var rectMaskSoftness = this._rectMaskSoftness;
1280
- if (rectMaskSoftness.x !== 0 || rectMaskSoftness.y !== 0 || rectMaskSoftness.z !== 0 || rectMaskSoftness.w !== 0) {
1281
- rectMaskSoftness.set(0, 0, 0, 0);
1282
- this.shaderData.setVector4(UIRenderer._rectClipSoftnessProperty, rectMaskSoftness);
1283
- }
1284
- if (this._rectMaskHardClip) {
1285
- this._rectMaskHardClip = false;
1286
- this.shaderData.setFloat(UIRenderer._rectClipHardClipProperty, 0);
1287
- }
1288
- };
1289
- _proto._onDestroy = function _onDestroy() {
1290
- if (this._subChunk) {
1291
- this._getChunkManager().freeSubChunk(this._subChunk);
1292
- this._subChunk = null;
1293
- }
1294
- Renderer.prototype._onDestroy.call(this);
1295
- //@ts-ignore
1296
- this._color._onValueChanged = null;
1297
- this._color = null;
1298
- this._rectMasks = null;
1299
- this._rectMaskSoftness = null;
1300
- };
1301
- _create_class(UIRenderer, [
1302
- {
1303
- key: "color",
1304
- get: /**
1837
+ };
1838
+ _proto._resetRectMaskClipState = function _resetRectMaskClipState() {
1839
+ if (this._rectMaskEnabled) {
1840
+ this._rectMaskEnabled = false;
1841
+ this.shaderData.setFloat(UIRenderer._rectClipEnabledProperty, 0);
1842
+ }
1843
+ var rectMaskSoftness = this._rectMaskSoftness;
1844
+ if (rectMaskSoftness.x !== 0 || rectMaskSoftness.y !== 0 || rectMaskSoftness.z !== 0 || rectMaskSoftness.w !== 0) {
1845
+ rectMaskSoftness.set(0, 0, 0, 0);
1846
+ this.shaderData.setVector4(UIRenderer._rectClipSoftnessProperty, rectMaskSoftness);
1847
+ }
1848
+ if (this._rectMaskHardClip) {
1849
+ this._rectMaskHardClip = false;
1850
+ this.shaderData.setFloat(UIRenderer._rectClipHardClipProperty, 0);
1851
+ }
1852
+ };
1853
+ _proto._onDestroy = function _onDestroy() {
1854
+ if (this._subChunk) {
1855
+ this._getChunkManager().freeSubChunk(this._subChunk);
1856
+ this._subChunk = null;
1857
+ }
1858
+ _superClass.prototype._onDestroy.call(this);
1859
+ //@ts-ignore
1860
+ this._color._onValueChanged = null;
1861
+ this._color = null;
1862
+ this._rectMasks = null;
1863
+ this._rectMaskSoftness = null;
1864
+ };
1865
+ _create_class(UIRenderer, [
1866
+ {
1867
+ key: "color",
1868
+ get: /**
1305
1869
  * Rendering color for the ui renderer.
1306
1870
  */ function get() {
1307
- return this._color;
1308
- },
1309
- set: function set(value) {
1310
- if (this._color !== value) {
1311
- this._color.copyFrom(value);
1871
+ return this._color;
1872
+ },
1873
+ set: function set(value) {
1874
+ if (this._color !== value) {
1875
+ this._color.copyFrom(value);
1876
+ }
1312
1877
  }
1313
- }
1314
- },
1315
- {
1316
- key: "maskLayer",
1317
- get: /**
1878
+ },
1879
+ {
1880
+ key: "maskLayer",
1881
+ get: /**
1318
1882
  * The mask layer the ui renderer belongs to.
1319
1883
  */ function get() {
1320
- return this._maskLayer;
1884
+ return this._maskLayer;
1885
+ },
1886
+ set: function set(value) {
1887
+ this._maskLayer = value;
1888
+ }
1321
1889
  },
1322
- set: function set(value) {
1323
- this._maskLayer = value;
1324
- }
1325
- },
1326
- {
1327
- key: "maskInteraction",
1328
- get: /**
1890
+ {
1891
+ key: "maskInteraction",
1892
+ get: /**
1329
1893
  * Interacts with the masks.
1330
1894
  */ function get() {
1331
- return this._maskInteraction;
1332
- },
1333
- set: function set(value) {
1334
- if (this._maskInteraction !== value) {
1335
- this._maskInteraction = value;
1895
+ return this._maskInteraction;
1896
+ },
1897
+ set: function set(value) {
1898
+ if (this._maskInteraction !== value) {
1899
+ this._maskInteraction = value;
1900
+ }
1336
1901
  }
1337
- }
1338
- },
1339
- {
1340
- key: "raycastEnabled",
1341
- get: /**
1902
+ },
1903
+ {
1904
+ key: "raycastEnabled",
1905
+ get: /**
1342
1906
  * Whether this renderer be picked up by raycast.
1343
1907
  */ function get() {
1344
- return this._raycastEnabled;
1345
- },
1346
- set: function set(value) {
1347
- this._raycastEnabled = value;
1908
+ return this._raycastEnabled;
1909
+ },
1910
+ set: function set(value) {
1911
+ this._raycastEnabled = value;
1912
+ }
1348
1913
  }
1349
- }
1350
- ]);
1351
- return UIRenderer;
1352
- }(engine.Renderer);
1353
- /** @internal */ exports.UIRenderer._tempVec20 = new engine.Vector2();
1354
- /** @internal */ exports.UIRenderer._tempVec30 = new engine.Vector3();
1355
- /** @internal */ exports.UIRenderer._tempVec31 = new engine.Vector3();
1356
- /** @internal */ exports.UIRenderer._tempMat = new engine.Matrix();
1357
- /** @internal */ exports.UIRenderer._tempPlane = new engine.Plane();
1358
- /** @internal */ exports.UIRenderer._textureProperty = engine.ShaderProperty.getByName("renderer_UITexture");
1359
- /** @internal */ exports.UIRenderer._rectClipRectProperty = engine.ShaderProperty.getByName("renderer_UIRectClipRect");
1360
- /** @internal */ exports.UIRenderer._rectClipEnabledProperty = engine.ShaderProperty.getByName("renderer_UIRectClipEnabled");
1361
- /** @internal */ exports.UIRenderer._rectClipSoftnessProperty = engine.ShaderProperty.getByName("renderer_UIRectClipSoftness");
1362
- /** @internal */ exports.UIRenderer._rectClipHardClipProperty = engine.ShaderProperty.getByName("renderer_UIRectClipHardClip");
1363
- /** @internal */ exports.UIRenderer._tempRect = new engine.Vector4();
1364
- __decorate([
1365
- engine.ignoreClone
1366
- ], exports.UIRenderer.prototype, "_indexInRootCanvas", void 0);
1367
- __decorate([
1368
- engine.ignoreClone
1369
- ], exports.UIRenderer.prototype, "_isRootCanvasDirty", void 0);
1370
- __decorate([
1371
- engine.ignoreClone
1372
- ], exports.UIRenderer.prototype, "_rootCanvasListeningEntities", void 0);
1373
- __decorate([
1374
- engine.ignoreClone
1375
- ], exports.UIRenderer.prototype, "_indexInGroup", void 0);
1376
- __decorate([
1377
- engine.ignoreClone
1378
- ], exports.UIRenderer.prototype, "_isGroupDirty", void 0);
1379
- __decorate([
1380
- engine.ignoreClone
1381
- ], exports.UIRenderer.prototype, "_groupListeningEntities", void 0);
1382
- __decorate([
1383
- engine.ignoreClone
1384
- ], exports.UIRenderer.prototype, "_subChunk", void 0);
1385
- __decorate([
1386
- engine.ignoreClone
1387
- ], exports.UIRenderer.prototype, "_rectMasks", void 0);
1388
- __decorate([
1389
- engine.ignoreClone
1390
- ], exports.UIRenderer.prototype, "_rectMaskRect", void 0);
1391
- __decorate([
1392
- engine.ignoreClone
1393
- ], exports.UIRenderer.prototype, "_rectMaskEnabled", void 0);
1394
- __decorate([
1395
- engine.ignoreClone
1396
- ], exports.UIRenderer.prototype, "_rectMaskSoftness", void 0);
1397
- __decorate([
1398
- engine.ignoreClone
1399
- ], exports.UIRenderer.prototype, "_rectMaskHardClip", void 0);
1400
- __decorate([
1401
- engine.ignoreClone
1402
- ], exports.UIRenderer.prototype, "_groupListener", null);
1403
- __decorate([
1404
- engine.ignoreClone
1405
- ], exports.UIRenderer.prototype, "_rootCanvasListener", null);
1406
- __decorate([
1407
- engine.ignoreClone
1408
- ], exports.UIRenderer.prototype, "_onColorChanged", null);
1409
- exports.UIRenderer = __decorate([
1410
- engine.dependentComponents(UITransform, engine.DependentMode.AutoAdd)
1411
- ], exports.UIRenderer);
1914
+ ]);
1915
+ return UIRenderer;
1916
+ }(_Renderer = engine.Renderer);
1917
+ var ref, ref1, ref2;
1918
+ ref = _apply_decs_2203_r(UIRenderer, [
1919
+ [
1920
+ engine.ignoreClone,
1921
+ 0,
1922
+ "_indexInRootCanvas"
1923
+ ],
1924
+ [
1925
+ engine.ignoreClone,
1926
+ 0,
1927
+ "_isRootCanvasDirty"
1928
+ ],
1929
+ [
1930
+ engine.ignoreClone,
1931
+ 0,
1932
+ "_rootCanvasListeningEntities"
1933
+ ],
1934
+ [
1935
+ engine.ignoreClone,
1936
+ 0,
1937
+ "_indexInGroup"
1938
+ ],
1939
+ [
1940
+ engine.ignoreClone,
1941
+ 0,
1942
+ "_isGroupDirty"
1943
+ ],
1944
+ [
1945
+ engine.ignoreClone,
1946
+ 0,
1947
+ "_groupListeningEntities"
1948
+ ],
1949
+ [
1950
+ engine.ignoreClone,
1951
+ 0,
1952
+ "_subChunk"
1953
+ ],
1954
+ [
1955
+ engine.ignoreClone,
1956
+ 0,
1957
+ "_rectMasks"
1958
+ ],
1959
+ [
1960
+ engine.ignoreClone,
1961
+ 0,
1962
+ "_rectMaskRect"
1963
+ ],
1964
+ [
1965
+ engine.ignoreClone,
1966
+ 0,
1967
+ "_rectMaskEnabled"
1968
+ ],
1969
+ [
1970
+ engine.ignoreClone,
1971
+ 0,
1972
+ "_rectMaskSoftness"
1973
+ ],
1974
+ [
1975
+ engine.ignoreClone,
1976
+ 0,
1977
+ "_rectMaskHardClip"
1978
+ ]
1979
+ ], [
1980
+ _dec$2
1981
+ ], _Renderer), ref1 = ref.e, _init__indexInRootCanvas$2 = ref1[0], _init__isRootCanvasDirty$2 = ref1[1], _init__rootCanvasListeningEntities$2 = ref1[2], _init__indexInGroup$1 = ref1[3], _init__isGroupDirty$1 = ref1[4], _init__groupListeningEntities$1 = ref1[5], _init__subChunk = ref1[6], _init__rectMasks = ref1[7], _init__rectMaskRect = ref1[8], _init__rectMaskEnabled = ref1[9], _init__rectMaskSoftness = ref1[10], _init__rectMaskHardClip = ref1[11], ref2 = ref.c, exports.UIRenderer = ref2[0], _initClass$2 = ref2[1];
1982
+ /** @internal */ UIRenderer._tempVec20 = new engine.Vector2();
1983
+ /** @internal */ UIRenderer._tempVec30 = new engine.Vector3();
1984
+ /** @internal */ UIRenderer._tempVec31 = new engine.Vector3();
1985
+ /** @internal */ UIRenderer._tempMat = new engine.Matrix();
1986
+ /** @internal */ UIRenderer._tempPlane = new engine.Plane();
1987
+ /** @internal */ UIRenderer._textureProperty = engine.ShaderProperty.getByName("renderer_UITexture");
1988
+ /** @internal */ UIRenderer._rectClipRectProperty = engine.ShaderProperty.getByName("renderer_UIRectClipRect");
1989
+ /** @internal */ UIRenderer._rectClipEnabledProperty = engine.ShaderProperty.getByName("renderer_UIRectClipEnabled");
1990
+ /** @internal */ UIRenderer._rectClipSoftnessProperty = engine.ShaderProperty.getByName("renderer_UIRectClipSoftness");
1991
+ /** @internal */ UIRenderer._rectClipHardClipProperty = engine.ShaderProperty.getByName("renderer_UIRectClipHardClip");
1992
+ /** @internal */ UIRenderer._tempRect = new engine.Vector4();
1993
+ }(), _class$2)();
1412
1994
  /**
1413
1995
  * @remarks Extends `RendererUpdateFlags`.
1414
1996
  */ var UIRendererUpdateFlags = /*#__PURE__*/ function(UIRendererUpdateFlags) {
@@ -1416,639 +1998,666 @@ exports.UIRenderer = __decorate([
1416
1998
  return UIRendererUpdateFlags;
1417
1999
  }({});
1418
2000
 
1419
- exports.UICanvas = /*#__PURE__*/ function(Component) {
1420
- _inherits(UICanvas, Component);
1421
- function UICanvas(entity) {
2001
+ var _class$1;
2002
+ var _dec$1, _initClass$1, _Component, /** @internal */ _init__canvasIndex, /** @internal */ _init__indexInRootCanvas$1, /** @internal */ _init__isRootCanvasDirty$1, /** @internal */ _init__rootCanvasListeningEntities$1, /** @internal */ _init__isRootCanvas, /** @internal */ _init__renderElements, /** @internal */ _init__batchedRenderElements, /** @internal */ _init__sortDistance, /** @internal */ _init__orderedRenderers, /** @internal */ _init__realRenderMode, _init__renderMode, _init__hierarchyVersion, _init__center;
2003
+ exports.UICanvas = void 0;
2004
+ _dec$1 = engine.dependentComponents(UITransform, engine.DependentMode.AutoAdd);
2005
+ new (_class$1 = /*#__PURE__*/ function(_identity) {
2006
+ _inherits(_class, _identity);
2007
+ function _class() {
1422
2008
  var _this;
1423
- _this = Component.call(this, entity) || this, /** @internal */ _this._canvasIndex = -1, /** @internal */ _this._indexInRootCanvas = -1, /** @internal */ _this._isRootCanvasDirty = false, /** @internal */ _this._rootCanvasListeningEntities = [], /** @internal */ _this._isRootCanvas = false, /** @internal */ _this._renderElements = [], /** @internal */ _this._batchedRenderElements = [], /** @internal */ _this._sortDistance = 0, /** @internal */ _this._orderedRenderers = [], /** @internal */ _this._realRenderMode = 4, /** @internal */ _this._disorderedElements = new engine.DisorderedArray(), _this._renderMode = CanvasRenderMode.WorldSpace, _this._resolutionAdaptationMode = ResolutionAdaptationMode.HeightAdaptation, _this._sortOrder = 0, _this._distance = 10, _this._referenceResolution = new engine.Vector2(800, 600), _this._referenceResolutionPerUnit = 100, _this._hierarchyVersion = -1, _this._center = new engine.Vector3();
1424
- _this._onCanvasSizeListener = _this._onCanvasSizeListener.bind(_this);
1425
- _this._onCameraModifyListener = _this._onCameraModifyListener.bind(_this);
1426
- _this._onCameraTransformListener = _this._onCameraTransformListener.bind(_this);
1427
- _this._onReferenceResolutionChanged = _this._onReferenceResolutionChanged.bind(_this);
1428
- // @ts-ignore
1429
- _this._referenceResolution._onValueChanged = _this._onReferenceResolutionChanged;
1430
- _this._rootCanvasListener = _this._rootCanvasListener.bind(_this);
1431
- _this._centerDirtyFlag = entity.registerWorldChangeFlag();
2009
+ _this = _identity.apply(this, arguments) || this, _initClass$1();
1432
2010
  return _this;
1433
2011
  }
1434
- var _proto = UICanvas.prototype;
1435
- /**
2012
+ return _class;
2013
+ }(_identity), function() {
2014
+ var UICanvas = /*#__PURE__*/ function(_superClass) {
2015
+ _inherits(UICanvas, _superClass);
2016
+ function UICanvas(entity) {
2017
+ var _this;
2018
+ _this = _superClass.call(this, entity) || this, _this._canvasIndex = _init__canvasIndex(_this, -1), _this._indexInRootCanvas = _init__indexInRootCanvas$1(_this, -1), _this._isRootCanvasDirty = _init__isRootCanvasDirty$1(_this, false), _this._rootCanvasListeningEntities = _init__rootCanvasListeningEntities$1(_this, []), _this._isRootCanvas = _init__isRootCanvas(_this, false), _this._renderElements = _init__renderElements(_this, []), _this._batchedRenderElements = _init__batchedRenderElements(_this, []), _this._sortDistance = _init__sortDistance(_this, 0), _this._orderedRenderers = _init__orderedRenderers(_this, []), _this._realRenderMode = _init__realRenderMode(_this, 4), /** @internal */ _this._disorderedElements = new engine.DisorderedArray(), _this._renderMode = _init__renderMode(_this, CanvasRenderMode.WorldSpace), _this._resolutionAdaptationMode = ResolutionAdaptationMode.HeightAdaptation, _this._sortOrder = 0, _this._distance = 10, _this._referenceResolution = new engine.Vector2(800, 600), _this._referenceResolutionPerUnit = 100, _this._hierarchyVersion = _init__hierarchyVersion(_this, -1), _this._center = _init__center(_this, new engine.Vector3());
2019
+ _this._onCanvasSizeListener = _this._onCanvasSizeListener.bind(_this);
2020
+ _this._onCameraModifyListener = _this._onCameraModifyListener.bind(_this);
2021
+ _this._onCameraTransformListener = _this._onCameraTransformListener.bind(_this);
2022
+ _this._onReferenceResolutionChanged = _this._onReferenceResolutionChanged.bind(_this);
2023
+ // @ts-ignore
2024
+ _this._referenceResolution._onValueChanged = _this._onReferenceResolutionChanged;
2025
+ _this._rootCanvasListener = _this._rootCanvasListener.bind(_this);
2026
+ _this._centerDirtyFlag = entity.registerWorldChangeFlag();
2027
+ return _this;
2028
+ }
2029
+ var _proto = UICanvas.prototype;
2030
+ /**
1436
2031
  * @internal
1437
2032
  */ _proto._raycast = function _raycast(ray, out, distance) {
1438
- if (distance === void 0) distance = Number.MAX_SAFE_INTEGER;
1439
- var renderers = this._getRenderers();
1440
- for(var i = renderers.length - 1; i >= 0; i--){
1441
- var element = renderers[i];
1442
- if (element.raycastEnabled && element._raycast(ray, out, distance)) {
1443
- return true;
2033
+ if (distance === void 0) distance = Number.MAX_SAFE_INTEGER;
2034
+ var renderers = this._getRenderers();
2035
+ for(var i = renderers.length - 1; i >= 0; i--){
2036
+ var element = renderers[i];
2037
+ if (element.raycastEnabled && element._raycast(ray, out, distance)) {
2038
+ return true;
2039
+ }
1444
2040
  }
1445
- }
1446
- out.component = null;
1447
- out.entity = null;
1448
- out.distance = 0;
1449
- out.point.set(0, 0, 0);
1450
- out.normal.set(0, 0, 0);
1451
- return false;
1452
- };
1453
- /**
2041
+ out.component = null;
2042
+ out.entity = null;
2043
+ out.distance = 0;
2044
+ out.point.set(0, 0, 0);
2045
+ out.normal.set(0, 0, 0);
2046
+ return false;
2047
+ };
2048
+ /**
1454
2049
  * @internal
1455
2050
  */ _proto._getRootCanvas = function _getRootCanvas() {
1456
- return this._rootCanvas;
1457
- };
1458
- /**
2051
+ return this._rootCanvas;
2052
+ };
2053
+ /**
1459
2054
  * @internal
1460
2055
  */ _proto._canRender = function _canRender(camera) {
1461
- return this._realRenderMode !== CanvasRenderMode.ScreenSpaceCamera || this._camera === camera;
1462
- };
1463
- /**
2056
+ return this._realRenderMode !== CanvasRenderMode.ScreenSpaceCamera || this._camera === camera;
2057
+ };
2058
+ /**
1464
2059
  * @internal
1465
2060
  */ _proto._canDispatchEvent = function _canDispatchEvent(camera) {
1466
- var realMode = this._realRenderMode;
1467
- if (realMode === CanvasRenderMode.ScreenSpaceOverlay) {
1468
- return true;
1469
- }
1470
- var assignedCamera = this._camera;
1471
- // @ts-ignore
1472
- return !assignedCamera || !assignedCamera._phasedActiveInScene || assignedCamera === camera;
1473
- };
1474
- /**
2061
+ var realMode = this._realRenderMode;
2062
+ if (realMode === CanvasRenderMode.ScreenSpaceOverlay) {
2063
+ return true;
2064
+ }
2065
+ var assignedCamera = this._camera;
2066
+ // @ts-ignore
2067
+ return !assignedCamera || !assignedCamera._phasedActiveInScene || assignedCamera === camera;
2068
+ };
2069
+ /**
1475
2070
  * @internal
1476
2071
  */ _proto._prepareRender = function _prepareRender(context) {
1477
- var _this = this, engine = _this.engine, mode = _this._realRenderMode;
1478
- var _context_camera = context.camera, enableFrustumCulling = _context_camera.enableFrustumCulling, cullingMask = _context_camera.cullingMask, frustum = _context_camera._frustum;
1479
- var frameCount = engine.time.frameCount;
1480
- var renderElements = this._renderElements;
1481
- renderElements.length = 0;
1482
- var virtualCamera = context.virtualCamera;
1483
- this._updateSortDistance(virtualCamera.isOrthographic, virtualCamera.position, virtualCamera.forward);
1484
- var _engine_canvas = engine.canvas, width = _engine_canvas.width, height = _engine_canvas.height;
1485
- var renderers = this._getRenderers();
1486
- for(var i = 0, n = renderers.length; i < n; i++){
1487
- var renderer = renderers[i];
1488
- // Filter by camera culling mask
1489
- if (!(cullingMask & renderer.entity.layer)) {
1490
- continue;
1491
- }
1492
- // Filter by camera frustum
1493
- if (enableFrustumCulling) {
1494
- switch(mode){
1495
- case CanvasRenderMode.ScreenSpaceOverlay:
1496
- var _renderer_bounds = renderer.bounds, min = _renderer_bounds.min, max = _renderer_bounds.max;
1497
- if (min.x > width || max.x < 0 || min.y > height || max.y < 0) {
1498
- continue;
1499
- }
1500
- break;
1501
- case CanvasRenderMode.ScreenSpaceCamera:
1502
- case CanvasRenderMode.WorldSpace:
1503
- if (!frustum.intersectsBox(renderer.bounds)) {
1504
- continue;
1505
- }
1506
- break;
2072
+ var _this = this, engine = _this.engine, mode = _this._realRenderMode;
2073
+ var _context_camera = context.camera, enableFrustumCulling = _context_camera.enableFrustumCulling, cullingMask = _context_camera.cullingMask, frustum = _context_camera._frustum;
2074
+ var frameCount = engine.time.frameCount;
2075
+ var renderElements = this._renderElements;
2076
+ renderElements.length = 0;
2077
+ var virtualCamera = context.virtualCamera;
2078
+ this._updateSortDistance(virtualCamera.isOrthographic, virtualCamera.position, virtualCamera.forward);
2079
+ var _engine_canvas = engine.canvas, width = _engine_canvas.width, height = _engine_canvas.height;
2080
+ var renderers = this._getRenderers();
2081
+ for(var i = 0, n = renderers.length; i < n; i++){
2082
+ var renderer = renderers[i];
2083
+ // Filter by camera culling mask
2084
+ if (!(cullingMask & renderer.entity.layer)) {
2085
+ continue;
1507
2086
  }
1508
- }
1509
- renderer._prepareRender(context);
1510
- renderer._renderFrameCount = frameCount;
1511
- }
1512
- var batchedRenderElements = this._batchedRenderElements;
1513
- batchedRenderElements.length = 0;
1514
- UIBatchSorter.sort(renderElements, this.entity.transform.worldMatrix);
1515
- engine._batcherManager.batch(renderElements, batchedRenderElements);
1516
- for(var i1 = 0, n1 = batchedRenderElements.length; i1 < n1; i1++){
1517
- batchedRenderElements[i1].subDistancePriority = i1;
1518
- }
1519
- };
1520
- /**
1521
- * @internal
1522
- */ _proto._updateSortDistance = function _updateSortDistance(isOrthographic, cameraPosition, cameraForward) {
1523
- switch(this._realRenderMode){
1524
- case CanvasRenderMode.ScreenSpaceOverlay:
1525
- this._sortDistance = 0;
1526
- break;
1527
- case CanvasRenderMode.ScreenSpaceCamera:
1528
- this._sortDistance = this._distance;
1529
- break;
1530
- case CanvasRenderMode.WorldSpace:
1531
- var boundsCenter = this._getCenter();
1532
- if (isOrthographic) {
1533
- var distance = UICanvas._tempVec3;
1534
- engine.Vector3.subtract(boundsCenter, cameraPosition, distance);
1535
- this._sortDistance = engine.Vector3.dot(distance, cameraForward);
1536
- } else {
1537
- this._sortDistance = engine.Vector3.distanceSquared(boundsCenter, cameraPosition);
2087
+ // Filter by camera frustum
2088
+ if (enableFrustumCulling) {
2089
+ switch(mode){
2090
+ case CanvasRenderMode.ScreenSpaceOverlay:
2091
+ var _renderer_bounds = renderer.bounds, min = _renderer_bounds.min, max = _renderer_bounds.max;
2092
+ if (min.x > width || max.x < 0 || min.y > height || max.y < 0) {
2093
+ continue;
2094
+ }
2095
+ break;
2096
+ case CanvasRenderMode.ScreenSpaceCamera:
2097
+ case CanvasRenderMode.WorldSpace:
2098
+ if (!frustum.intersectsBox(renderer.bounds)) {
2099
+ continue;
2100
+ }
2101
+ break;
2102
+ }
1538
2103
  }
1539
- break;
1540
- }
1541
- };
1542
- // @ts-ignore
1543
- _proto._onEnableInScene = function _onEnableInScene() {
1544
- var entity = this.entity;
1545
- // @ts-ignore
1546
- entity._dispatchModify(4, this);
1547
- var rootCanvas = Utils.searchRootCanvasInParents(this);
1548
- this._setIsRootCanvas(!rootCanvas);
1549
- Utils.setRootCanvas(this, rootCanvas);
1550
- };
1551
- // @ts-ignore
1552
- _proto._onDisableInScene = function _onDisableInScene() {
1553
- this._setIsRootCanvas(false);
1554
- Utils.cleanRootCanvas(this);
1555
- };
1556
- // @ts-ignore
1557
- _proto._onDisable = function _onDisable() {
1558
- this._renderElements.length = 0;
1559
- this._batchedRenderElements.length = 0;
1560
- };
1561
- /**
1562
- * @internal
1563
- */ _proto._rootCanvasListener = function _rootCanvasListener(flag, param) {
1564
- if (this._isRootCanvas) {
1565
- if (flag === engine.EntityModifyFlags.Parent) {
1566
- var rootCanvas = Utils.searchRootCanvasInParents(this);
1567
- this._setIsRootCanvas(!rootCanvas);
1568
- Utils.setRootCanvas(this, rootCanvas);
1569
- } else if (flag === 4) {
1570
- this._setIsRootCanvas(false);
1571
- Utils.setRootCanvas(this, param);
2104
+ renderer._prepareRender(context);
2105
+ renderer._renderFrameCount = frameCount;
1572
2106
  }
1573
- } else {
1574
- if (flag === engine.EntityModifyFlags.Parent) {
1575
- var rootCanvas1 = Utils.searchRootCanvasInParents(this);
1576
- this._setIsRootCanvas(!rootCanvas1);
1577
- Utils.setRootCanvas(this, rootCanvas1);
2107
+ var batchedRenderElements = this._batchedRenderElements;
2108
+ batchedRenderElements.length = 0;
2109
+ UIBatchSorter.sort(renderElements, this.entity.transform.worldMatrix);
2110
+ engine._batcherManager.batch(renderElements, batchedRenderElements);
2111
+ for(var i1 = 0, n1 = batchedRenderElements.length; i1 < n1; i1++){
2112
+ batchedRenderElements[i1].subDistancePriority = i1;
1578
2113
  }
1579
- }
1580
- };
1581
- /**
1582
- * @inheritdoc
1583
- */ _proto._onClone = function _onClone(target) {
1584
- target.renderMode = this._renderMode;
1585
- };
1586
- _proto._getRenderers = function _getRenderers() {
1587
- var _this = this, renderers = _this._orderedRenderers, entity = _this.entity;
1588
- var uiHierarchyVersion = entity._uiHierarchyVersion;
1589
- if (this._hierarchyVersion !== uiHierarchyVersion) {
1590
- UICanvas._tempRectMaskList.length = 0;
1591
- renderers.length = this._walk(this.entity, renderers, 0, null, 0);
1592
- UICanvas._tempGroupAbleList.length = 0;
1593
- this._hierarchyVersion = uiHierarchyVersion;
1594
- ++UICanvas._hierarchyCounter;
1595
- }
1596
- return renderers;
1597
- };
1598
- _proto._adapterPoseInScreenSpace = function _adapterPoseInScreenSpace() {
1599
- var transform = this.entity.transform;
1600
- var realRenderMode = this._realRenderMode;
1601
- if (realRenderMode === CanvasRenderMode.ScreenSpaceCamera) {
1602
- var cameraEntity = this._camera.entity;
1603
- if (!this._isSameOrChildEntity(cameraEntity)) {
1604
- var cameraTransform = cameraEntity.transform;
1605
- var cameraWorldPosition = cameraTransform.worldPosition, cameraWorldForward = cameraTransform.worldForward;
1606
- var distance = this._distance;
1607
- transform.setWorldPosition(cameraWorldPosition.x + cameraWorldForward.x * distance, cameraWorldPosition.y + cameraWorldForward.y * distance, cameraWorldPosition.z + cameraWorldForward.z * distance);
1608
- transform.worldRotationQuaternion.copyFrom(cameraTransform.worldRotationQuaternion);
1609
- }
1610
- } else {
1611
- var canvas = this.engine.canvas;
1612
- transform.setWorldPosition(canvas.width * 0.5, canvas.height * 0.5, 0);
1613
- transform.worldRotationQuaternion.set(0, 0, 0, 1);
1614
- }
1615
- };
1616
- _proto._adapterSizeInScreenSpace = function _adapterSizeInScreenSpace() {
1617
- var transform = this.entity.transform;
1618
- var realRenderMode = this._realRenderMode;
1619
- var _this__referenceResolution = this._referenceResolution, width = _this__referenceResolution.x, height = _this__referenceResolution.y;
1620
- var curWidth;
1621
- var curHeight;
1622
- if (realRenderMode === CanvasRenderMode.ScreenSpaceCamera) {
1623
- var camera = this._camera;
1624
- curHeight = camera.isOrthographic ? camera.orthographicSize * 2 : 2 * (Math.tan(engine.MathUtil.degreeToRadian(camera.fieldOfView * 0.5)) * this._distance);
1625
- curWidth = camera.aspectRatio * curHeight;
1626
- } else {
1627
- var canvas = this.engine.canvas;
1628
- curHeight = canvas.height;
1629
- curWidth = canvas.width;
1630
- }
1631
- var expectX, expectY, expectZ;
1632
- switch(this._resolutionAdaptationMode){
1633
- case ResolutionAdaptationMode.WidthAdaptation:
1634
- expectX = expectY = expectZ = curWidth / width;
1635
- break;
1636
- case ResolutionAdaptationMode.HeightAdaptation:
1637
- expectX = expectY = expectZ = curHeight / height;
1638
- break;
1639
- case ResolutionAdaptationMode.BothAdaptation:
1640
- expectX = curWidth / width;
1641
- expectY = curHeight / height;
1642
- expectZ = (expectX + expectY) * 0.5;
1643
- break;
1644
- case ResolutionAdaptationMode.ExpandAdaptation:
1645
- expectX = expectY = expectZ = Math.min(curWidth / width, curHeight / height);
1646
- break;
1647
- case ResolutionAdaptationMode.ShrinkAdaptation:
1648
- expectX = expectY = expectZ = Math.max(curWidth / width, curHeight / height);
1649
- break;
1650
- }
1651
- var worldMatrix = UICanvas._tempMat;
1652
- engine.Matrix.affineTransformation(UICanvas._tempVec3.set(expectX, expectY, expectZ), transform.worldRotationQuaternion, transform.worldPosition, worldMatrix);
1653
- transform.worldMatrix = worldMatrix;
1654
- transform.size.set(curWidth / expectX, curHeight / expectY);
1655
- };
1656
- _proto._walk = function _walk(entity, renderers, depth, group, rectMaskCount) {
1657
- if (depth === void 0) depth = 0;
1658
- if (group === void 0) group = null;
1659
- if (rectMaskCount === void 0) rectMaskCount = 0;
2114
+ };
2115
+ /**
2116
+ * @internal
2117
+ */ _proto._updateSortDistance = function _updateSortDistance(isOrthographic, cameraPosition, cameraForward) {
2118
+ switch(this._realRenderMode){
2119
+ case CanvasRenderMode.ScreenSpaceOverlay:
2120
+ this._sortDistance = 0;
2121
+ break;
2122
+ case CanvasRenderMode.ScreenSpaceCamera:
2123
+ this._sortDistance = this._distance;
2124
+ break;
2125
+ case CanvasRenderMode.WorldSpace:
2126
+ var boundsCenter = this._getCenter();
2127
+ if (isOrthographic) {
2128
+ var distance = UICanvas._tempVec3;
2129
+ engine.Vector3.subtract(boundsCenter, cameraPosition, distance);
2130
+ this._sortDistance = engine.Vector3.dot(distance, cameraForward);
2131
+ } else {
2132
+ this._sortDistance = engine.Vector3.distanceSquared(boundsCenter, cameraPosition);
2133
+ }
2134
+ break;
2135
+ }
2136
+ };
1660
2137
  // @ts-ignore
1661
- var components = entity._components;
1662
- var tempGroupAbleList = UICanvas._tempGroupAbleList;
1663
- var tempRectMaskList = UICanvas._tempRectMaskList;
1664
- var rectMask = null;
1665
- var groupAbleCount = 0;
1666
- for(var i = 0, n = components.length; i < n; i++){
1667
- var component = components[i];
1668
- if (!component.enabled) continue;
1669
- if (_instanceof(component, exports.UIRenderer)) {
1670
- renderers[depth] = component;
1671
- ++depth;
1672
- component._isRootCanvasDirty && Utils.setRootCanvas(component, this);
1673
- if (component._isGroupDirty) {
1674
- tempGroupAbleList[groupAbleCount++] = component;
2138
+ _proto._onEnableInScene = function _onEnableInScene() {
2139
+ var entity = this.entity;
2140
+ // @ts-ignore
2141
+ entity._dispatchModify(4, this);
2142
+ var rootCanvas = Utils.searchRootCanvasInParents(this);
2143
+ this._setIsRootCanvas(!rootCanvas);
2144
+ Utils.setRootCanvas(this, rootCanvas);
2145
+ };
2146
+ // @ts-ignore
2147
+ _proto._onDisableInScene = function _onDisableInScene() {
2148
+ this._setIsRootCanvas(false);
2149
+ Utils.cleanRootCanvas(this);
2150
+ };
2151
+ // @ts-ignore
2152
+ _proto._onDisable = function _onDisable() {
2153
+ this._renderElements.length = 0;
2154
+ this._batchedRenderElements.length = 0;
2155
+ };
2156
+ /**
2157
+ * @internal
2158
+ */ _proto._rootCanvasListener = function _rootCanvasListener(flag, param) {
2159
+ if (this._isRootCanvas) {
2160
+ if (flag === engine.EntityModifyFlags.Parent) {
2161
+ var rootCanvas = Utils.searchRootCanvasInParents(this);
2162
+ this._setIsRootCanvas(!rootCanvas);
2163
+ Utils.setRootCanvas(this, rootCanvas);
2164
+ } else if (flag === 4) {
2165
+ this._setIsRootCanvas(false);
2166
+ Utils.setRootCanvas(this, param);
1675
2167
  }
1676
- component._setRectMasks(tempRectMaskList, rectMaskCount);
1677
- } else if (_instanceof(component, UIInteractive)) {
1678
- component._isRootCanvasDirty && Utils.setRootCanvas(component, this);
1679
- if (component._isGroupDirty) {
1680
- tempGroupAbleList[groupAbleCount++] = component;
2168
+ } else {
2169
+ if (flag === engine.EntityModifyFlags.Parent) {
2170
+ var rootCanvas1 = Utils.searchRootCanvasInParents(this);
2171
+ this._setIsRootCanvas(!rootCanvas1);
2172
+ Utils.setRootCanvas(this, rootCanvas1);
1681
2173
  }
1682
- } else if (_instanceof(component, exports.RectMask2D)) {
1683
- rectMask = component;
1684
- } else if (_instanceof(component, UIGroup)) {
1685
- component._isRootCanvasDirty && Utils.setRootCanvas(component, this);
1686
- component._isGroupDirty && Utils.setGroup(component, group);
1687
- group = component;
1688
2174
  }
1689
- }
1690
- for(var i1 = 0; i1 < groupAbleCount; i1++){
1691
- Utils.setGroup(tempGroupAbleList[i1], group);
1692
- }
1693
- if (rectMask) {
1694
- tempRectMaskList[rectMaskCount++] = rectMask;
1695
- }
1696
- var children = entity.children;
1697
- for(var i2 = 0, n1 = children.length; i2 < n1; i2++){
1698
- var child = children[i2];
1699
- child.isActive && (depth = this._walk(child, renderers, depth, group, rectMaskCount));
1700
- }
1701
- return depth;
1702
- };
1703
- _proto._updateCameraObserver = function _updateCameraObserver() {
1704
- var camera = this._isRootCanvas && this._renderMode === CanvasRenderMode.ScreenSpaceCamera ? this._camera : null;
1705
- var preCamera = this._cameraObserver;
1706
- if (preCamera !== camera) {
1707
- this._cameraObserver = camera;
1708
- if (preCamera) {
1709
- // @ts-ignore
1710
- preCamera.entity._updateFlagManager.removeListener(this._onCameraTransformListener);
1711
- // @ts-ignore
1712
- preCamera._unRegisterModifyListener(this._onCameraModifyListener);
2175
+ };
2176
+ /**
2177
+ * @inheritdoc
2178
+ */ _proto._onClone = function _onClone(target) {
2179
+ target.renderMode = this._renderMode;
2180
+ };
2181
+ _proto._getRenderers = function _getRenderers() {
2182
+ var _this = this, renderers = _this._orderedRenderers, entity = _this.entity;
2183
+ var uiHierarchyVersion = entity._uiHierarchyVersion;
2184
+ if (this._hierarchyVersion !== uiHierarchyVersion) {
2185
+ UICanvas._tempRectMaskList.length = 0;
2186
+ renderers.length = this._walk(this.entity, renderers, 0, null, 0);
2187
+ UICanvas._tempGroupAbleList.length = 0;
2188
+ this._hierarchyVersion = uiHierarchyVersion;
2189
+ ++UICanvas._hierarchyCounter;
1713
2190
  }
1714
- if (camera) {
1715
- // @ts-ignore
1716
- camera.entity._updateFlagManager.addListener(this._onCameraTransformListener);
1717
- // @ts-ignore
1718
- camera._registerModifyListener(this._onCameraModifyListener);
2191
+ return renderers;
2192
+ };
2193
+ _proto._adapterPoseInScreenSpace = function _adapterPoseInScreenSpace() {
2194
+ var transform = this.entity.transform;
2195
+ var realRenderMode = this._realRenderMode;
2196
+ if (realRenderMode === CanvasRenderMode.ScreenSpaceCamera) {
2197
+ var cameraEntity = this._camera.entity;
2198
+ if (!this._isSameOrChildEntity(cameraEntity)) {
2199
+ var cameraTransform = cameraEntity.transform;
2200
+ var cameraWorldPosition = cameraTransform.worldPosition, cameraWorldForward = cameraTransform.worldForward;
2201
+ var distance = this._distance;
2202
+ transform.setWorldPosition(cameraWorldPosition.x + cameraWorldForward.x * distance, cameraWorldPosition.y + cameraWorldForward.y * distance, cameraWorldPosition.z + cameraWorldForward.z * distance);
2203
+ transform.worldRotationQuaternion.copyFrom(cameraTransform.worldRotationQuaternion);
2204
+ }
2205
+ } else {
2206
+ var canvas = this.engine.canvas;
2207
+ transform.setWorldPosition(canvas.width * 0.5, canvas.height * 0.5, 0);
2208
+ transform.worldRotationQuaternion.set(0, 0, 0, 1);
1719
2209
  }
1720
- }
1721
- };
1722
- _proto._onCameraModifyListener = function _onCameraModifyListener(flag) {
1723
- if (this._realRenderMode === CanvasRenderMode.ScreenSpaceCamera) {
1724
- switch(flag){
1725
- case engine.CameraModifyFlags.ProjectionType:
1726
- case engine.CameraModifyFlags.AspectRatio:
1727
- this._adapterSizeInScreenSpace();
2210
+ };
2211
+ _proto._adapterSizeInScreenSpace = function _adapterSizeInScreenSpace() {
2212
+ var transform = this.entity.transform;
2213
+ var realRenderMode = this._realRenderMode;
2214
+ var _this__referenceResolution = this._referenceResolution, width = _this__referenceResolution.x, height = _this__referenceResolution.y;
2215
+ var curWidth;
2216
+ var curHeight;
2217
+ if (realRenderMode === CanvasRenderMode.ScreenSpaceCamera) {
2218
+ var camera = this._camera;
2219
+ curHeight = camera.isOrthographic ? camera.orthographicSize * 2 : 2 * (Math.tan(engine.MathUtil.degreeToRadian(camera.fieldOfView * 0.5)) * this._distance);
2220
+ curWidth = camera.aspectRatio * curHeight;
2221
+ } else {
2222
+ var canvas = this.engine.canvas;
2223
+ curHeight = canvas.height;
2224
+ curWidth = canvas.width;
2225
+ }
2226
+ var expectX, expectY, expectZ;
2227
+ switch(this._resolutionAdaptationMode){
2228
+ case ResolutionAdaptationMode.WidthAdaptation:
2229
+ expectX = expectY = expectZ = curWidth / width;
1728
2230
  break;
1729
- case engine.CameraModifyFlags.FieldOfView:
1730
- !this._camera.isOrthographic && this._adapterSizeInScreenSpace();
2231
+ case ResolutionAdaptationMode.HeightAdaptation:
2232
+ expectX = expectY = expectZ = curHeight / height;
1731
2233
  break;
1732
- case engine.CameraModifyFlags.OrthographicSize:
1733
- this._camera.isOrthographic && this._adapterSizeInScreenSpace();
2234
+ case ResolutionAdaptationMode.BothAdaptation:
2235
+ expectX = curWidth / width;
2236
+ expectY = curHeight / height;
2237
+ expectZ = (expectX + expectY) * 0.5;
1734
2238
  break;
1735
- case engine.CameraModifyFlags.DisableInScene:
1736
- this._setRealRenderMode(CanvasRenderMode.ScreenSpaceOverlay);
2239
+ case ResolutionAdaptationMode.ExpandAdaptation:
2240
+ expectX = expectY = expectZ = Math.min(curWidth / width, curHeight / height);
2241
+ break;
2242
+ case ResolutionAdaptationMode.ShrinkAdaptation:
2243
+ expectX = expectY = expectZ = Math.max(curWidth / width, curHeight / height);
1737
2244
  break;
1738
2245
  }
1739
- } else {
1740
- flag === engine.CameraModifyFlags.EnableInScene && this._setRealRenderMode(CanvasRenderMode.ScreenSpaceCamera);
1741
- }
1742
- };
1743
- _proto._onCameraTransformListener = function _onCameraTransformListener() {
1744
- this._realRenderMode === CanvasRenderMode.ScreenSpaceCamera && this._adapterPoseInScreenSpace();
1745
- };
1746
- _proto._addCanvasListener = function _addCanvasListener() {
1747
- // @ts-ignore
1748
- this.engine.canvas._sizeUpdateFlagManager.addListener(this._onCanvasSizeListener);
1749
- };
1750
- _proto._removeCanvasListener = function _removeCanvasListener() {
1751
- // @ts-ignore
1752
- this.engine.canvas._sizeUpdateFlagManager.removeListener(this._onCanvasSizeListener);
1753
- };
1754
- _proto._onCanvasSizeListener = function _onCanvasSizeListener() {
1755
- var canvas = this.engine.canvas;
1756
- this.entity.transform.setWorldPosition(canvas.width * 0.5, canvas.height * 0.5, 0);
1757
- this._adapterSizeInScreenSpace();
1758
- };
1759
- _proto._onReferenceResolutionChanged = function _onReferenceResolutionChanged() {
1760
- var realRenderMode = this._realRenderMode;
1761
- if (realRenderMode === CanvasRenderMode.ScreenSpaceOverlay || realRenderMode === CanvasRenderMode.ScreenSpaceCamera) {
1762
- this._adapterSizeInScreenSpace();
1763
- }
1764
- };
1765
- _proto._setIsRootCanvas = function _setIsRootCanvas(isRootCanvas) {
1766
- var _this = this;
1767
- if (this._isRootCanvas !== isRootCanvas) {
1768
- this._isRootCanvas = isRootCanvas;
1769
- this._updateCameraObserver();
1770
- this._setRealRenderMode(this._getRealRenderMode());
1771
- if (isRootCanvas) {
1772
- this.entity._updateUIHierarchyVersion(UICanvas._hierarchyCounter);
1773
- } else {
1774
- var _this1 = this, disorderedElements = _this1._disorderedElements;
1775
- disorderedElements.forEach(function(element) {
1776
- if (_instanceof(element, UICanvas)) {
1777
- var rootCanvas = Utils.searchRootCanvasInParents(element);
1778
- element._setIsRootCanvas(!rootCanvas);
1779
- Utils.setRootCanvas(element, rootCanvas);
1780
- } else {
1781
- Utils.setRootCanvasDirty(_this);
1782
- Utils.setGroupDirty(element);
2246
+ var worldMatrix = UICanvas._tempMat;
2247
+ engine.Matrix.affineTransformation(UICanvas._tempVec3.set(expectX, expectY, expectZ), transform.worldRotationQuaternion, transform.worldPosition, worldMatrix);
2248
+ transform.worldMatrix = worldMatrix;
2249
+ transform.size.set(curWidth / expectX, curHeight / expectY);
2250
+ };
2251
+ _proto._walk = function _walk(entity, renderers, depth, group, rectMaskCount) {
2252
+ if (depth === void 0) depth = 0;
2253
+ if (group === void 0) group = null;
2254
+ if (rectMaskCount === void 0) rectMaskCount = 0;
2255
+ // @ts-ignore
2256
+ var components = entity._components;
2257
+ var tempGroupAbleList = UICanvas._tempGroupAbleList;
2258
+ var tempRectMaskList = UICanvas._tempRectMaskList;
2259
+ var rectMask = null;
2260
+ var groupAbleCount = 0;
2261
+ for(var i = 0, n = components.length; i < n; i++){
2262
+ var component = components[i];
2263
+ if (!component.enabled) continue;
2264
+ if (_instanceof(component, exports.UIRenderer)) {
2265
+ renderers[depth] = component;
2266
+ ++depth;
2267
+ component._isRootCanvasDirty && Utils.setRootCanvas(component, this);
2268
+ if (component._isGroupDirty) {
2269
+ tempGroupAbleList[groupAbleCount++] = component;
1783
2270
  }
1784
- });
1785
- disorderedElements.length = 0;
1786
- disorderedElements.garbageCollection();
1787
- this._orderedRenderers.length = 0;
2271
+ component._setRectMasks(tempRectMaskList, rectMaskCount);
2272
+ } else if (_instanceof(component, UIInteractive)) {
2273
+ component._isRootCanvasDirty && Utils.setRootCanvas(component, this);
2274
+ if (component._isGroupDirty) {
2275
+ tempGroupAbleList[groupAbleCount++] = component;
2276
+ }
2277
+ } else if (_instanceof(component, exports.RectMask2D)) {
2278
+ rectMask = component;
2279
+ } else if (_instanceof(component, UIGroup)) {
2280
+ component._isRootCanvasDirty && Utils.setRootCanvas(component, this);
2281
+ component._isGroupDirty && Utils.setGroup(component, group);
2282
+ group = component;
2283
+ }
1788
2284
  }
1789
- }
1790
- };
1791
- _proto._getCenter = function _getCenter() {
1792
- if (this._centerDirtyFlag.flag) {
1793
- var center = this._center;
1794
- var uiTransform = this.entity.transform;
1795
- var pivot = uiTransform.pivot, size = uiTransform.size;
1796
- center.set((0.5 - pivot.x) * size.x, (0.5 - pivot.y) * size.y, 0);
1797
- engine.Vector3.transformCoordinate(center, uiTransform.worldMatrix, center);
1798
- this._centerDirtyFlag.flag = false;
1799
- }
1800
- return this._center;
1801
- };
1802
- _proto._getRealRenderMode = function _getRealRenderMode() {
1803
- if (this._isRootCanvas) {
1804
- var _this__camera;
1805
- var mode = this._renderMode;
1806
- // @ts-ignore
1807
- if (mode === CanvasRenderMode.ScreenSpaceCamera && !((_this__camera = this._camera) == null ? void 0 : _this__camera._phasedActiveInScene)) {
1808
- return CanvasRenderMode.ScreenSpaceOverlay;
2285
+ for(var i1 = 0; i1 < groupAbleCount; i1++){
2286
+ Utils.setGroup(tempGroupAbleList[i1], group);
2287
+ }
2288
+ if (rectMask) {
2289
+ tempRectMaskList[rectMaskCount++] = rectMask;
2290
+ }
2291
+ var children = entity.children;
2292
+ for(var i2 = 0, n1 = children.length; i2 < n1; i2++){
2293
+ var child = children[i2];
2294
+ child.isActive && (depth = this._walk(child, renderers, depth, group, rectMaskCount));
2295
+ }
2296
+ return depth;
2297
+ };
2298
+ _proto._updateCameraObserver = function _updateCameraObserver() {
2299
+ var camera = this._isRootCanvas && this._renderMode === CanvasRenderMode.ScreenSpaceCamera ? this._camera : null;
2300
+ var preCamera = this._cameraObserver;
2301
+ if (preCamera !== camera) {
2302
+ this._cameraObserver = camera;
2303
+ if (preCamera) {
2304
+ // @ts-ignore
2305
+ preCamera.entity._updateFlagManager.removeListener(this._onCameraTransformListener);
2306
+ // @ts-ignore
2307
+ preCamera._unRegisterModifyListener(this._onCameraModifyListener);
2308
+ }
2309
+ if (camera) {
2310
+ // @ts-ignore
2311
+ camera.entity._updateFlagManager.addListener(this._onCameraTransformListener);
2312
+ // @ts-ignore
2313
+ camera._registerModifyListener(this._onCameraModifyListener);
2314
+ }
2315
+ }
2316
+ };
2317
+ _proto._onCameraModifyListener = function _onCameraModifyListener(flag) {
2318
+ if (this._realRenderMode === CanvasRenderMode.ScreenSpaceCamera) {
2319
+ switch(flag){
2320
+ case engine.CameraModifyFlags.ProjectionType:
2321
+ case engine.CameraModifyFlags.AspectRatio:
2322
+ this._adapterSizeInScreenSpace();
2323
+ break;
2324
+ case engine.CameraModifyFlags.FieldOfView:
2325
+ !this._camera.isOrthographic && this._adapterSizeInScreenSpace();
2326
+ break;
2327
+ case engine.CameraModifyFlags.OrthographicSize:
2328
+ this._camera.isOrthographic && this._adapterSizeInScreenSpace();
2329
+ break;
2330
+ case engine.CameraModifyFlags.DisableInScene:
2331
+ this._setRealRenderMode(CanvasRenderMode.ScreenSpaceOverlay);
2332
+ break;
2333
+ }
1809
2334
  } else {
1810
- return mode;
2335
+ flag === engine.CameraModifyFlags.EnableInScene && this._setRealRenderMode(CanvasRenderMode.ScreenSpaceCamera);
1811
2336
  }
1812
- } else {
1813
- return 4;
1814
- }
1815
- };
1816
- _proto._setRealRenderMode = function _setRealRenderMode(curRealMode) {
1817
- var preRealMode = this._realRenderMode;
1818
- if (preRealMode !== curRealMode) {
1819
- this._realRenderMode = curRealMode;
2337
+ };
2338
+ _proto._onCameraTransformListener = function _onCameraTransformListener() {
2339
+ this._realRenderMode === CanvasRenderMode.ScreenSpaceCamera && this._adapterPoseInScreenSpace();
2340
+ };
2341
+ _proto._addCanvasListener = function _addCanvasListener() {
1820
2342
  // @ts-ignore
1821
- var componentsManager = this.scene._componentsManager;
1822
- switch(preRealMode){
1823
- case CanvasRenderMode.ScreenSpaceOverlay:
1824
- this._removeCanvasListener();
1825
- case CanvasRenderMode.ScreenSpaceCamera:
1826
- case CanvasRenderMode.WorldSpace:
1827
- componentsManager.removeUICanvas(this, preRealMode === CanvasRenderMode.ScreenSpaceOverlay);
1828
- break;
2343
+ this.engine.canvas._sizeUpdateFlagManager.addListener(this._onCanvasSizeListener);
2344
+ };
2345
+ _proto._removeCanvasListener = function _removeCanvasListener() {
2346
+ // @ts-ignore
2347
+ this.engine.canvas._sizeUpdateFlagManager.removeListener(this._onCanvasSizeListener);
2348
+ };
2349
+ _proto._onCanvasSizeListener = function _onCanvasSizeListener() {
2350
+ var canvas = this.engine.canvas;
2351
+ this.entity.transform.setWorldPosition(canvas.width * 0.5, canvas.height * 0.5, 0);
2352
+ this._adapterSizeInScreenSpace();
2353
+ };
2354
+ _proto._onReferenceResolutionChanged = function _onReferenceResolutionChanged() {
2355
+ var realRenderMode = this._realRenderMode;
2356
+ if (realRenderMode === CanvasRenderMode.ScreenSpaceOverlay || realRenderMode === CanvasRenderMode.ScreenSpaceCamera) {
2357
+ this._adapterSizeInScreenSpace();
1829
2358
  }
1830
- switch(curRealMode){
1831
- case CanvasRenderMode.ScreenSpaceOverlay:
1832
- this._addCanvasListener();
1833
- case CanvasRenderMode.ScreenSpaceCamera:
1834
- this._adapterPoseInScreenSpace();
1835
- this._adapterSizeInScreenSpace();
1836
- case CanvasRenderMode.WorldSpace:
1837
- componentsManager.addUICanvas(this, curRealMode === CanvasRenderMode.ScreenSpaceOverlay);
1838
- break;
2359
+ };
2360
+ _proto._setIsRootCanvas = function _setIsRootCanvas(isRootCanvas) {
2361
+ var _this = this;
2362
+ if (this._isRootCanvas !== isRootCanvas) {
2363
+ this._isRootCanvas = isRootCanvas;
2364
+ this._updateCameraObserver();
2365
+ this._setRealRenderMode(this._getRealRenderMode());
2366
+ if (isRootCanvas) {
2367
+ this.entity._updateUIHierarchyVersion(UICanvas._hierarchyCounter);
2368
+ } else {
2369
+ var _this1 = this, disorderedElements = _this1._disorderedElements;
2370
+ disorderedElements.forEach(function(element) {
2371
+ if (_instanceof(element, UICanvas)) {
2372
+ var rootCanvas = Utils.searchRootCanvasInParents(element);
2373
+ element._setIsRootCanvas(!rootCanvas);
2374
+ Utils.setRootCanvas(element, rootCanvas);
2375
+ } else {
2376
+ Utils.setRootCanvasDirty(_this);
2377
+ Utils.setGroupDirty(element);
2378
+ }
2379
+ });
2380
+ disorderedElements.length = 0;
2381
+ disorderedElements.garbageCollection();
2382
+ this._orderedRenderers.length = 0;
2383
+ }
1839
2384
  }
1840
- }
1841
- };
1842
- _proto._isSameOrChildEntity = function _isSameOrChildEntity(cameraEntity) {
1843
- var canvasEntity = this.entity;
1844
- while(cameraEntity){
1845
- if (cameraEntity === canvasEntity) return true;
1846
- cameraEntity = cameraEntity.parent;
1847
- }
1848
- return false;
1849
- };
1850
- _create_class(UICanvas, [
1851
- {
1852
- key: "referenceResolutionPerUnit",
1853
- get: /**
2385
+ };
2386
+ _proto._getCenter = function _getCenter() {
2387
+ if (this._centerDirtyFlag.flag) {
2388
+ var center = this._center;
2389
+ var uiTransform = this.entity.transform;
2390
+ var pivot = uiTransform.pivot, size = uiTransform.size;
2391
+ center.set((0.5 - pivot.x) * size.x, (0.5 - pivot.y) * size.y, 0);
2392
+ engine.Vector3.transformCoordinate(center, uiTransform.worldMatrix, center);
2393
+ this._centerDirtyFlag.flag = false;
2394
+ }
2395
+ return this._center;
2396
+ };
2397
+ _proto._getRealRenderMode = function _getRealRenderMode() {
2398
+ if (this._isRootCanvas) {
2399
+ var _this__camera;
2400
+ var mode = this._renderMode;
2401
+ // @ts-ignore
2402
+ if (mode === CanvasRenderMode.ScreenSpaceCamera && !((_this__camera = this._camera) == null ? void 0 : _this__camera._phasedActiveInScene)) {
2403
+ return CanvasRenderMode.ScreenSpaceOverlay;
2404
+ } else {
2405
+ return mode;
2406
+ }
2407
+ } else {
2408
+ return 4;
2409
+ }
2410
+ };
2411
+ _proto._setRealRenderMode = function _setRealRenderMode(curRealMode) {
2412
+ var preRealMode = this._realRenderMode;
2413
+ if (preRealMode !== curRealMode) {
2414
+ this._realRenderMode = curRealMode;
2415
+ // @ts-ignore
2416
+ var componentsManager = this.scene._componentsManager;
2417
+ switch(preRealMode){
2418
+ case CanvasRenderMode.ScreenSpaceOverlay:
2419
+ this._removeCanvasListener();
2420
+ case CanvasRenderMode.ScreenSpaceCamera:
2421
+ case CanvasRenderMode.WorldSpace:
2422
+ componentsManager.removeUICanvas(this, preRealMode === CanvasRenderMode.ScreenSpaceOverlay);
2423
+ break;
2424
+ }
2425
+ switch(curRealMode){
2426
+ case CanvasRenderMode.ScreenSpaceOverlay:
2427
+ this._addCanvasListener();
2428
+ case CanvasRenderMode.ScreenSpaceCamera:
2429
+ this._adapterPoseInScreenSpace();
2430
+ this._adapterSizeInScreenSpace();
2431
+ case CanvasRenderMode.WorldSpace:
2432
+ componentsManager.addUICanvas(this, curRealMode === CanvasRenderMode.ScreenSpaceOverlay);
2433
+ break;
2434
+ }
2435
+ }
2436
+ };
2437
+ _proto._isSameOrChildEntity = function _isSameOrChildEntity(cameraEntity) {
2438
+ var canvasEntity = this.entity;
2439
+ while(cameraEntity){
2440
+ if (cameraEntity === canvasEntity) return true;
2441
+ cameraEntity = cameraEntity.parent;
2442
+ }
2443
+ return false;
2444
+ };
2445
+ _create_class(UICanvas, [
2446
+ {
2447
+ key: "referenceResolutionPerUnit",
2448
+ get: /**
1854
2449
  * The conversion ratio between reference resolution and unit for UI elements in this canvas.
1855
2450
  */ function get() {
1856
- return this._referenceResolutionPerUnit;
1857
- },
1858
- set: function set(value) {
1859
- if (this._referenceResolutionPerUnit !== value) {
1860
- this._referenceResolutionPerUnit = value;
1861
- this._disorderedElements.forEach(function(element) {
1862
- element._onRootCanvasModify == null ? void 0 : element._onRootCanvasModify.call(element, 1);
1863
- });
2451
+ return this._referenceResolutionPerUnit;
2452
+ },
2453
+ set: function set(value) {
2454
+ if (this._referenceResolutionPerUnit !== value) {
2455
+ this._referenceResolutionPerUnit = value;
2456
+ this._disorderedElements.forEach(function(element) {
2457
+ element._onRootCanvasModify == null ? void 0 : element._onRootCanvasModify.call(element, 1);
2458
+ });
2459
+ }
1864
2460
  }
1865
- }
1866
- },
1867
- {
1868
- key: "referenceResolution",
1869
- get: /**
2461
+ },
2462
+ {
2463
+ key: "referenceResolution",
2464
+ get: /**
1870
2465
  * The reference resolution of the UI canvas in `ScreenSpaceCamera` and `ScreenSpaceOverlay` mode.
1871
2466
  */ function get() {
1872
- return this._referenceResolution;
2467
+ return this._referenceResolution;
2468
+ },
2469
+ set: function set(value) {
2470
+ var referenceResolution = this._referenceResolution;
2471
+ if (referenceResolution === value) return;
2472
+ (referenceResolution.x !== value.x || referenceResolution.y !== value.y) && referenceResolution.copyFrom(value);
2473
+ }
1873
2474
  },
1874
- set: function set(value) {
1875
- var referenceResolution = this._referenceResolution;
1876
- if (referenceResolution === value) return;
1877
- (referenceResolution.x !== value.x || referenceResolution.y !== value.y) && referenceResolution.copyFrom(value);
1878
- }
1879
- },
1880
- {
1881
- key: "renderMode",
1882
- get: /**
2475
+ {
2476
+ key: "renderMode",
2477
+ get: /**
1883
2478
  * The rendering mode of the UI canvas.
1884
2479
  */ function get() {
1885
- return this._renderMode;
1886
- },
1887
- set: function set(mode) {
1888
- var preMode = this._renderMode;
1889
- if (preMode !== mode) {
1890
- this._renderMode = mode;
1891
- this._updateCameraObserver();
1892
- this._setRealRenderMode(this._getRealRenderMode());
2480
+ return this._renderMode;
2481
+ },
2482
+ set: function set(mode) {
2483
+ var preMode = this._renderMode;
2484
+ if (preMode !== mode) {
2485
+ this._renderMode = mode;
2486
+ this._updateCameraObserver();
2487
+ this._setRealRenderMode(this._getRealRenderMode());
2488
+ }
1893
2489
  }
1894
- }
1895
- },
1896
- {
1897
- key: "camera",
1898
- get: /**
2490
+ },
2491
+ {
2492
+ key: "camera",
2493
+ get: /**
1899
2494
  * The camera associated with this canvas.
1900
2495
  * @remarks
1901
2496
  * - `ScreenSpaceCamera` mode: Used for rendering adaptation. Defaults to `ScreenSpaceOverlay` if not assigned.
1902
2497
  * - `WorldSpace` mode: Used for event detection. If not assigned, events are handled by the highest-priority camera.
1903
2498
  */ function get() {
1904
- return this._camera;
1905
- },
1906
- set: function set(value) {
1907
- var preCamera = this._camera;
1908
- if (preCamera !== value) {
1909
- if (value && this._isSameOrChildEntity(value.entity)) {
1910
- engine.Logger.warn("Camera entity matching or nested within the canvas entity disables canvas auto-adaptation in ScreenSpaceCamera mode.");
1911
- }
1912
- this._camera = value;
1913
- this._updateCameraObserver();
1914
- var preRenderMode = this._realRenderMode;
1915
- var curRenderMode = this._getRealRenderMode();
1916
- if (preRenderMode === curRenderMode) {
1917
- if (curRenderMode === CanvasRenderMode.ScreenSpaceCamera) {
1918
- this._adapterPoseInScreenSpace();
1919
- this._adapterSizeInScreenSpace();
2499
+ return this._camera;
2500
+ },
2501
+ set: function set(value) {
2502
+ var preCamera = this._camera;
2503
+ if (preCamera !== value) {
2504
+ if (value && this._isSameOrChildEntity(value.entity)) {
2505
+ engine.Logger.warn("Camera entity matching or nested within the canvas entity disables canvas auto-adaptation in ScreenSpaceCamera mode.");
2506
+ }
2507
+ this._camera = value;
2508
+ this._updateCameraObserver();
2509
+ var preRenderMode = this._realRenderMode;
2510
+ var curRenderMode = this._getRealRenderMode();
2511
+ if (preRenderMode === curRenderMode) {
2512
+ if (curRenderMode === CanvasRenderMode.ScreenSpaceCamera) {
2513
+ this._adapterPoseInScreenSpace();
2514
+ this._adapterSizeInScreenSpace();
2515
+ }
2516
+ } else {
2517
+ this._setRealRenderMode(curRenderMode);
1920
2518
  }
1921
- } else {
1922
- this._setRealRenderMode(curRenderMode);
1923
2519
  }
1924
2520
  }
1925
- }
1926
- },
1927
- {
1928
- key: "renderCamera",
1929
- get: /**
2521
+ },
2522
+ {
2523
+ key: "renderCamera",
2524
+ get: /**
1930
2525
  * @deprecated Use {@link camera} instead.
1931
2526
  */ function get() {
1932
- return this.camera;
2527
+ return this.camera;
2528
+ },
2529
+ set: function set(value) {
2530
+ this.camera = value;
2531
+ }
1933
2532
  },
1934
- set: function set(value) {
1935
- this.camera = value;
1936
- }
1937
- },
1938
- {
1939
- key: "resolutionAdaptationMode",
1940
- get: /**
2533
+ {
2534
+ key: "resolutionAdaptationMode",
2535
+ get: /**
1941
2536
  * The screen resolution adaptation mode of the UI canvas in `ScreenSpaceCamera` and `ScreenSpaceOverlay` mode.
1942
2537
  */ function get() {
1943
- return this._resolutionAdaptationMode;
1944
- },
1945
- set: function set(value) {
1946
- if (this._resolutionAdaptationMode !== value) {
1947
- this._resolutionAdaptationMode = value;
1948
- var realRenderMode = this._realRenderMode;
1949
- if (realRenderMode === CanvasRenderMode.ScreenSpaceCamera || realRenderMode === CanvasRenderMode.ScreenSpaceOverlay) {
1950
- this._adapterSizeInScreenSpace();
2538
+ return this._resolutionAdaptationMode;
2539
+ },
2540
+ set: function set(value) {
2541
+ if (this._resolutionAdaptationMode !== value) {
2542
+ this._resolutionAdaptationMode = value;
2543
+ var realRenderMode = this._realRenderMode;
2544
+ if (realRenderMode === CanvasRenderMode.ScreenSpaceCamera || realRenderMode === CanvasRenderMode.ScreenSpaceOverlay) {
2545
+ this._adapterSizeInScreenSpace();
2546
+ }
1951
2547
  }
1952
2548
  }
1953
- }
1954
- },
1955
- {
1956
- key: "sortOrder",
1957
- get: /**
2549
+ },
2550
+ {
2551
+ key: "sortOrder",
2552
+ get: /**
1958
2553
  * The rendering order priority of the UI canvas in `ScreenSpaceOverlay` mode.
1959
2554
  */ function get() {
1960
- return this._sortOrder;
1961
- },
1962
- set: function set(value) {
1963
- if (this._sortOrder !== value) {
1964
- this._sortOrder = value;
1965
- this._realRenderMode === CanvasRenderMode.ScreenSpaceOverlay && // @ts-ignore
1966
- (this.scene._componentsManager._overlayCanvasesSortingFlag = true);
2555
+ return this._sortOrder;
2556
+ },
2557
+ set: function set(value) {
2558
+ if (this._sortOrder !== value) {
2559
+ this._sortOrder = value;
2560
+ this._realRenderMode === CanvasRenderMode.ScreenSpaceOverlay && // @ts-ignore
2561
+ (this.scene._componentsManager._overlayCanvasesSortingFlag = true);
2562
+ }
1967
2563
  }
1968
- }
1969
- },
1970
- {
1971
- key: "distance",
1972
- get: /**
2564
+ },
2565
+ {
2566
+ key: "distance",
2567
+ get: /**
1973
2568
  * The distance between the UI canvas and the camera in `ScreenSpaceCamera` mode.
1974
2569
  */ function get() {
1975
- return this._distance;
1976
- },
1977
- set: function set(value) {
1978
- if (this._distance !== value) {
1979
- this._distance = value;
1980
- if (this._realRenderMode === CanvasRenderMode.ScreenSpaceCamera) {
1981
- this._adapterPoseInScreenSpace();
1982
- this._adapterSizeInScreenSpace();
2570
+ return this._distance;
2571
+ },
2572
+ set: function set(value) {
2573
+ if (this._distance !== value) {
2574
+ this._distance = value;
2575
+ if (this._realRenderMode === CanvasRenderMode.ScreenSpaceCamera) {
2576
+ this._adapterPoseInScreenSpace();
2577
+ this._adapterSizeInScreenSpace();
2578
+ }
1983
2579
  }
1984
2580
  }
1985
2581
  }
1986
- }
1987
- ]);
1988
- return UICanvas;
1989
- }(engine.Component);
1990
- /** @internal */ exports.UICanvas._hierarchyCounter = 1;
1991
- exports.UICanvas._tempGroupAbleList = [];
1992
- exports.UICanvas._tempRectMaskList = [];
1993
- exports.UICanvas._tempVec3 = new engine.Vector3();
1994
- exports.UICanvas._tempMat = new engine.Matrix();
1995
- __decorate([
1996
- engine.ignoreClone
1997
- ], exports.UICanvas.prototype, "_canvasIndex", void 0);
1998
- __decorate([
1999
- engine.ignoreClone
2000
- ], exports.UICanvas.prototype, "_indexInRootCanvas", void 0);
2001
- __decorate([
2002
- engine.ignoreClone
2003
- ], exports.UICanvas.prototype, "_isRootCanvasDirty", void 0);
2004
- __decorate([
2005
- engine.ignoreClone
2006
- ], exports.UICanvas.prototype, "_rootCanvasListeningEntities", void 0);
2007
- __decorate([
2008
- engine.ignoreClone
2009
- ], exports.UICanvas.prototype, "_isRootCanvas", void 0);
2010
- __decorate([
2011
- engine.ignoreClone
2012
- ], exports.UICanvas.prototype, "_renderElements", void 0);
2013
- __decorate([
2014
- engine.ignoreClone
2015
- ], exports.UICanvas.prototype, "_batchedRenderElements", void 0);
2016
- __decorate([
2017
- engine.ignoreClone
2018
- ], exports.UICanvas.prototype, "_sortDistance", void 0);
2019
- __decorate([
2020
- engine.ignoreClone
2021
- ], exports.UICanvas.prototype, "_orderedRenderers", void 0);
2022
- __decorate([
2023
- engine.ignoreClone
2024
- ], exports.UICanvas.prototype, "_realRenderMode", void 0);
2025
- __decorate([
2026
- engine.ignoreClone
2027
- ], exports.UICanvas.prototype, "_renderMode", void 0);
2028
- __decorate([
2029
- engine.ignoreClone
2030
- ], exports.UICanvas.prototype, "_hierarchyVersion", void 0);
2031
- __decorate([
2032
- engine.ignoreClone
2033
- ], exports.UICanvas.prototype, "_center", void 0);
2034
- __decorate([
2035
- engine.ignoreClone
2036
- ], exports.UICanvas.prototype, "_rootCanvasListener", null);
2037
- __decorate([
2038
- engine.ignoreClone
2039
- ], exports.UICanvas.prototype, "_onCameraModifyListener", null);
2040
- __decorate([
2041
- engine.ignoreClone
2042
- ], exports.UICanvas.prototype, "_onCameraTransformListener", null);
2043
- __decorate([
2044
- engine.ignoreClone
2045
- ], exports.UICanvas.prototype, "_onCanvasSizeListener", null);
2046
- __decorate([
2047
- engine.ignoreClone
2048
- ], exports.UICanvas.prototype, "_onReferenceResolutionChanged", null);
2049
- exports.UICanvas = __decorate([
2050
- engine.dependentComponents(UITransform, engine.DependentMode.AutoAdd)
2051
- ], exports.UICanvas);
2582
+ ]);
2583
+ return UICanvas;
2584
+ }(_Component = engine.Component);
2585
+ var ref, ref1, ref2;
2586
+ ref = _apply_decs_2203_r(UICanvas, [
2587
+ [
2588
+ engine.ignoreClone,
2589
+ 0,
2590
+ "_canvasIndex"
2591
+ ],
2592
+ [
2593
+ engine.ignoreClone,
2594
+ 0,
2595
+ "_indexInRootCanvas"
2596
+ ],
2597
+ [
2598
+ engine.ignoreClone,
2599
+ 0,
2600
+ "_isRootCanvasDirty"
2601
+ ],
2602
+ [
2603
+ engine.ignoreClone,
2604
+ 0,
2605
+ "_rootCanvasListeningEntities"
2606
+ ],
2607
+ [
2608
+ engine.ignoreClone,
2609
+ 0,
2610
+ "_isRootCanvas"
2611
+ ],
2612
+ [
2613
+ engine.ignoreClone,
2614
+ 0,
2615
+ "_renderElements"
2616
+ ],
2617
+ [
2618
+ engine.ignoreClone,
2619
+ 0,
2620
+ "_batchedRenderElements"
2621
+ ],
2622
+ [
2623
+ engine.ignoreClone,
2624
+ 0,
2625
+ "_sortDistance"
2626
+ ],
2627
+ [
2628
+ engine.ignoreClone,
2629
+ 0,
2630
+ "_orderedRenderers"
2631
+ ],
2632
+ [
2633
+ engine.ignoreClone,
2634
+ 0,
2635
+ "_realRenderMode"
2636
+ ],
2637
+ [
2638
+ engine.ignoreClone,
2639
+ 0,
2640
+ "_renderMode"
2641
+ ],
2642
+ [
2643
+ engine.ignoreClone,
2644
+ 0,
2645
+ "_hierarchyVersion"
2646
+ ],
2647
+ [
2648
+ engine.ignoreClone,
2649
+ 0,
2650
+ "_center"
2651
+ ]
2652
+ ], [
2653
+ _dec$1
2654
+ ], _Component), ref1 = ref.e, _init__canvasIndex = ref1[0], _init__indexInRootCanvas$1 = ref1[1], _init__isRootCanvasDirty$1 = ref1[2], _init__rootCanvasListeningEntities$1 = ref1[3], _init__isRootCanvas = ref1[4], _init__renderElements = ref1[5], _init__batchedRenderElements = ref1[6], _init__sortDistance = ref1[7], _init__orderedRenderers = ref1[8], _init__realRenderMode = ref1[9], _init__renderMode = ref1[10], _init__hierarchyVersion = ref1[11], _init__center = ref1[12], ref2 = ref.c, exports.UICanvas = ref2[0], _initClass$1 = ref2[1];
2655
+ /** @internal */ UICanvas._hierarchyCounter = 1;
2656
+ UICanvas._tempGroupAbleList = [];
2657
+ UICanvas._tempRectMaskList = [];
2658
+ UICanvas._tempVec3 = new engine.Vector3();
2659
+ UICanvas._tempMat = new engine.Matrix();
2660
+ }(), _class$1)();
2052
2661
  /**
2053
2662
  * @remarks Extends `EntityModifyFlags`.
2054
2663
  */ var EntityUIModifyFlags = /*#__PURE__*/ function(EntityUIModifyFlags) {
@@ -2250,13 +2859,14 @@ Utils._tempPlane = new engine.Plane();
2250
2859
  Utils._tempVec3 = new engine.Vector3();
2251
2860
  Utils._tempMat = new engine.Matrix();
2252
2861
 
2862
+ var /** @internal */ _init__indexInRootCanvas, /** @internal */ _init__isRootCanvasDirty, /** @internal */ _init__rootCanvasListeningEntities, /** @internal */ _init__indexInGroup, /** @internal */ _init__isGroupDirty, /** @internal */ _init__groupListeningEntities, /** @internal */ _init__globalInteractive, /** @internal */ _init__globalInteractiveDirty, _init__state, /** @todo Multi-touch points are not considered yet. */ _init__isPointerInside, _init__isPointerDragging;
2253
2863
  /**
2254
2864
  * Interactive component.
2255
2865
  */ var UIInteractive = /*#__PURE__*/ function(Script) {
2256
2866
  _inherits(UIInteractive, Script);
2257
2867
  function UIInteractive(entity) {
2258
2868
  var _this;
2259
- _this = Script.call(this, entity) || this, /** @internal */ _this._indexInRootCanvas = -1, /** @internal */ _this._isRootCanvasDirty = false, /** @internal */ _this._rootCanvasListeningEntities = [], /** @internal */ _this._indexInGroup = -1, /** @internal */ _this._isGroupDirty = false, /** @internal */ _this._groupListeningEntities = [], /** @internal */ _this._globalInteractive = false, /** @internal */ _this._globalInteractiveDirty = false, _this._transitions = [], _this._interactive = true, _this._state = 0, /** @todo Multi-touch points are not considered yet. */ _this._isPointerInside = false, _this._isPointerDragging = false;
2869
+ _this = Script.call(this, entity) || this, _this._indexInRootCanvas = _init__indexInRootCanvas(_this, -1), _this._isRootCanvasDirty = _init__isRootCanvasDirty(_this, false), _this._rootCanvasListeningEntities = _init__rootCanvasListeningEntities(_this, []), _this._indexInGroup = _init__indexInGroup(_this, -1), _this._isGroupDirty = _init__isGroupDirty(_this, false), _this._groupListeningEntities = _init__groupListeningEntities(_this, []), _this._globalInteractive = _init__globalInteractive(_this, false), _this._globalInteractiveDirty = _init__globalInteractiveDirty(_this, false), _this._transitions = [], _this._interactive = true, _this._state = _init__state(_this, 0), _this._isPointerInside = _init__isPointerInside(_this, false), _this._isPointerDragging = _init__isPointerDragging(_this, false);
2260
2870
  _this._groupListener = _this._groupListener.bind(_this);
2261
2871
  _this._rootCanvasListener = _this._rootCanvasListener.bind(_this);
2262
2872
  return _this;
@@ -2439,48 +3049,64 @@ Utils._tempMat = new engine.Matrix();
2439
3049
  ]);
2440
3050
  return UIInteractive;
2441
3051
  }(engine.Script);
2442
- __decorate([
2443
- engine.ignoreClone
2444
- ], UIInteractive.prototype, "_indexInRootCanvas", void 0);
2445
- __decorate([
2446
- engine.ignoreClone
2447
- ], UIInteractive.prototype, "_isRootCanvasDirty", void 0);
2448
- __decorate([
2449
- engine.ignoreClone
2450
- ], UIInteractive.prototype, "_rootCanvasListeningEntities", void 0);
2451
- __decorate([
2452
- engine.ignoreClone
2453
- ], UIInteractive.prototype, "_indexInGroup", void 0);
2454
- __decorate([
2455
- engine.ignoreClone
2456
- ], UIInteractive.prototype, "_isGroupDirty", void 0);
2457
- __decorate([
2458
- engine.ignoreClone
2459
- ], UIInteractive.prototype, "_groupListeningEntities", void 0);
2460
- __decorate([
2461
- engine.ignoreClone
2462
- ], UIInteractive.prototype, "_globalInteractive", void 0);
2463
- __decorate([
2464
- engine.ignoreClone
2465
- ], UIInteractive.prototype, "_globalInteractiveDirty", void 0);
2466
- __decorate([
2467
- engine.ignoreClone
2468
- ], UIInteractive.prototype, "_state", void 0);
2469
- __decorate([
2470
- engine.ignoreClone
2471
- ], UIInteractive.prototype, "_isPointerInside", void 0);
2472
- __decorate([
2473
- engine.ignoreClone
2474
- ], UIInteractive.prototype, "_isPointerDragging", void 0);
2475
- __decorate([
2476
- engine.ignoreClone
2477
- ], UIInteractive.prototype, "_groupListener", null);
2478
- __decorate([
2479
- engine.ignoreClone
2480
- ], UIInteractive.prototype, "_rootCanvasListener", null);
2481
- __decorate([
2482
- engine.ignoreClone
2483
- ], UIInteractive.prototype, "_onGroupModify", null);
3052
+ var ref$3, ref1$3;
3053
+ ref$3 = _apply_decs_2203_r(UIInteractive, [
3054
+ [
3055
+ engine.ignoreClone,
3056
+ 0,
3057
+ "_indexInRootCanvas"
3058
+ ],
3059
+ [
3060
+ engine.ignoreClone,
3061
+ 0,
3062
+ "_isRootCanvasDirty"
3063
+ ],
3064
+ [
3065
+ engine.ignoreClone,
3066
+ 0,
3067
+ "_rootCanvasListeningEntities"
3068
+ ],
3069
+ [
3070
+ engine.ignoreClone,
3071
+ 0,
3072
+ "_indexInGroup"
3073
+ ],
3074
+ [
3075
+ engine.ignoreClone,
3076
+ 0,
3077
+ "_isGroupDirty"
3078
+ ],
3079
+ [
3080
+ engine.ignoreClone,
3081
+ 0,
3082
+ "_groupListeningEntities"
3083
+ ],
3084
+ [
3085
+ engine.ignoreClone,
3086
+ 0,
3087
+ "_globalInteractive"
3088
+ ],
3089
+ [
3090
+ engine.ignoreClone,
3091
+ 0,
3092
+ "_globalInteractiveDirty"
3093
+ ],
3094
+ [
3095
+ engine.ignoreClone,
3096
+ 0,
3097
+ "_state"
3098
+ ],
3099
+ [
3100
+ engine.ignoreClone,
3101
+ 0,
3102
+ "_isPointerInside"
3103
+ ],
3104
+ [
3105
+ engine.ignoreClone,
3106
+ 0,
3107
+ "_isPointerDragging"
3108
+ ]
3109
+ ], []), ref1$3 = ref$3.e, _init__indexInRootCanvas = ref1$3[0], _init__isRootCanvasDirty = ref1$3[1], _init__rootCanvasListeningEntities = ref1$3[2], _init__indexInGroup = ref1$3[3], _init__isGroupDirty = ref1$3[4], _init__groupListeningEntities = ref1$3[5], _init__globalInteractive = ref1$3[6], _init__globalInteractiveDirty = ref1$3[7], _init__state = ref1$3[8], _init__isPointerInside = ref1$3[9], _init__isPointerDragging = ref1$3[10];
2484
3110
  var InteractiveState = /*#__PURE__*/ function(InteractiveState) {
2485
3111
  InteractiveState[InteractiveState["Normal"] = 0] = "Normal";
2486
3112
  InteractiveState[InteractiveState["Pressed"] = 1] = "Pressed";
@@ -2520,13 +3146,14 @@ var Button = /*#__PURE__*/ function(UIInteractive) {
2520
3146
  return Button;
2521
3147
  }(UIInteractive);
2522
3148
 
3149
+ var _init__sprite, _init__drawMode, _init__assembler;
2523
3150
  /**
2524
3151
  * UI element that renders an image.
2525
3152
  */ var Image = /*#__PURE__*/ function(UIRenderer1) {
2526
3153
  _inherits(Image, UIRenderer1);
2527
3154
  function Image(entity) {
2528
3155
  var _this;
2529
- _this = UIRenderer1.call(this, entity) || this, _this._sprite = null, _this._tileMode = engine.SpriteTileMode.Continuous, _this._tiledAdaptiveThreshold = 0.5, _this._filledMode = engine.SpriteFilledMode.Radial360, _this._filledAmount = 1, _this._filledOrigin = engine.SpriteFilledOrigin.Bottom, _this._filledClockWise = true;
3156
+ _this = UIRenderer1.call(this, entity) || this, _this._sprite = _init__sprite(_this, null), _this._drawMode = _init__drawMode(_this), _this._assembler = _init__assembler(_this), _this._tileMode = engine.SpriteTileMode.Continuous, _this._tiledAdaptiveThreshold = 0.5, _this._filledMode = engine.SpriteFilledMode.Radial360, _this._filledAmount = 1, _this._filledOrigin = engine.SpriteFilledOrigin.Bottom, _this._filledClockWise = true;
2530
3157
  _this.drawMode = engine.SpriteDrawMode.Simple;
2531
3158
  // @ts-ignore
2532
3159
  _this.setMaterial(_this._engine._getUIDefaultMaterial());
@@ -2842,21 +3469,24 @@ var Button = /*#__PURE__*/ function(UIInteractive) {
2842
3469
  ]);
2843
3470
  return Image;
2844
3471
  }(exports.UIRenderer);
2845
- __decorate([
2846
- engine.ignoreClone
2847
- ], Image.prototype, "_sprite", void 0);
2848
- __decorate([
2849
- engine.ignoreClone
2850
- ], Image.prototype, "_drawMode", void 0);
2851
- __decorate([
2852
- engine.ignoreClone
2853
- ], Image.prototype, "_assembler", void 0);
2854
- __decorate([
2855
- engine.ignoreClone
2856
- ], Image.prototype, "_onTransformChanged", null);
2857
- __decorate([
2858
- engine.ignoreClone
2859
- ], Image.prototype, "_onSpriteChange", null);
3472
+ var ref$2, ref1$2;
3473
+ ref$2 = _apply_decs_2203_r(Image, [
3474
+ [
3475
+ engine.ignoreClone,
3476
+ 0,
3477
+ "_sprite"
3478
+ ],
3479
+ [
3480
+ engine.ignoreClone,
3481
+ 0,
3482
+ "_drawMode"
3483
+ ],
3484
+ [
3485
+ engine.ignoreClone,
3486
+ 0,
3487
+ "_assembler"
3488
+ ]
3489
+ ], []), ref1$2 = ref$2.e, _init__sprite = ref1$2[0], _init__drawMode = ref1$2[1], _init__assembler = ref1$2[2];
2860
3490
 
2861
3491
  /**
2862
3492
  * UI component that uses a sprite to mask child UI renderers via stencil.
@@ -2921,13 +3551,14 @@ __decorate([
2921
3551
  return Mask;
2922
3552
  }(engine.MaskRenderable(exports.UIRenderer));
2923
3553
 
3554
+ var _init__textChunks, _init__subFont, _init__localBounds;
2924
3555
  /**
2925
3556
  * UI component used to render text.
2926
3557
  */ var Text = /*#__PURE__*/ function(UIRenderer1) {
2927
3558
  _inherits(Text, UIRenderer1);
2928
3559
  function Text(entity) {
2929
3560
  var _this;
2930
- _this = UIRenderer1.call(this, entity) || this, _this._textChunks = Array(), _this._subFont = null, _this._text = "", _this._localBounds = new engine.BoundingBox(), _this._font = null, _this._fontSize = 24, _this._fontStyle = engine.FontStyle.None, _this._lineSpacing = 0, _this._characterSpacing = 0, _this._horizontalAlignment = engine.TextHorizontalAlignment.Center, _this._verticalAlignment = engine.TextVerticalAlignment.Center, _this._enableWrapping = false, _this._overflowMode = engine.OverflowMode.Overflow, _this._outlineColor = new engine.Color(0, 0, 0, 1), _this._outlineWidth = 0;
3561
+ _this = UIRenderer1.call(this, entity) || this, _this._textChunks = _init__textChunks(_this, Array()), _this._subFont = _init__subFont(_this, null), _this._text = "", _this._localBounds = _init__localBounds(_this, new engine.BoundingBox()), _this._font = null, _this._fontSize = 24, _this._fontStyle = engine.FontStyle.None, _this._lineSpacing = 0, _this._characterSpacing = 0, _this._horizontalAlignment = engine.TextHorizontalAlignment.Center, _this._verticalAlignment = engine.TextVerticalAlignment.Center, _this._enableWrapping = false, _this._overflowMode = engine.OverflowMode.Overflow, _this._outlineColor = new engine.Color(0, 0, 0, 1), _this._outlineWidth = 0;
2931
3562
  var engine$1 = _this.engine;
2932
3563
  // @ts-ignore
2933
3564
  _this.font = engine$1._textDefaultFont;
@@ -3527,6 +4158,24 @@ __decorate([
3527
4158
  ]);
3528
4159
  return Text;
3529
4160
  }(exports.UIRenderer);
4161
+ var ref$1, ref1$1;
4162
+ ref$1 = _apply_decs_2203_r(Text, [
4163
+ [
4164
+ engine.ignoreClone,
4165
+ 0,
4166
+ "_textChunks"
4167
+ ],
4168
+ [
4169
+ engine.ignoreClone,
4170
+ 0,
4171
+ "_subFont"
4172
+ ],
4173
+ [
4174
+ engine.ignoreClone,
4175
+ 0,
4176
+ "_localBounds"
4177
+ ]
4178
+ ], []), ref1$1 = ref$1.e, _init__textChunks = ref1$1[0], _init__subFont = ref1$1[1], _init__localBounds = ref1$1[2];
3530
4179
  Text._textTextureProperty = engine.ShaderProperty.getByName("renderElement_TextTexture");
3531
4180
  Text._textTextureSizeProperty = engine.ShaderProperty.getByName("renderElement_TextTextureSize");
3532
4181
  Text._outlineColorProperty = engine.ShaderProperty.getByName("renderer_OutlineColor");
@@ -3538,32 +4187,18 @@ Text._worldPositions = [
3538
4187
  new engine.Vector3()
3539
4188
  ];
3540
4189
  Text._charRenderInfos = [];
3541
- __decorate([
3542
- engine.ignoreClone
3543
- ], Text.prototype, "_textChunks", void 0);
3544
- __decorate([
3545
- engine.ignoreClone
3546
- ], Text.prototype, "_subFont", void 0);
3547
- __decorate([
3548
- engine.ignoreClone
3549
- ], Text.prototype, "_localBounds", void 0);
3550
- __decorate([
3551
- engine.ignoreClone
3552
- ], Text.prototype, "_onTransformChanged", null);
3553
- __decorate([
3554
- engine.ignoreClone
3555
- ], Text.prototype, "_onOutlineColorChanged", null);
3556
4190
  var TextChunk = function TextChunk() {
3557
4191
  this.charRenderInfos = new Array();
3558
4192
  };
3559
4193
 
4194
+ var _init__countDown, _init__initialValue, _init__finalValue, _init__currentValue, _init__finalState;
3560
4195
  /**
3561
4196
  * The transition behavior of UIInteractive.
3562
4197
  */ var Transition = /*#__PURE__*/ function(DataObject) {
3563
4198
  _inherits(Transition, DataObject);
3564
4199
  function Transition() {
3565
4200
  var _this;
3566
- _this = DataObject.apply(this, arguments) || this, _this._duration = 0, _this._countDown = 0, _this._finalState = InteractiveState.Normal;
4201
+ _this = DataObject.apply(this, arguments) || this, _this._duration = 0, _this._countDown = _init__countDown(_this, 0), _this._initialValue = _init__initialValue(_this), _this._finalValue = _init__finalValue(_this), _this._currentValue = _init__currentValue(_this), _this._finalState = _init__finalState(_this, InteractiveState.Normal);
3567
4202
  return _this;
3568
4203
  }
3569
4204
  var _proto = Transition.prototype;
@@ -3739,21 +4374,34 @@ var TextChunk = function TextChunk() {
3739
4374
  ]);
3740
4375
  return Transition;
3741
4376
  }(engine.DataObject);
3742
- __decorate([
3743
- engine.ignoreClone
3744
- ], Transition.prototype, "_countDown", void 0);
3745
- __decorate([
3746
- engine.ignoreClone
3747
- ], Transition.prototype, "_initialValue", void 0);
3748
- __decorate([
3749
- engine.ignoreClone
3750
- ], Transition.prototype, "_finalValue", void 0);
3751
- __decorate([
3752
- engine.ignoreClone
3753
- ], Transition.prototype, "_currentValue", void 0);
3754
- __decorate([
3755
- engine.ignoreClone
3756
- ], Transition.prototype, "_finalState", void 0);
4377
+ var ref, ref1;
4378
+ ref = _apply_decs_2203_r(Transition, [
4379
+ [
4380
+ engine.ignoreClone,
4381
+ 0,
4382
+ "_countDown"
4383
+ ],
4384
+ [
4385
+ engine.ignoreClone,
4386
+ 0,
4387
+ "_initialValue"
4388
+ ],
4389
+ [
4390
+ engine.ignoreClone,
4391
+ 0,
4392
+ "_finalValue"
4393
+ ],
4394
+ [
4395
+ engine.ignoreClone,
4396
+ 0,
4397
+ "_currentValue"
4398
+ ],
4399
+ [
4400
+ engine.ignoreClone,
4401
+ 0,
4402
+ "_finalState"
4403
+ ]
4404
+ ], []), ref1 = ref.e, _init__countDown = ref1[0], _init__initialValue = ref1[1], _init__finalValue = ref1[2], _init__currentValue = ref1[3], _init__finalState = ref1[4];
3757
4405
 
3758
4406
  /**
3759
4407
  * Color transition.
@@ -3902,233 +4550,248 @@ var GUIComponent = /*#__PURE__*/Object.freeze({
3902
4550
  this.component = null;
3903
4551
  };
3904
4552
 
3905
- exports.UIPointerEventEmitter = /*#__PURE__*/ function(PointerEventEmitter1) {
3906
- _inherits(UIPointerEventEmitter, PointerEventEmitter1);
3907
- function UIPointerEventEmitter() {
4553
+ var _class;
4554
+ var _dec, _initClass, _PointerEventEmitter;
4555
+ exports.UIPointerEventEmitter = void 0;
4556
+ _dec = engine.registerPointerEventEmitter();
4557
+ new (_class = /*#__PURE__*/ function(_identity) {
4558
+ _inherits(_class, _identity);
4559
+ function _class() {
3908
4560
  var _this;
3909
- _this = PointerEventEmitter1.apply(this, arguments) || this, _this._enteredPath = [], _this._pressedPath = [], _this._draggedPath = [];
4561
+ _this = _identity.apply(this, arguments) || this, _initClass();
3910
4562
  return _this;
3911
4563
  }
3912
- var _proto = UIPointerEventEmitter.prototype;
3913
- _proto._init = function _init() {
3914
- this._hitResult = new UIHitResult();
3915
- };
3916
- _proto.processRaycast = function processRaycast(scenes, pointer) {
3917
- var ray = engine.PointerEventEmitter._tempRay;
3918
- var hitResult = this._hitResult;
3919
- var position = pointer.position;
3920
- var x = position.x, y = position.y;
3921
- for(var i = scenes.length - 1; i >= 0; i--){
3922
- var scene = scenes[i];
3923
- if (!scene.isActive || scene.destroyed) continue;
3924
- // @ts-ignore
3925
- var componentsManager = scene._componentsManager;
3926
- // Overlay Canvas
3927
- var canvasElements = componentsManager._overlayCanvases;
3928
- // Screen to world ( Assume that world units have a one-to-one relationship with pixel units )
3929
- ray.origin.set(position.x, scene.engine.canvas.height - position.y, 1);
3930
- ray.direction.set(0, 0, -1);
3931
- for(var j = canvasElements.length - 1; j >= 0; j--){
3932
- if (canvasElements.get(j)._raycast(ray, hitResult)) {
3933
- this._updateRaycast(hitResult.component, pointer);
3934
- return;
4564
+ return _class;
4565
+ }(_identity), function() {
4566
+ var UIPointerEventEmitter = /*#__PURE__*/ function(_superClass) {
4567
+ _inherits(UIPointerEventEmitter, _superClass);
4568
+ function UIPointerEventEmitter() {
4569
+ var _this;
4570
+ _this = _superClass.apply(this, arguments) || this, _this._enteredPath = [], _this._pressedPath = [], _this._draggedPath = [];
4571
+ return _this;
4572
+ }
4573
+ var _proto = UIPointerEventEmitter.prototype;
4574
+ _proto._init = function _init() {
4575
+ this._hitResult = new UIHitResult();
4576
+ };
4577
+ _proto.processRaycast = function processRaycast(scenes, pointer) {
4578
+ var ray = engine.PointerEventEmitter._tempRay;
4579
+ var hitResult = this._hitResult;
4580
+ var position = pointer.position;
4581
+ var x = position.x, y = position.y;
4582
+ for(var i = scenes.length - 1; i >= 0; i--){
4583
+ var scene = scenes[i];
4584
+ if (!scene.isActive || scene.destroyed) continue;
4585
+ // @ts-ignore
4586
+ var componentsManager = scene._componentsManager;
4587
+ // Overlay Canvas
4588
+ var canvasElements = componentsManager._overlayCanvases;
4589
+ // Screen to world ( Assume that world units have a one-to-one relationship with pixel units )
4590
+ ray.origin.set(position.x, scene.engine.canvas.height - position.y, 1);
4591
+ ray.direction.set(0, 0, -1);
4592
+ for(var j = canvasElements.length - 1; j >= 0; j--){
4593
+ if (canvasElements.get(j)._raycast(ray, hitResult)) {
4594
+ this._updateRaycast(hitResult.component, pointer);
4595
+ return;
4596
+ }
4597
+ }
4598
+ var cameras = componentsManager._activeCameras;
4599
+ for(var j1 = cameras.length - 1; j1 >= 0; j1--){
4600
+ var camera = cameras.get(j1);
4601
+ if (camera.renderTarget) continue;
4602
+ var pixelViewport = camera.pixelViewport;
4603
+ if (x < pixelViewport.x || y < pixelViewport.y || x > pixelViewport.x + pixelViewport.width || y > pixelViewport.y + pixelViewport.height) {
4604
+ continue;
4605
+ }
4606
+ camera.screenPointToRay(pointer.position, ray);
4607
+ // Other canvases
4608
+ var isOrthographic = camera.isOrthographic;
4609
+ var _camera_entity_transform = camera.entity.transform, cameraPosition = _camera_entity_transform.worldPosition, cameraForward = _camera_entity_transform.worldForward;
4610
+ // Sort by rendering order
4611
+ canvasElements = componentsManager._canvases;
4612
+ for(var k = 0, n = canvasElements.length; k < n; k++){
4613
+ canvasElements.get(k)._updateSortDistance(isOrthographic, cameraPosition, cameraForward);
4614
+ }
4615
+ canvasElements.sort(function(a, b) {
4616
+ return a.sortOrder - b.sortOrder || a._sortDistance - b._sortDistance;
4617
+ });
4618
+ for(var k1 = 0, n1 = canvasElements.length; k1 < n1; k1++){
4619
+ canvasElements.get(k1)._canvasIndex = k1;
4620
+ }
4621
+ var farClipPlane = camera.farClipPlane;
4622
+ // Post-rendering first detection
4623
+ for(var k2 = 0, n2 = canvasElements.length; k2 < n2; k2++){
4624
+ var canvas = canvasElements.get(k2);
4625
+ if (!canvas._canDispatchEvent(camera)) continue;
4626
+ if (canvas._raycast(ray, hitResult, farClipPlane)) {
4627
+ this._updateRaycast(hitResult.component, pointer);
4628
+ return;
4629
+ }
4630
+ }
4631
+ if (camera.clearFlags & engine.CameraClearFlags.Color) {
4632
+ this._updateRaycast(null, pointer);
4633
+ return;
4634
+ }
3935
4635
  }
4636
+ this._updateRaycast(null, pointer);
3936
4637
  }
3937
- var cameras = componentsManager._activeCameras;
3938
- for(var j1 = cameras.length - 1; j1 >= 0; j1--){
3939
- var camera = cameras.get(j1);
3940
- if (camera.renderTarget) continue;
3941
- var pixelViewport = camera.pixelViewport;
3942
- if (x < pixelViewport.x || y < pixelViewport.y || x > pixelViewport.x + pixelViewport.width || y > pixelViewport.y + pixelViewport.height) {
3943
- continue;
4638
+ };
4639
+ _proto.processDrag = function processDrag(pointer) {
4640
+ var draggedPath = this._draggedPath;
4641
+ if (draggedPath.length > 0) {
4642
+ this._bubble(draggedPath, pointer, this._fireDrag);
4643
+ }
4644
+ };
4645
+ _proto.processDown = function processDown(pointer) {
4646
+ var enteredPath = this._enteredPath;
4647
+ var pressedPath = this._pressedPath;
4648
+ var draggedPath = this._draggedPath;
4649
+ var length = draggedPath.length = pressedPath.length = enteredPath.length;
4650
+ if (length > 0) {
4651
+ for(var i = 0; i < length; i++){
4652
+ pressedPath[i] = draggedPath[i] = enteredPath[i];
3944
4653
  }
3945
- camera.screenPointToRay(pointer.position, ray);
3946
- // Other canvases
3947
- var isOrthographic = camera.isOrthographic;
3948
- var _camera_entity_transform = camera.entity.transform, cameraPosition = _camera_entity_transform.worldPosition, cameraForward = _camera_entity_transform.worldForward;
3949
- // Sort by rendering order
3950
- canvasElements = componentsManager._canvases;
3951
- for(var k = 0, n = canvasElements.length; k < n; k++){
3952
- canvasElements.get(k)._updateSortDistance(isOrthographic, cameraPosition, cameraForward);
4654
+ this._bubble(pressedPath, pointer, this._fireDown);
4655
+ this._bubble(draggedPath, pointer, this._fireBeginDrag);
4656
+ }
4657
+ };
4658
+ _proto.processUp = function processUp(pointer) {
4659
+ var enteredPath = this._enteredPath;
4660
+ var pressedPath = this._pressedPath;
4661
+ if (enteredPath.length > 0) {
4662
+ this._bubble(enteredPath, pointer, this._fireUp);
4663
+ if (pressedPath.length > 0) {
4664
+ var common = UIPointerEventEmitter._tempArray0;
4665
+ if (this._findCommonInPath(enteredPath, pressedPath, common)) {
4666
+ this._bubble(common, pointer, this._fireClick);
4667
+ common.length = 0;
4668
+ }
3953
4669
  }
3954
- canvasElements.sort(function(a, b) {
3955
- return a.sortOrder - b.sortOrder || a._sortDistance - b._sortDistance;
3956
- });
3957
- for(var k1 = 0, n1 = canvasElements.length; k1 < n1; k1++){
3958
- canvasElements.get(k1)._canvasIndex = k1;
4670
+ }
4671
+ pressedPath.length = 0;
4672
+ var draggedPath = this._draggedPath;
4673
+ if (draggedPath.length > 0) {
4674
+ this._bubble(draggedPath, pointer, this._fireEndDrag);
4675
+ draggedPath.length = 0;
4676
+ }
4677
+ if (enteredPath.length > 0) {
4678
+ this._bubble(enteredPath, pointer, this._fireDrop);
4679
+ }
4680
+ };
4681
+ _proto.processLeave = function processLeave(pointer) {
4682
+ var enteredPath = this._enteredPath;
4683
+ if (enteredPath.length > 0) {
4684
+ this._bubble(enteredPath, pointer, this._fireExit);
4685
+ enteredPath.length = 0;
4686
+ }
4687
+ var draggedPath = this._draggedPath;
4688
+ if (draggedPath.length > 0) {
4689
+ this._bubble(draggedPath, pointer, this._fireEndDrag);
4690
+ draggedPath.length = 0;
4691
+ }
4692
+ this._pressedPath.length = 0;
4693
+ };
4694
+ _proto.dispose = function dispose() {
4695
+ this._enteredPath.length = this._pressedPath.length = this._draggedPath.length = 0;
4696
+ };
4697
+ _proto._updateRaycast = function _updateRaycast(element, pointer) {
4698
+ var enteredPath = this._enteredPath;
4699
+ var curPath = this._composedPath(element, UIPointerEventEmitter._path);
4700
+ var add = UIPointerEventEmitter._tempArray0;
4701
+ var del = UIPointerEventEmitter._tempArray1;
4702
+ if (this._findDiffInPath(enteredPath, curPath, add, del)) {
4703
+ for(var i = 0, n = add.length; i < n; i++){
4704
+ this._fireEnter(add[i], this._createEventData(pointer, add[i]));
3959
4705
  }
3960
- var farClipPlane = camera.farClipPlane;
3961
- // Post-rendering first detection
3962
- for(var k2 = 0, n2 = canvasElements.length; k2 < n2; k2++){
3963
- var canvas = canvasElements.get(k2);
3964
- if (!canvas._canDispatchEvent(camera)) continue;
3965
- if (canvas._raycast(ray, hitResult, farClipPlane)) {
3966
- this._updateRaycast(hitResult.component, pointer);
3967
- return;
3968
- }
4706
+ for(var i1 = 0, n1 = del.length; i1 < n1; i1++){
4707
+ this._fireExit(del[i1], this._createEventData(pointer, del[i1]));
3969
4708
  }
3970
- if (camera.clearFlags & engine.CameraClearFlags.Color) {
3971
- this._updateRaycast(null, pointer);
3972
- return;
4709
+ var length = enteredPath.length = curPath.length;
4710
+ for(var i2 = 0; i2 < length; i2++){
4711
+ enteredPath[i2] = curPath[i2];
3973
4712
  }
4713
+ add.length = del.length = 0;
3974
4714
  }
3975
- this._updateRaycast(null, pointer);
3976
- }
3977
- };
3978
- _proto.processDrag = function processDrag(pointer) {
3979
- var draggedPath = this._draggedPath;
3980
- if (draggedPath.length > 0) {
3981
- this._bubble(draggedPath, pointer, this._fireDrag);
3982
- }
3983
- };
3984
- _proto.processDown = function processDown(pointer) {
3985
- var enteredPath = this._enteredPath;
3986
- var pressedPath = this._pressedPath;
3987
- var draggedPath = this._draggedPath;
3988
- var length = draggedPath.length = pressedPath.length = enteredPath.length;
3989
- if (length > 0) {
3990
- for(var i = 0; i < length; i++){
3991
- pressedPath[i] = draggedPath[i] = enteredPath[i];
4715
+ curPath.length = 0;
4716
+ };
4717
+ _proto._composedPath = function _composedPath(element, path) {
4718
+ if (!element) {
4719
+ path.length = 0;
4720
+ return path;
3992
4721
  }
3993
- this._bubble(pressedPath, pointer, this._fireDown);
3994
- this._bubble(draggedPath, pointer, this._fireBeginDrag);
3995
- }
3996
- };
3997
- _proto.processUp = function processUp(pointer) {
3998
- var enteredPath = this._enteredPath;
3999
- var pressedPath = this._pressedPath;
4000
- if (enteredPath.length > 0) {
4001
- this._bubble(enteredPath, pointer, this._fireUp);
4002
- if (pressedPath.length > 0) {
4003
- var common = UIPointerEventEmitter._tempArray0;
4004
- if (this._findCommonInPath(enteredPath, pressedPath, common)) {
4005
- this._bubble(common, pointer, this._fireClick);
4006
- common.length = 0;
4007
- }
4722
+ var entity = path[0] = element.entity;
4723
+ var i = 1;
4724
+ var rootEntity = element._getRootCanvas().entity;
4725
+ for(; i < UIPointerEventEmitter._MAX_PATH_DEPTH && !!entity && entity !== rootEntity; i++){
4726
+ entity = path[i] = entity.parent;
4008
4727
  }
4009
- }
4010
- pressedPath.length = 0;
4011
- var draggedPath = this._draggedPath;
4012
- if (draggedPath.length > 0) {
4013
- this._bubble(draggedPath, pointer, this._fireEndDrag);
4014
- draggedPath.length = 0;
4015
- }
4016
- if (enteredPath.length > 0) {
4017
- this._bubble(enteredPath, pointer, this._fireDrop);
4018
- }
4019
- };
4020
- _proto.processLeave = function processLeave(pointer) {
4021
- var enteredPath = this._enteredPath;
4022
- if (enteredPath.length > 0) {
4023
- this._bubble(enteredPath, pointer, this._fireExit);
4024
- enteredPath.length = 0;
4025
- }
4026
- var draggedPath = this._draggedPath;
4027
- if (draggedPath.length > 0) {
4028
- this._bubble(draggedPath, pointer, this._fireEndDrag);
4029
- draggedPath.length = 0;
4030
- }
4031
- this._pressedPath.length = 0;
4032
- };
4033
- _proto.dispose = function dispose() {
4034
- this._enteredPath.length = this._pressedPath.length = this._draggedPath.length = 0;
4035
- };
4036
- _proto._updateRaycast = function _updateRaycast(element, pointer) {
4037
- var enteredPath = this._enteredPath;
4038
- var curPath = this._composedPath(element, UIPointerEventEmitter._path);
4039
- var add = UIPointerEventEmitter._tempArray0;
4040
- var del = UIPointerEventEmitter._tempArray1;
4041
- if (this._findDiffInPath(enteredPath, curPath, add, del)) {
4042
- for(var i = 0, n = add.length; i < n; i++){
4043
- this._fireEnter(add[i], this._createEventData(pointer, add[i]));
4044
- }
4045
- for(var i1 = 0, n1 = del.length; i1 < n1; i1++){
4046
- this._fireExit(del[i1], this._createEventData(pointer, del[i1]));
4047
- }
4048
- var length = enteredPath.length = curPath.length;
4049
- for(var i2 = 0; i2 < length; i2++){
4050
- enteredPath[i2] = curPath[i2];
4051
- }
4052
- add.length = del.length = 0;
4053
- }
4054
- curPath.length = 0;
4055
- };
4056
- _proto._composedPath = function _composedPath(element, path) {
4057
- if (!element) {
4058
- path.length = 0;
4728
+ path.length = i;
4059
4729
  return path;
4060
- }
4061
- var entity = path[0] = element.entity;
4062
- var i = 1;
4063
- var rootEntity = element._getRootCanvas().entity;
4064
- for(; i < UIPointerEventEmitter._MAX_PATH_DEPTH && !!entity && entity !== rootEntity; i++){
4065
- entity = path[i] = entity.parent;
4066
- }
4067
- path.length = i;
4068
- return path;
4069
- };
4070
- _proto._findCommonInPath = function _findCommonInPath(prePath, curPath, common) {
4071
- var idSet = UIPointerEventEmitter._tempSet;
4072
- idSet.clear();
4073
- for(var i = 0, n = prePath.length; i < n; i++){
4074
- idSet.add(prePath[i].instanceId);
4075
- }
4076
- var hasCommon = false;
4077
- for(var i1 = 0, n1 = curPath.length; i1 < n1; i1++){
4078
- var entity = curPath[i1];
4079
- if (idSet.has(entity.instanceId)) {
4080
- common.push(entity);
4081
- hasCommon = true;
4730
+ };
4731
+ _proto._findCommonInPath = function _findCommonInPath(prePath, curPath, common) {
4732
+ var idSet = UIPointerEventEmitter._tempSet;
4733
+ idSet.clear();
4734
+ for(var i = 0, n = prePath.length; i < n; i++){
4735
+ idSet.add(prePath[i].instanceId);
4082
4736
  }
4083
- }
4084
- return hasCommon;
4085
- };
4086
- _proto._findDiffInPath = function _findDiffInPath(prePath, curPath, add, del) {
4087
- var idSet = UIPointerEventEmitter._tempSet;
4088
- idSet.clear();
4089
- var changed = false;
4090
- for(var i = 0, n = prePath.length; i < n; i++){
4091
- idSet.add(prePath[i].instanceId);
4092
- }
4093
- for(var i1 = 0, n1 = curPath.length; i1 < n1; i1++){
4094
- var entity = curPath[i1];
4095
- if (!idSet.has(entity.instanceId)) {
4096
- add.push(entity);
4097
- changed = true;
4737
+ var hasCommon = false;
4738
+ for(var i1 = 0, n1 = curPath.length; i1 < n1; i1++){
4739
+ var entity = curPath[i1];
4740
+ if (idSet.has(entity.instanceId)) {
4741
+ common.push(entity);
4742
+ hasCommon = true;
4743
+ }
4098
4744
  }
4099
- }
4100
- idSet.clear();
4101
- for(var i2 = 0, n2 = curPath.length; i2 < n2; i2++){
4102
- idSet.add(curPath[i2].instanceId);
4103
- }
4104
- for(var i3 = 0, n3 = prePath.length; i3 < n3; i3++){
4105
- var entity1 = prePath[i3];
4106
- if (!idSet.has(entity1.instanceId)) {
4107
- del.push(entity1);
4108
- changed = true;
4745
+ return hasCommon;
4746
+ };
4747
+ _proto._findDiffInPath = function _findDiffInPath(prePath, curPath, add, del) {
4748
+ var idSet = UIPointerEventEmitter._tempSet;
4749
+ idSet.clear();
4750
+ var changed = false;
4751
+ for(var i = 0, n = prePath.length; i < n; i++){
4752
+ idSet.add(prePath[i].instanceId);
4109
4753
  }
4110
- }
4111
- return changed;
4112
- };
4113
- _proto._bubble = function _bubble(path, pointer, fireEvent) {
4114
- var length = path.length;
4115
- if (length <= 0) return;
4116
- var eventData = this._createEventData(pointer, path[0]);
4117
- for(var i = 0; i < length; i++){
4118
- eventData.currentTarget = path[i];
4119
- fireEvent(path[i], eventData);
4120
- }
4121
- };
4122
- return UIPointerEventEmitter;
4123
- }(engine.PointerEventEmitter);
4124
- exports.UIPointerEventEmitter._MAX_PATH_DEPTH = 2048;
4125
- exports.UIPointerEventEmitter._tempSet = new Set();
4126
- exports.UIPointerEventEmitter._path = [];
4127
- exports.UIPointerEventEmitter._tempArray0 = [];
4128
- exports.UIPointerEventEmitter._tempArray1 = [];
4129
- exports.UIPointerEventEmitter = __decorate([
4130
- engine.registerPointerEventEmitter()
4131
- ], exports.UIPointerEventEmitter);
4754
+ for(var i1 = 0, n1 = curPath.length; i1 < n1; i1++){
4755
+ var entity = curPath[i1];
4756
+ if (!idSet.has(entity.instanceId)) {
4757
+ add.push(entity);
4758
+ changed = true;
4759
+ }
4760
+ }
4761
+ idSet.clear();
4762
+ for(var i2 = 0, n2 = curPath.length; i2 < n2; i2++){
4763
+ idSet.add(curPath[i2].instanceId);
4764
+ }
4765
+ for(var i3 = 0, n3 = prePath.length; i3 < n3; i3++){
4766
+ var entity1 = prePath[i3];
4767
+ if (!idSet.has(entity1.instanceId)) {
4768
+ del.push(entity1);
4769
+ changed = true;
4770
+ }
4771
+ }
4772
+ return changed;
4773
+ };
4774
+ _proto._bubble = function _bubble(path, pointer, fireEvent) {
4775
+ var length = path.length;
4776
+ if (length <= 0) return;
4777
+ var eventData = this._createEventData(pointer, path[0]);
4778
+ for(var i = 0; i < length; i++){
4779
+ eventData.currentTarget = path[i];
4780
+ fireEvent(path[i], eventData);
4781
+ }
4782
+ };
4783
+ return UIPointerEventEmitter;
4784
+ }(_PointerEventEmitter = engine.PointerEventEmitter);
4785
+ var ref, ref1;
4786
+ ref = _apply_decs_2203_r(UIPointerEventEmitter, [], [
4787
+ _dec
4788
+ ], _PointerEventEmitter), ref1 = ref.c, exports.UIPointerEventEmitter = ref1[0], _initClass = ref1[1];
4789
+ UIPointerEventEmitter._MAX_PATH_DEPTH = 2048;
4790
+ UIPointerEventEmitter._tempSet = new Set();
4791
+ UIPointerEventEmitter._path = [];
4792
+ UIPointerEventEmitter._tempArray0 = [];
4793
+ UIPointerEventEmitter._tempArray1 = [];
4794
+ }(), _class)();
4132
4795
 
4133
4796
  var EngineExtension = /*#__PURE__*/ function() {
4134
4797
  function EngineExtension() {}