@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/browser.js +4872 -0
- package/dist/browser.js.map +1 -0
- package/dist/browser.min.js +2 -0
- package/dist/browser.min.js.map +1 -0
- package/dist/main.js +2072 -1409
- package/dist/main.js.map +1 -1
- package/dist/module.js +2089 -1426
- package/dist/module.js.map +1 -1
- package/package.json +3 -3
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
|
-
|
|
68
|
-
|
|
69
|
-
|
|
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
|
-
|
|
658
|
-
|
|
659
|
-
|
|
660
|
-
|
|
661
|
-
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
|
|
666
|
-
|
|
667
|
-
|
|
668
|
-
]
|
|
669
|
-
|
|
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
|
-
|
|
685
|
-
|
|
686
|
-
|
|
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 =
|
|
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
|
-
|
|
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
|
-
|
|
699
|
-
|
|
700
|
-
|
|
701
|
-
|
|
702
|
-
|
|
703
|
-
|
|
704
|
-
|
|
705
|
-
|
|
706
|
-
|
|
707
|
-
|
|
708
|
-
|
|
709
|
-
|
|
710
|
-
|
|
711
|
-
|
|
712
|
-
|
|
713
|
-
|
|
714
|
-
|
|
715
|
-
|
|
716
|
-
|
|
717
|
-
|
|
718
|
-
|
|
719
|
-
|
|
720
|
-
|
|
721
|
-
|
|
722
|
-
|
|
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
|
-
|
|
728
|
-
|
|
729
|
-
|
|
730
|
-
|
|
731
|
-
|
|
732
|
-
|
|
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
|
-
|
|
751
|
-
|
|
752
|
-
|
|
1268
|
+
_proto._onEnableInScene = function _onEnableInScene() {
|
|
1269
|
+
this.entity._updateUIHierarchyVersion(exports.UICanvas._hierarchyCounter);
|
|
1270
|
+
};
|
|
753
1271
|
// @ts-ignore
|
|
754
|
-
|
|
755
|
-
|
|
756
|
-
|
|
757
|
-
|
|
758
|
-
|
|
759
|
-
|
|
760
|
-
|
|
761
|
-
|
|
762
|
-
|
|
763
|
-
|
|
764
|
-
|
|
765
|
-
|
|
766
|
-
|
|
767
|
-
|
|
768
|
-
|
|
769
|
-
|
|
770
|
-
|
|
771
|
-
|
|
772
|
-
|
|
773
|
-
|
|
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
|
-
|
|
777
|
-
|
|
778
|
-
|
|
779
|
-
|
|
780
|
-
|
|
781
|
-
|
|
782
|
-
|
|
783
|
-
|
|
784
|
-
|
|
785
|
-
|
|
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
|
-
|
|
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
|
-
|
|
795
|
-
|
|
796
|
-
|
|
797
|
-
|
|
1327
|
+
return this._alphaClip;
|
|
1328
|
+
},
|
|
1329
|
+
set: function set(value) {
|
|
1330
|
+
this._alphaClip = value;
|
|
1331
|
+
}
|
|
798
1332
|
}
|
|
799
|
-
|
|
800
|
-
|
|
801
|
-
|
|
802
|
-
|
|
803
|
-
|
|
804
|
-
|
|
805
|
-
exports.RectMask2D
|
|
806
|
-
|
|
807
|
-
|
|
808
|
-
|
|
809
|
-
|
|
810
|
-
|
|
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,
|
|
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
|
-
|
|
969
|
-
|
|
970
|
-
|
|
971
|
-
|
|
972
|
-
|
|
973
|
-
|
|
974
|
-
|
|
975
|
-
|
|
976
|
-
|
|
977
|
-
|
|
978
|
-
|
|
979
|
-
],
|
|
980
|
-
|
|
981
|
-
|
|
982
|
-
|
|
983
|
-
|
|
984
|
-
|
|
985
|
-
|
|
986
|
-
|
|
987
|
-
|
|
988
|
-
|
|
989
|
-
|
|
990
|
-
|
|
991
|
-
|
|
992
|
-
|
|
993
|
-
|
|
994
|
-
],
|
|
995
|
-
|
|
996
|
-
|
|
997
|
-
|
|
998
|
-
|
|
999
|
-
|
|
1000
|
-
|
|
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
|
-
|
|
1010
|
-
|
|
1011
|
-
|
|
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 =
|
|
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
|
-
|
|
1029
|
-
|
|
1030
|
-
|
|
1031
|
-
|
|
1032
|
-
|
|
1033
|
-
|
|
1034
|
-
|
|
1035
|
-
|
|
1036
|
-
|
|
1037
|
-
|
|
1038
|
-
|
|
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
|
-
|
|
1041
|
-
|
|
1042
|
-
|
|
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
|
-
|
|
1059
|
-
|
|
1060
|
-
|
|
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
|
-
|
|
1067
|
-
|
|
1068
|
-
|
|
1069
|
-
|
|
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
|
-
|
|
1075
|
-
|
|
1076
|
-
|
|
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
|
-
|
|
1082
|
-
|
|
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
|
-
|
|
1088
|
-
|
|
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
|
-
|
|
1094
|
-
|
|
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
|
-
|
|
1101
|
-
|
|
1102
|
-
|
|
1103
|
-
|
|
1104
|
-
|
|
1105
|
-
|
|
1106
|
-
|
|
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
|
-
|
|
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
|
-
|
|
1123
|
-
|
|
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
|
-
|
|
1129
|
-
|
|
1130
|
-
|
|
1131
|
-
|
|
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
|
-
|
|
1138
|
-
|
|
1139
|
-
|
|
1140
|
-
|
|
1141
|
-
|
|
1142
|
-
|
|
1143
|
-
|
|
1144
|
-
|
|
1145
|
-
|
|
1146
|
-
|
|
1147
|
-
|
|
1148
|
-
|
|
1149
|
-
|
|
1150
|
-
|
|
1151
|
-
|
|
1152
|
-
|
|
1153
|
-
|
|
1154
|
-
|
|
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
|
-
|
|
1159
|
-
|
|
1160
|
-
|
|
1161
|
-
|
|
1162
|
-
|
|
1163
|
-
|
|
1164
|
-
|
|
1165
|
-
|
|
1166
|
-
|
|
1167
|
-
|
|
1168
|
-
|
|
1169
|
-
|
|
1170
|
-
|
|
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
|
-
|
|
1174
|
-
|
|
1175
|
-
|
|
1176
|
-
|
|
1177
|
-
|
|
1178
|
-
|
|
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
|
-
|
|
1188
|
-
|
|
1189
|
-
|
|
1190
|
-
|
|
1191
|
-
|
|
1192
|
-
|
|
1193
|
-
|
|
1194
|
-
|
|
1195
|
-
|
|
1196
|
-
|
|
1197
|
-
|
|
1198
|
-
|
|
1199
|
-
|
|
1200
|
-
|
|
1201
|
-
|
|
1202
|
-
|
|
1203
|
-
|
|
1204
|
-
|
|
1205
|
-
|
|
1206
|
-
|
|
1207
|
-
|
|
1208
|
-
|
|
1209
|
-
|
|
1210
|
-
|
|
1211
|
-
|
|
1212
|
-
|
|
1213
|
-
|
|
1214
|
-
|
|
1215
|
-
|
|
1216
|
-
|
|
1217
|
-
|
|
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
|
-
|
|
1814
|
+
clipSoftnessLeft = 0;
|
|
1815
|
+
clipSoftnessBottom = 0;
|
|
1816
|
+
clipSoftnessRight = 0;
|
|
1817
|
+
clipSoftnessTop = 0;
|
|
1223
1818
|
}
|
|
1224
|
-
|
|
1225
|
-
|
|
1226
|
-
|
|
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
|
-
|
|
1229
|
-
|
|
1230
|
-
clipSoftnessBottom
|
|
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 (
|
|
1233
|
-
|
|
1234
|
-
|
|
1829
|
+
if (this._rectMaskHardClip !== clipHardClip) {
|
|
1830
|
+
this._rectMaskHardClip = clipHardClip;
|
|
1831
|
+
this.shaderData.setFloat(UIRenderer._rectClipHardClipProperty, clipHardClip ? 1 : 0);
|
|
1235
1832
|
}
|
|
1236
|
-
if (
|
|
1237
|
-
|
|
1238
|
-
|
|
1833
|
+
if (!this._rectMaskEnabled) {
|
|
1834
|
+
this._rectMaskEnabled = true;
|
|
1835
|
+
this.shaderData.setFloat(UIRenderer._rectClipEnabledProperty, 1);
|
|
1239
1836
|
}
|
|
1240
|
-
}
|
|
1241
|
-
|
|
1242
|
-
this.
|
|
1243
|
-
|
|
1244
|
-
|
|
1245
|
-
|
|
1246
|
-
|
|
1247
|
-
|
|
1248
|
-
|
|
1249
|
-
|
|
1250
|
-
|
|
1251
|
-
|
|
1252
|
-
|
|
1253
|
-
|
|
1254
|
-
|
|
1255
|
-
|
|
1256
|
-
|
|
1257
|
-
|
|
1258
|
-
|
|
1259
|
-
|
|
1260
|
-
|
|
1261
|
-
|
|
1262
|
-
|
|
1263
|
-
this.
|
|
1264
|
-
|
|
1265
|
-
|
|
1266
|
-
this.
|
|
1267
|
-
|
|
1268
|
-
|
|
1269
|
-
|
|
1270
|
-
|
|
1271
|
-
|
|
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
|
-
|
|
1308
|
-
|
|
1309
|
-
|
|
1310
|
-
|
|
1311
|
-
|
|
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
|
-
|
|
1317
|
-
get: /**
|
|
1878
|
+
},
|
|
1879
|
+
{
|
|
1880
|
+
key: "maskLayer",
|
|
1881
|
+
get: /**
|
|
1318
1882
|
* The mask layer the ui renderer belongs to.
|
|
1319
1883
|
*/ function get() {
|
|
1320
|
-
|
|
1884
|
+
return this._maskLayer;
|
|
1885
|
+
},
|
|
1886
|
+
set: function set(value) {
|
|
1887
|
+
this._maskLayer = value;
|
|
1888
|
+
}
|
|
1321
1889
|
},
|
|
1322
|
-
|
|
1323
|
-
|
|
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
|
-
|
|
1332
|
-
|
|
1333
|
-
|
|
1334
|
-
|
|
1335
|
-
|
|
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
|
-
|
|
1341
|
-
get: /**
|
|
1902
|
+
},
|
|
1903
|
+
{
|
|
1904
|
+
key: "raycastEnabled",
|
|
1905
|
+
get: /**
|
|
1342
1906
|
* Whether this renderer be picked up by raycast.
|
|
1343
1907
|
*/ function get() {
|
|
1344
|
-
|
|
1345
|
-
|
|
1346
|
-
|
|
1347
|
-
|
|
1908
|
+
return this._raycastEnabled;
|
|
1909
|
+
},
|
|
1910
|
+
set: function set(value) {
|
|
1911
|
+
this._raycastEnabled = value;
|
|
1912
|
+
}
|
|
1348
1913
|
}
|
|
1349
|
-
|
|
1350
|
-
|
|
1351
|
-
|
|
1352
|
-
|
|
1353
|
-
|
|
1354
|
-
|
|
1355
|
-
|
|
1356
|
-
|
|
1357
|
-
|
|
1358
|
-
|
|
1359
|
-
|
|
1360
|
-
|
|
1361
|
-
|
|
1362
|
-
|
|
1363
|
-
|
|
1364
|
-
|
|
1365
|
-
|
|
1366
|
-
|
|
1367
|
-
|
|
1368
|
-
|
|
1369
|
-
|
|
1370
|
-
|
|
1371
|
-
|
|
1372
|
-
|
|
1373
|
-
|
|
1374
|
-
|
|
1375
|
-
|
|
1376
|
-
|
|
1377
|
-
|
|
1378
|
-
],
|
|
1379
|
-
|
|
1380
|
-
|
|
1381
|
-
|
|
1382
|
-
|
|
1383
|
-
|
|
1384
|
-
|
|
1385
|
-
|
|
1386
|
-
|
|
1387
|
-
|
|
1388
|
-
|
|
1389
|
-
|
|
1390
|
-
|
|
1391
|
-
|
|
1392
|
-
|
|
1393
|
-
],
|
|
1394
|
-
|
|
1395
|
-
|
|
1396
|
-
|
|
1397
|
-
|
|
1398
|
-
|
|
1399
|
-
|
|
1400
|
-
|
|
1401
|
-
|
|
1402
|
-
|
|
1403
|
-
|
|
1404
|
-
|
|
1405
|
-
|
|
1406
|
-
|
|
1407
|
-
|
|
1408
|
-
],
|
|
1409
|
-
|
|
1410
|
-
|
|
1411
|
-
|
|
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
|
-
|
|
1420
|
-
|
|
1421
|
-
|
|
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 =
|
|
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
|
-
|
|
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
|
-
|
|
1439
|
-
|
|
1440
|
-
|
|
1441
|
-
|
|
1442
|
-
|
|
1443
|
-
|
|
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
|
-
|
|
1447
|
-
|
|
1448
|
-
|
|
1449
|
-
|
|
1450
|
-
|
|
1451
|
-
|
|
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
|
-
|
|
1457
|
-
|
|
1458
|
-
|
|
2051
|
+
return this._rootCanvas;
|
|
2052
|
+
};
|
|
2053
|
+
/**
|
|
1459
2054
|
* @internal
|
|
1460
2055
|
*/ _proto._canRender = function _canRender(camera) {
|
|
1461
|
-
|
|
1462
|
-
|
|
1463
|
-
|
|
2056
|
+
return this._realRenderMode !== CanvasRenderMode.ScreenSpaceCamera || this._camera === camera;
|
|
2057
|
+
};
|
|
2058
|
+
/**
|
|
1464
2059
|
* @internal
|
|
1465
2060
|
*/ _proto._canDispatchEvent = function _canDispatchEvent(camera) {
|
|
1466
|
-
|
|
1467
|
-
|
|
1468
|
-
|
|
1469
|
-
|
|
1470
|
-
|
|
1471
|
-
|
|
1472
|
-
|
|
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
|
-
|
|
1478
|
-
|
|
1479
|
-
|
|
1480
|
-
|
|
1481
|
-
|
|
1482
|
-
|
|
1483
|
-
|
|
1484
|
-
|
|
1485
|
-
|
|
1486
|
-
|
|
1487
|
-
|
|
1488
|
-
|
|
1489
|
-
|
|
1490
|
-
|
|
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
|
-
|
|
1510
|
-
|
|
1511
|
-
|
|
1512
|
-
|
|
1513
|
-
|
|
1514
|
-
|
|
1515
|
-
|
|
1516
|
-
|
|
1517
|
-
|
|
1518
|
-
|
|
1519
|
-
|
|
1520
|
-
|
|
1521
|
-
|
|
1522
|
-
|
|
1523
|
-
|
|
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
|
-
|
|
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
|
-
|
|
1574
|
-
|
|
1575
|
-
|
|
1576
|
-
|
|
1577
|
-
|
|
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
|
-
|
|
1583
|
-
|
|
1584
|
-
|
|
1585
|
-
|
|
1586
|
-
|
|
1587
|
-
|
|
1588
|
-
|
|
1589
|
-
|
|
1590
|
-
|
|
1591
|
-
|
|
1592
|
-
|
|
1593
|
-
|
|
1594
|
-
|
|
1595
|
-
|
|
1596
|
-
|
|
1597
|
-
|
|
1598
|
-
|
|
1599
|
-
|
|
1600
|
-
|
|
1601
|
-
|
|
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
|
-
|
|
1662
|
-
|
|
1663
|
-
|
|
1664
|
-
|
|
1665
|
-
|
|
1666
|
-
|
|
1667
|
-
|
|
1668
|
-
|
|
1669
|
-
|
|
1670
|
-
|
|
1671
|
-
|
|
1672
|
-
|
|
1673
|
-
|
|
1674
|
-
|
|
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
|
-
|
|
1677
|
-
|
|
1678
|
-
|
|
1679
|
-
|
|
1680
|
-
|
|
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
|
-
|
|
1691
|
-
|
|
1692
|
-
|
|
1693
|
-
|
|
1694
|
-
|
|
1695
|
-
|
|
1696
|
-
|
|
1697
|
-
|
|
1698
|
-
|
|
1699
|
-
|
|
1700
|
-
|
|
1701
|
-
|
|
1702
|
-
|
|
1703
|
-
|
|
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
|
-
|
|
1715
|
-
|
|
1716
|
-
|
|
1717
|
-
|
|
1718
|
-
|
|
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
|
-
|
|
1723
|
-
|
|
1724
|
-
|
|
1725
|
-
|
|
1726
|
-
|
|
1727
|
-
|
|
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
|
|
1730
|
-
|
|
2231
|
+
case ResolutionAdaptationMode.HeightAdaptation:
|
|
2232
|
+
expectX = expectY = expectZ = curHeight / height;
|
|
1731
2233
|
break;
|
|
1732
|
-
case
|
|
1733
|
-
|
|
2234
|
+
case ResolutionAdaptationMode.BothAdaptation:
|
|
2235
|
+
expectX = curWidth / width;
|
|
2236
|
+
expectY = curHeight / height;
|
|
2237
|
+
expectZ = (expectX + expectY) * 0.5;
|
|
1734
2238
|
break;
|
|
1735
|
-
case
|
|
1736
|
-
|
|
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
|
-
|
|
1740
|
-
|
|
1741
|
-
|
|
1742
|
-
|
|
1743
|
-
|
|
1744
|
-
|
|
1745
|
-
|
|
1746
|
-
|
|
1747
|
-
|
|
1748
|
-
|
|
1749
|
-
|
|
1750
|
-
|
|
1751
|
-
|
|
1752
|
-
|
|
1753
|
-
|
|
1754
|
-
|
|
1755
|
-
|
|
1756
|
-
|
|
1757
|
-
|
|
1758
|
-
|
|
1759
|
-
|
|
1760
|
-
|
|
1761
|
-
|
|
1762
|
-
|
|
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
|
-
|
|
1786
|
-
|
|
1787
|
-
|
|
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
|
-
|
|
1792
|
-
|
|
1793
|
-
|
|
1794
|
-
|
|
1795
|
-
var
|
|
1796
|
-
|
|
1797
|
-
|
|
1798
|
-
|
|
1799
|
-
|
|
1800
|
-
|
|
1801
|
-
|
|
1802
|
-
|
|
1803
|
-
|
|
1804
|
-
var
|
|
1805
|
-
|
|
1806
|
-
|
|
1807
|
-
|
|
1808
|
-
|
|
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
|
-
|
|
2335
|
+
flag === engine.CameraModifyFlags.EnableInScene && this._setRealRenderMode(CanvasRenderMode.ScreenSpaceCamera);
|
|
1811
2336
|
}
|
|
1812
|
-
}
|
|
1813
|
-
|
|
1814
|
-
|
|
1815
|
-
|
|
1816
|
-
|
|
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
|
-
|
|
1822
|
-
|
|
1823
|
-
|
|
1824
|
-
|
|
1825
|
-
|
|
1826
|
-
|
|
1827
|
-
|
|
1828
|
-
|
|
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
|
-
|
|
1831
|
-
|
|
1832
|
-
|
|
1833
|
-
|
|
1834
|
-
|
|
1835
|
-
|
|
1836
|
-
|
|
1837
|
-
|
|
1838
|
-
|
|
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
|
-
|
|
1843
|
-
|
|
1844
|
-
|
|
1845
|
-
|
|
1846
|
-
|
|
1847
|
-
|
|
1848
|
-
|
|
1849
|
-
|
|
1850
|
-
|
|
1851
|
-
|
|
1852
|
-
|
|
1853
|
-
|
|
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
|
-
|
|
1857
|
-
|
|
1858
|
-
|
|
1859
|
-
|
|
1860
|
-
|
|
1861
|
-
|
|
1862
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
1875
|
-
|
|
1876
|
-
|
|
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
|
-
|
|
1886
|
-
|
|
1887
|
-
|
|
1888
|
-
|
|
1889
|
-
|
|
1890
|
-
|
|
1891
|
-
|
|
1892
|
-
|
|
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
|
-
|
|
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
|
-
|
|
1905
|
-
|
|
1906
|
-
|
|
1907
|
-
|
|
1908
|
-
|
|
1909
|
-
|
|
1910
|
-
|
|
1911
|
-
|
|
1912
|
-
|
|
1913
|
-
|
|
1914
|
-
|
|
1915
|
-
|
|
1916
|
-
|
|
1917
|
-
|
|
1918
|
-
|
|
1919
|
-
|
|
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
|
-
|
|
1929
|
-
get: /**
|
|
2521
|
+
},
|
|
2522
|
+
{
|
|
2523
|
+
key: "renderCamera",
|
|
2524
|
+
get: /**
|
|
1930
2525
|
* @deprecated Use {@link camera} instead.
|
|
1931
2526
|
*/ function get() {
|
|
1932
|
-
|
|
2527
|
+
return this.camera;
|
|
2528
|
+
},
|
|
2529
|
+
set: function set(value) {
|
|
2530
|
+
this.camera = value;
|
|
2531
|
+
}
|
|
1933
2532
|
},
|
|
1934
|
-
|
|
1935
|
-
|
|
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
|
-
|
|
1944
|
-
|
|
1945
|
-
|
|
1946
|
-
|
|
1947
|
-
|
|
1948
|
-
|
|
1949
|
-
|
|
1950
|
-
|
|
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
|
-
|
|
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
|
-
|
|
1961
|
-
|
|
1962
|
-
|
|
1963
|
-
|
|
1964
|
-
|
|
1965
|
-
|
|
1966
|
-
|
|
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
|
-
|
|
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
|
-
|
|
1976
|
-
|
|
1977
|
-
|
|
1978
|
-
|
|
1979
|
-
|
|
1980
|
-
|
|
1981
|
-
|
|
1982
|
-
|
|
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
|
-
|
|
1989
|
-
|
|
1990
|
-
|
|
1991
|
-
|
|
1992
|
-
|
|
1993
|
-
|
|
1994
|
-
|
|
1995
|
-
|
|
1996
|
-
|
|
1997
|
-
|
|
1998
|
-
|
|
1999
|
-
|
|
2000
|
-
],
|
|
2001
|
-
|
|
2002
|
-
|
|
2003
|
-
|
|
2004
|
-
|
|
2005
|
-
|
|
2006
|
-
|
|
2007
|
-
|
|
2008
|
-
|
|
2009
|
-
|
|
2010
|
-
|
|
2011
|
-
|
|
2012
|
-
|
|
2013
|
-
|
|
2014
|
-
|
|
2015
|
-
],
|
|
2016
|
-
|
|
2017
|
-
|
|
2018
|
-
|
|
2019
|
-
|
|
2020
|
-
|
|
2021
|
-
|
|
2022
|
-
|
|
2023
|
-
|
|
2024
|
-
|
|
2025
|
-
|
|
2026
|
-
|
|
2027
|
-
|
|
2028
|
-
|
|
2029
|
-
|
|
2030
|
-
],
|
|
2031
|
-
|
|
2032
|
-
|
|
2033
|
-
|
|
2034
|
-
|
|
2035
|
-
|
|
2036
|
-
|
|
2037
|
-
|
|
2038
|
-
|
|
2039
|
-
|
|
2040
|
-
|
|
2041
|
-
|
|
2042
|
-
|
|
2043
|
-
|
|
2044
|
-
|
|
2045
|
-
],
|
|
2046
|
-
|
|
2047
|
-
|
|
2048
|
-
|
|
2049
|
-
|
|
2050
|
-
|
|
2051
|
-
|
|
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,
|
|
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
|
-
|
|
2443
|
-
|
|
2444
|
-
|
|
2445
|
-
|
|
2446
|
-
|
|
2447
|
-
|
|
2448
|
-
|
|
2449
|
-
|
|
2450
|
-
|
|
2451
|
-
|
|
2452
|
-
|
|
2453
|
-
],
|
|
2454
|
-
|
|
2455
|
-
|
|
2456
|
-
|
|
2457
|
-
|
|
2458
|
-
|
|
2459
|
-
|
|
2460
|
-
|
|
2461
|
-
|
|
2462
|
-
|
|
2463
|
-
|
|
2464
|
-
|
|
2465
|
-
|
|
2466
|
-
|
|
2467
|
-
|
|
2468
|
-
],
|
|
2469
|
-
|
|
2470
|
-
|
|
2471
|
-
|
|
2472
|
-
|
|
2473
|
-
|
|
2474
|
-
|
|
2475
|
-
|
|
2476
|
-
|
|
2477
|
-
|
|
2478
|
-
|
|
2479
|
-
|
|
2480
|
-
|
|
2481
|
-
|
|
2482
|
-
|
|
2483
|
-
],
|
|
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
|
-
|
|
2846
|
-
|
|
2847
|
-
|
|
2848
|
-
|
|
2849
|
-
|
|
2850
|
-
|
|
2851
|
-
|
|
2852
|
-
|
|
2853
|
-
|
|
2854
|
-
|
|
2855
|
-
|
|
2856
|
-
],
|
|
2857
|
-
|
|
2858
|
-
|
|
2859
|
-
|
|
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
|
-
|
|
3743
|
-
|
|
3744
|
-
|
|
3745
|
-
|
|
3746
|
-
|
|
3747
|
-
|
|
3748
|
-
|
|
3749
|
-
|
|
3750
|
-
|
|
3751
|
-
|
|
3752
|
-
|
|
3753
|
-
],
|
|
3754
|
-
|
|
3755
|
-
|
|
3756
|
-
|
|
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
|
-
|
|
3906
|
-
|
|
3907
|
-
|
|
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 =
|
|
4561
|
+
_this = _identity.apply(this, arguments) || this, _initClass();
|
|
3910
4562
|
return _this;
|
|
3911
4563
|
}
|
|
3912
|
-
|
|
3913
|
-
|
|
3914
|
-
|
|
3915
|
-
|
|
3916
|
-
|
|
3917
|
-
|
|
3918
|
-
|
|
3919
|
-
|
|
3920
|
-
|
|
3921
|
-
|
|
3922
|
-
|
|
3923
|
-
|
|
3924
|
-
|
|
3925
|
-
|
|
3926
|
-
|
|
3927
|
-
var
|
|
3928
|
-
|
|
3929
|
-
|
|
3930
|
-
|
|
3931
|
-
|
|
3932
|
-
if (
|
|
3933
|
-
|
|
3934
|
-
|
|
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
|
-
|
|
3938
|
-
|
|
3939
|
-
|
|
3940
|
-
|
|
3941
|
-
|
|
3942
|
-
|
|
3943
|
-
|
|
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
|
-
|
|
3946
|
-
|
|
3947
|
-
|
|
3948
|
-
|
|
3949
|
-
|
|
3950
|
-
|
|
3951
|
-
|
|
3952
|
-
|
|
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
|
-
|
|
3955
|
-
|
|
3956
|
-
|
|
3957
|
-
|
|
3958
|
-
|
|
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
|
|
3961
|
-
|
|
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
|
-
|
|
3971
|
-
|
|
3972
|
-
|
|
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
|
-
|
|
3976
|
-
}
|
|
3977
|
-
|
|
3978
|
-
|
|
3979
|
-
|
|
3980
|
-
|
|
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
|
-
|
|
3994
|
-
|
|
3995
|
-
|
|
3996
|
-
|
|
3997
|
-
|
|
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
|
-
|
|
4062
|
-
|
|
4063
|
-
|
|
4064
|
-
|
|
4065
|
-
|
|
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
|
-
|
|
4085
|
-
|
|
4086
|
-
|
|
4087
|
-
|
|
4088
|
-
|
|
4089
|
-
|
|
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
|
-
|
|
4101
|
-
|
|
4102
|
-
idSet.
|
|
4103
|
-
|
|
4104
|
-
|
|
4105
|
-
var
|
|
4106
|
-
|
|
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
|
-
|
|
4112
|
-
|
|
4113
|
-
|
|
4114
|
-
|
|
4115
|
-
|
|
4116
|
-
|
|
4117
|
-
|
|
4118
|
-
|
|
4119
|
-
|
|
4120
|
-
|
|
4121
|
-
|
|
4122
|
-
|
|
4123
|
-
|
|
4124
|
-
|
|
4125
|
-
|
|
4126
|
-
|
|
4127
|
-
|
|
4128
|
-
|
|
4129
|
-
|
|
4130
|
-
|
|
4131
|
-
|
|
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() {}
|