@dcl/playground-assets 7.0.6-3807227301.commit-1045452 → 7.0.6-3808797047.commit-ee7ea04
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/alpha.d.ts +279 -82
- package/dist/beta.d.ts +279 -82
- package/dist/index.bundled.d.ts +279 -82
- package/dist/index.js +1211 -538
- package/dist/index.js.map +1 -1
- package/dist/index.min.js +1 -1
- package/dist/index.min.js.map +1 -1
- package/dist/playground/sdk/dcl-sdk.package.json +8 -2
- package/dist/playground/snippets/info.json +1 -1
- package/dist/playground/snippets/pointer-events.ts +6 -4
- package/dist/playground/snippets/ui-backgrounds.tsx +192 -0
- package/dist/playground/snippets/ui-dropdown.tsx +32 -0
- package/dist/playground/snippets/ui.tsx +17 -14
- package/dist/playground-assets.d.ts +280 -83
- package/etc/playground-assets.api.json +2901 -894
- package/etc/playground-assets.api.md +263 -94
- package/package.json +3 -3
package/dist/index.js
CHANGED
|
@@ -7471,17 +7471,17 @@
|
|
|
7471
7471
|
}
|
|
7472
7472
|
}
|
|
7473
7473
|
return message;
|
|
7474
|
-
}
|
|
7474
|
+
},
|
|
7475
7475
|
};
|
|
7476
7476
|
function createBasePBAnimationState() {
|
|
7477
7477
|
return {
|
|
7478
|
-
name:
|
|
7479
|
-
clip:
|
|
7478
|
+
name: "",
|
|
7479
|
+
clip: "",
|
|
7480
7480
|
playing: undefined,
|
|
7481
7481
|
weight: undefined,
|
|
7482
7482
|
speed: undefined,
|
|
7483
7483
|
loop: undefined,
|
|
7484
|
-
shouldReset: undefined
|
|
7484
|
+
shouldReset: undefined,
|
|
7485
7485
|
};
|
|
7486
7486
|
}
|
|
7487
7487
|
/**
|
|
@@ -7489,10 +7489,10 @@
|
|
|
7489
7489
|
*/
|
|
7490
7490
|
const PBAnimationState = {
|
|
7491
7491
|
encode(message, writer = minimalExports.Writer.create()) {
|
|
7492
|
-
if (message.name !==
|
|
7492
|
+
if (message.name !== "") {
|
|
7493
7493
|
writer.uint32(10).string(message.name);
|
|
7494
7494
|
}
|
|
7495
|
-
if (message.clip !==
|
|
7495
|
+
if (message.clip !== "") {
|
|
7496
7496
|
writer.uint32(18).string(message.clip);
|
|
7497
7497
|
}
|
|
7498
7498
|
if (message.playing !== undefined) {
|
|
@@ -7546,7 +7546,7 @@
|
|
|
7546
7546
|
}
|
|
7547
7547
|
}
|
|
7548
7548
|
return message;
|
|
7549
|
-
}
|
|
7549
|
+
},
|
|
7550
7550
|
};
|
|
7551
7551
|
|
|
7552
7552
|
/**
|
|
@@ -7570,7 +7570,7 @@
|
|
|
7570
7570
|
|
|
7571
7571
|
/* eslint-disable */
|
|
7572
7572
|
function createBasePBAudioSource() {
|
|
7573
|
-
return { playing: undefined, volume: undefined, loop: undefined, pitch: undefined, audioClipUrl:
|
|
7573
|
+
return { playing: undefined, volume: undefined, loop: undefined, pitch: undefined, audioClipUrl: "" };
|
|
7574
7574
|
}
|
|
7575
7575
|
/**
|
|
7576
7576
|
* Internal
|
|
@@ -7589,7 +7589,7 @@
|
|
|
7589
7589
|
if (message.pitch !== undefined) {
|
|
7590
7590
|
writer.uint32(37).float(message.pitch);
|
|
7591
7591
|
}
|
|
7592
|
-
if (message.audioClipUrl !==
|
|
7592
|
+
if (message.audioClipUrl !== "") {
|
|
7593
7593
|
writer.uint32(42).string(message.audioClipUrl);
|
|
7594
7594
|
}
|
|
7595
7595
|
return writer;
|
|
@@ -7622,7 +7622,7 @@
|
|
|
7622
7622
|
}
|
|
7623
7623
|
}
|
|
7624
7624
|
return message;
|
|
7625
|
-
}
|
|
7625
|
+
},
|
|
7626
7626
|
};
|
|
7627
7627
|
|
|
7628
7628
|
/**
|
|
@@ -7646,7 +7646,7 @@
|
|
|
7646
7646
|
|
|
7647
7647
|
/* eslint-disable */
|
|
7648
7648
|
function createBasePBAudioStream() {
|
|
7649
|
-
return { playing: undefined, volume: undefined, url:
|
|
7649
|
+
return { playing: undefined, volume: undefined, url: "" };
|
|
7650
7650
|
}
|
|
7651
7651
|
/**
|
|
7652
7652
|
* Internal
|
|
@@ -7659,7 +7659,7 @@
|
|
|
7659
7659
|
if (message.volume !== undefined) {
|
|
7660
7660
|
writer.uint32(21).float(message.volume);
|
|
7661
7661
|
}
|
|
7662
|
-
if (message.url !==
|
|
7662
|
+
if (message.url !== "") {
|
|
7663
7663
|
writer.uint32(26).string(message.url);
|
|
7664
7664
|
}
|
|
7665
7665
|
return writer;
|
|
@@ -7686,7 +7686,7 @@
|
|
|
7686
7686
|
}
|
|
7687
7687
|
}
|
|
7688
7688
|
return message;
|
|
7689
|
-
}
|
|
7689
|
+
},
|
|
7690
7690
|
};
|
|
7691
7691
|
|
|
7692
7692
|
/**
|
|
@@ -7717,14 +7717,14 @@
|
|
|
7717
7717
|
AvatarAnchorPointType[AvatarAnchorPointType["AAPT_RIGHT_HAND"] = 3] = "AAPT_RIGHT_HAND";
|
|
7718
7718
|
})(exports.AvatarAnchorPointType || (exports.AvatarAnchorPointType = {}));
|
|
7719
7719
|
function createBasePBAvatarAttach() {
|
|
7720
|
-
return { avatarId:
|
|
7720
|
+
return { avatarId: "", anchorPointId: 0 };
|
|
7721
7721
|
}
|
|
7722
7722
|
/**
|
|
7723
7723
|
* Internal
|
|
7724
7724
|
*/
|
|
7725
7725
|
const PBAvatarAttach = {
|
|
7726
7726
|
encode(message, writer = minimalExports.Writer.create()) {
|
|
7727
|
-
if (message.avatarId !==
|
|
7727
|
+
if (message.avatarId !== "") {
|
|
7728
7728
|
writer.uint32(10).string(message.avatarId);
|
|
7729
7729
|
}
|
|
7730
7730
|
if (message.anchorPointId !== 0) {
|
|
@@ -7751,7 +7751,7 @@
|
|
|
7751
7751
|
}
|
|
7752
7752
|
}
|
|
7753
7753
|
return message;
|
|
7754
|
-
}
|
|
7754
|
+
},
|
|
7755
7755
|
};
|
|
7756
7756
|
|
|
7757
7757
|
/**
|
|
@@ -7815,7 +7815,7 @@
|
|
|
7815
7815
|
}
|
|
7816
7816
|
}
|
|
7817
7817
|
return message;
|
|
7818
|
-
}
|
|
7818
|
+
},
|
|
7819
7819
|
};
|
|
7820
7820
|
|
|
7821
7821
|
/* eslint-disable */
|
|
@@ -7875,7 +7875,7 @@
|
|
|
7875
7875
|
}
|
|
7876
7876
|
}
|
|
7877
7877
|
return message;
|
|
7878
|
-
}
|
|
7878
|
+
},
|
|
7879
7879
|
};
|
|
7880
7880
|
|
|
7881
7881
|
/**
|
|
@@ -9273,7 +9273,7 @@
|
|
|
9273
9273
|
}
|
|
9274
9274
|
}
|
|
9275
9275
|
return message;
|
|
9276
|
-
}
|
|
9276
|
+
},
|
|
9277
9277
|
};
|
|
9278
9278
|
function createBaseColor4() {
|
|
9279
9279
|
return { r: 0, g: 0, b: 0, a: 0 };
|
|
@@ -9322,13 +9322,13 @@
|
|
|
9322
9322
|
}
|
|
9323
9323
|
}
|
|
9324
9324
|
return message;
|
|
9325
|
-
}
|
|
9325
|
+
},
|
|
9326
9326
|
};
|
|
9327
9327
|
|
|
9328
9328
|
/* eslint-disable */
|
|
9329
9329
|
function createBasePBAvatarShape() {
|
|
9330
9330
|
return {
|
|
9331
|
-
id:
|
|
9331
|
+
id: "",
|
|
9332
9332
|
name: undefined,
|
|
9333
9333
|
bodyShape: undefined,
|
|
9334
9334
|
skinColor: undefined,
|
|
@@ -9338,7 +9338,7 @@
|
|
|
9338
9338
|
expressionTriggerTimestamp: undefined,
|
|
9339
9339
|
talking: undefined,
|
|
9340
9340
|
wearables: [],
|
|
9341
|
-
emotes: []
|
|
9341
|
+
emotes: [],
|
|
9342
9342
|
};
|
|
9343
9343
|
}
|
|
9344
9344
|
/**
|
|
@@ -9346,7 +9346,7 @@
|
|
|
9346
9346
|
*/
|
|
9347
9347
|
const PBAvatarShape = {
|
|
9348
9348
|
encode(message, writer = minimalExports.Writer.create()) {
|
|
9349
|
-
if (message.id !==
|
|
9349
|
+
if (message.id !== "") {
|
|
9350
9350
|
writer.uint32(10).string(message.id);
|
|
9351
9351
|
}
|
|
9352
9352
|
if (message.name !== undefined) {
|
|
@@ -9427,22 +9427,26 @@
|
|
|
9427
9427
|
}
|
|
9428
9428
|
}
|
|
9429
9429
|
return message;
|
|
9430
|
-
}
|
|
9430
|
+
},
|
|
9431
9431
|
};
|
|
9432
|
-
var
|
|
9433
|
-
if (typeof globalThis
|
|
9434
|
-
return globalThis
|
|
9435
|
-
|
|
9432
|
+
var tsProtoGlobalThis$1 = (() => {
|
|
9433
|
+
if (typeof globalThis !== "undefined") {
|
|
9434
|
+
return globalThis;
|
|
9435
|
+
}
|
|
9436
|
+
if (typeof self !== "undefined") {
|
|
9436
9437
|
return self;
|
|
9437
|
-
|
|
9438
|
+
}
|
|
9439
|
+
if (typeof window !== "undefined") {
|
|
9438
9440
|
return window;
|
|
9439
|
-
|
|
9441
|
+
}
|
|
9442
|
+
if (typeof global !== "undefined") {
|
|
9440
9443
|
return global;
|
|
9441
|
-
|
|
9444
|
+
}
|
|
9445
|
+
throw "Unable to locate global object";
|
|
9442
9446
|
})();
|
|
9443
9447
|
function longToNumber$1(long) {
|
|
9444
9448
|
if (long.gt(Number.MAX_SAFE_INTEGER)) {
|
|
9445
|
-
throw new
|
|
9449
|
+
throw new tsProtoGlobalThis$1.Error("Value is larger than Number.MAX_SAFE_INTEGER");
|
|
9446
9450
|
}
|
|
9447
9451
|
return long.toNumber();
|
|
9448
9452
|
}
|
|
@@ -9511,7 +9515,7 @@
|
|
|
9511
9515
|
}
|
|
9512
9516
|
}
|
|
9513
9517
|
return message;
|
|
9514
|
-
}
|
|
9518
|
+
},
|
|
9515
9519
|
};
|
|
9516
9520
|
|
|
9517
9521
|
/**
|
|
@@ -9533,6 +9537,7 @@
|
|
|
9533
9537
|
}
|
|
9534
9538
|
};
|
|
9535
9539
|
|
|
9540
|
+
/* eslint-disable */
|
|
9536
9541
|
function createBasePBCameraMode() {
|
|
9537
9542
|
return { mode: 0 };
|
|
9538
9543
|
}
|
|
@@ -9562,7 +9567,7 @@
|
|
|
9562
9567
|
}
|
|
9563
9568
|
}
|
|
9564
9569
|
return message;
|
|
9565
|
-
}
|
|
9570
|
+
},
|
|
9566
9571
|
};
|
|
9567
9572
|
|
|
9568
9573
|
/**
|
|
@@ -9584,6 +9589,7 @@
|
|
|
9584
9589
|
}
|
|
9585
9590
|
};
|
|
9586
9591
|
|
|
9592
|
+
/* eslint-disable */
|
|
9587
9593
|
function createBasePBCameraModeArea() {
|
|
9588
9594
|
return { area: undefined, mode: 0 };
|
|
9589
9595
|
}
|
|
@@ -9619,7 +9625,7 @@
|
|
|
9619
9625
|
}
|
|
9620
9626
|
}
|
|
9621
9627
|
return message;
|
|
9622
|
-
}
|
|
9628
|
+
},
|
|
9623
9629
|
};
|
|
9624
9630
|
|
|
9625
9631
|
/**
|
|
@@ -9643,14 +9649,14 @@
|
|
|
9643
9649
|
|
|
9644
9650
|
/* eslint-disable */
|
|
9645
9651
|
function createBasePBGltfContainer() {
|
|
9646
|
-
return { src:
|
|
9652
|
+
return { src: "" };
|
|
9647
9653
|
}
|
|
9648
9654
|
/**
|
|
9649
9655
|
* Internal
|
|
9650
9656
|
*/
|
|
9651
9657
|
const PBGltfContainer = {
|
|
9652
9658
|
encode(message, writer = minimalExports.Writer.create()) {
|
|
9653
|
-
if (message.src !==
|
|
9659
|
+
if (message.src !== "") {
|
|
9654
9660
|
writer.uint32(10).string(message.src);
|
|
9655
9661
|
}
|
|
9656
9662
|
return writer;
|
|
@@ -9671,7 +9677,7 @@
|
|
|
9671
9677
|
}
|
|
9672
9678
|
}
|
|
9673
9679
|
return message;
|
|
9674
|
-
}
|
|
9680
|
+
},
|
|
9675
9681
|
};
|
|
9676
9682
|
|
|
9677
9683
|
/**
|
|
@@ -9708,14 +9714,14 @@
|
|
|
9708
9714
|
TextureFilterMode[TextureFilterMode["TFM_TRILINEAR"] = 2] = "TFM_TRILINEAR";
|
|
9709
9715
|
})(exports.TextureFilterMode || (exports.TextureFilterMode = {}));
|
|
9710
9716
|
function createBaseTexture() {
|
|
9711
|
-
return { src:
|
|
9717
|
+
return { src: "", wrapMode: undefined, filterMode: undefined };
|
|
9712
9718
|
}
|
|
9713
9719
|
/**
|
|
9714
9720
|
* Internal
|
|
9715
9721
|
*/
|
|
9716
9722
|
const Texture = {
|
|
9717
9723
|
encode(message, writer = minimalExports.Writer.create()) {
|
|
9718
|
-
if (message.src !==
|
|
9724
|
+
if (message.src !== "") {
|
|
9719
9725
|
writer.uint32(10).string(message.src);
|
|
9720
9726
|
}
|
|
9721
9727
|
if (message.wrapMode !== undefined) {
|
|
@@ -9748,17 +9754,17 @@
|
|
|
9748
9754
|
}
|
|
9749
9755
|
}
|
|
9750
9756
|
return message;
|
|
9751
|
-
}
|
|
9757
|
+
},
|
|
9752
9758
|
};
|
|
9753
9759
|
function createBaseAvatarTexture() {
|
|
9754
|
-
return { userId:
|
|
9760
|
+
return { userId: "", wrapMode: undefined, filterMode: undefined };
|
|
9755
9761
|
}
|
|
9756
9762
|
/**
|
|
9757
9763
|
* Internal
|
|
9758
9764
|
*/
|
|
9759
9765
|
const AvatarTexture = {
|
|
9760
9766
|
encode(message, writer = minimalExports.Writer.create()) {
|
|
9761
|
-
if (message.userId !==
|
|
9767
|
+
if (message.userId !== "") {
|
|
9762
9768
|
writer.uint32(10).string(message.userId);
|
|
9763
9769
|
}
|
|
9764
9770
|
if (message.wrapMode !== undefined) {
|
|
@@ -9791,7 +9797,7 @@
|
|
|
9791
9797
|
}
|
|
9792
9798
|
}
|
|
9793
9799
|
return message;
|
|
9794
|
-
}
|
|
9800
|
+
},
|
|
9795
9801
|
};
|
|
9796
9802
|
function createBaseTextureUnion() {
|
|
9797
9803
|
return { tex: undefined };
|
|
@@ -9801,10 +9807,10 @@
|
|
|
9801
9807
|
*/
|
|
9802
9808
|
const TextureUnion = {
|
|
9803
9809
|
encode(message, writer = minimalExports.Writer.create()) {
|
|
9804
|
-
if (message.tex?.$case ===
|
|
9810
|
+
if (message.tex?.$case === "texture") {
|
|
9805
9811
|
Texture.encode(message.tex.texture, writer.uint32(10).fork()).ldelim();
|
|
9806
9812
|
}
|
|
9807
|
-
if (message.tex?.$case ===
|
|
9813
|
+
if (message.tex?.$case === "avatarTexture") {
|
|
9808
9814
|
AvatarTexture.encode(message.tex.avatarTexture, writer.uint32(18).fork()).ldelim();
|
|
9809
9815
|
}
|
|
9810
9816
|
return writer;
|
|
@@ -9817,10 +9823,10 @@
|
|
|
9817
9823
|
const tag = reader.uint32();
|
|
9818
9824
|
switch (tag >>> 3) {
|
|
9819
9825
|
case 1:
|
|
9820
|
-
message.tex = { $case:
|
|
9826
|
+
message.tex = { $case: "texture", texture: Texture.decode(reader, reader.uint32()) };
|
|
9821
9827
|
break;
|
|
9822
9828
|
case 2:
|
|
9823
|
-
message.tex = { $case:
|
|
9829
|
+
message.tex = { $case: "avatarTexture", avatarTexture: AvatarTexture.decode(reader, reader.uint32()) };
|
|
9824
9830
|
break;
|
|
9825
9831
|
default:
|
|
9826
9832
|
reader.skipType(tag & 7);
|
|
@@ -9828,7 +9834,7 @@
|
|
|
9828
9834
|
}
|
|
9829
9835
|
}
|
|
9830
9836
|
return message;
|
|
9831
|
-
}
|
|
9837
|
+
},
|
|
9832
9838
|
};
|
|
9833
9839
|
|
|
9834
9840
|
/* eslint-disable */
|
|
@@ -9848,10 +9854,10 @@
|
|
|
9848
9854
|
*/
|
|
9849
9855
|
const PBMaterial = {
|
|
9850
9856
|
encode(message, writer = minimalExports.Writer.create()) {
|
|
9851
|
-
if (message.material?.$case ===
|
|
9857
|
+
if (message.material?.$case === "unlit") {
|
|
9852
9858
|
PBMaterial_UnlitMaterial.encode(message.material.unlit, writer.uint32(10).fork()).ldelim();
|
|
9853
9859
|
}
|
|
9854
|
-
if (message.material?.$case ===
|
|
9860
|
+
if (message.material?.$case === "pbr") {
|
|
9855
9861
|
PBMaterial_PbrMaterial.encode(message.material.pbr, writer.uint32(18).fork()).ldelim();
|
|
9856
9862
|
}
|
|
9857
9863
|
return writer;
|
|
@@ -9864,10 +9870,10 @@
|
|
|
9864
9870
|
const tag = reader.uint32();
|
|
9865
9871
|
switch (tag >>> 3) {
|
|
9866
9872
|
case 1:
|
|
9867
|
-
message.material = { $case:
|
|
9873
|
+
message.material = { $case: "unlit", unlit: PBMaterial_UnlitMaterial.decode(reader, reader.uint32()) };
|
|
9868
9874
|
break;
|
|
9869
9875
|
case 2:
|
|
9870
|
-
message.material = { $case:
|
|
9876
|
+
message.material = { $case: "pbr", pbr: PBMaterial_PbrMaterial.decode(reader, reader.uint32()) };
|
|
9871
9877
|
break;
|
|
9872
9878
|
default:
|
|
9873
9879
|
reader.skipType(tag & 7);
|
|
@@ -9875,7 +9881,7 @@
|
|
|
9875
9881
|
}
|
|
9876
9882
|
}
|
|
9877
9883
|
return message;
|
|
9878
|
-
}
|
|
9884
|
+
},
|
|
9879
9885
|
};
|
|
9880
9886
|
function createBasePBMaterial_UnlitMaterial() {
|
|
9881
9887
|
return { texture: undefined, alphaTest: undefined, castShadows: undefined };
|
|
@@ -9918,7 +9924,7 @@
|
|
|
9918
9924
|
}
|
|
9919
9925
|
}
|
|
9920
9926
|
return message;
|
|
9921
|
-
}
|
|
9927
|
+
},
|
|
9922
9928
|
};
|
|
9923
9929
|
function createBasePBMaterial_PbrMaterial() {
|
|
9924
9930
|
return {
|
|
@@ -9937,7 +9943,7 @@
|
|
|
9937
9943
|
glossiness: undefined,
|
|
9938
9944
|
specularIntensity: undefined,
|
|
9939
9945
|
emissiveIntensity: undefined,
|
|
9940
|
-
directIntensity: undefined
|
|
9946
|
+
directIntensity: undefined,
|
|
9941
9947
|
};
|
|
9942
9948
|
}
|
|
9943
9949
|
/**
|
|
@@ -10056,7 +10062,7 @@
|
|
|
10056
10062
|
}
|
|
10057
10063
|
}
|
|
10058
10064
|
return message;
|
|
10059
|
-
}
|
|
10065
|
+
},
|
|
10060
10066
|
};
|
|
10061
10067
|
|
|
10062
10068
|
/**
|
|
@@ -10096,16 +10102,16 @@
|
|
|
10096
10102
|
if (message.collisionMask !== undefined) {
|
|
10097
10103
|
writer.uint32(8).int32(message.collisionMask);
|
|
10098
10104
|
}
|
|
10099
|
-
if (message.mesh?.$case ===
|
|
10105
|
+
if (message.mesh?.$case === "box") {
|
|
10100
10106
|
PBMeshCollider_BoxMesh.encode(message.mesh.box, writer.uint32(18).fork()).ldelim();
|
|
10101
10107
|
}
|
|
10102
|
-
if (message.mesh?.$case ===
|
|
10108
|
+
if (message.mesh?.$case === "sphere") {
|
|
10103
10109
|
PBMeshCollider_SphereMesh.encode(message.mesh.sphere, writer.uint32(26).fork()).ldelim();
|
|
10104
10110
|
}
|
|
10105
|
-
if (message.mesh?.$case ===
|
|
10111
|
+
if (message.mesh?.$case === "cylinder") {
|
|
10106
10112
|
PBMeshCollider_CylinderMesh.encode(message.mesh.cylinder, writer.uint32(34).fork()).ldelim();
|
|
10107
10113
|
}
|
|
10108
|
-
if (message.mesh?.$case ===
|
|
10114
|
+
if (message.mesh?.$case === "plane") {
|
|
10109
10115
|
PBMeshCollider_PlaneMesh.encode(message.mesh.plane, writer.uint32(42).fork()).ldelim();
|
|
10110
10116
|
}
|
|
10111
10117
|
return writer;
|
|
@@ -10121,16 +10127,16 @@
|
|
|
10121
10127
|
message.collisionMask = reader.int32();
|
|
10122
10128
|
break;
|
|
10123
10129
|
case 2:
|
|
10124
|
-
message.mesh = { $case:
|
|
10130
|
+
message.mesh = { $case: "box", box: PBMeshCollider_BoxMesh.decode(reader, reader.uint32()) };
|
|
10125
10131
|
break;
|
|
10126
10132
|
case 3:
|
|
10127
|
-
message.mesh = { $case:
|
|
10133
|
+
message.mesh = { $case: "sphere", sphere: PBMeshCollider_SphereMesh.decode(reader, reader.uint32()) };
|
|
10128
10134
|
break;
|
|
10129
10135
|
case 4:
|
|
10130
|
-
message.mesh = { $case:
|
|
10136
|
+
message.mesh = { $case: "cylinder", cylinder: PBMeshCollider_CylinderMesh.decode(reader, reader.uint32()) };
|
|
10131
10137
|
break;
|
|
10132
10138
|
case 5:
|
|
10133
|
-
message.mesh = { $case:
|
|
10139
|
+
message.mesh = { $case: "plane", plane: PBMeshCollider_PlaneMesh.decode(reader, reader.uint32()) };
|
|
10134
10140
|
break;
|
|
10135
10141
|
default:
|
|
10136
10142
|
reader.skipType(tag & 7);
|
|
@@ -10138,7 +10144,7 @@
|
|
|
10138
10144
|
}
|
|
10139
10145
|
}
|
|
10140
10146
|
return message;
|
|
10141
|
-
}
|
|
10147
|
+
},
|
|
10142
10148
|
};
|
|
10143
10149
|
function createBasePBMeshCollider_BoxMesh() {
|
|
10144
10150
|
return {};
|
|
@@ -10163,7 +10169,7 @@
|
|
|
10163
10169
|
}
|
|
10164
10170
|
}
|
|
10165
10171
|
return message;
|
|
10166
|
-
}
|
|
10172
|
+
},
|
|
10167
10173
|
};
|
|
10168
10174
|
function createBasePBMeshCollider_CylinderMesh() {
|
|
10169
10175
|
return { radiusTop: undefined, radiusBottom: undefined };
|
|
@@ -10200,7 +10206,7 @@
|
|
|
10200
10206
|
}
|
|
10201
10207
|
}
|
|
10202
10208
|
return message;
|
|
10203
|
-
}
|
|
10209
|
+
},
|
|
10204
10210
|
};
|
|
10205
10211
|
function createBasePBMeshCollider_PlaneMesh() {
|
|
10206
10212
|
return {};
|
|
@@ -10225,7 +10231,7 @@
|
|
|
10225
10231
|
}
|
|
10226
10232
|
}
|
|
10227
10233
|
return message;
|
|
10228
|
-
}
|
|
10234
|
+
},
|
|
10229
10235
|
};
|
|
10230
10236
|
function createBasePBMeshCollider_SphereMesh() {
|
|
10231
10237
|
return {};
|
|
@@ -10250,7 +10256,7 @@
|
|
|
10250
10256
|
}
|
|
10251
10257
|
}
|
|
10252
10258
|
return message;
|
|
10253
|
-
}
|
|
10259
|
+
},
|
|
10254
10260
|
};
|
|
10255
10261
|
|
|
10256
10262
|
/**
|
|
@@ -10281,16 +10287,16 @@
|
|
|
10281
10287
|
*/
|
|
10282
10288
|
const PBMeshRenderer = {
|
|
10283
10289
|
encode(message, writer = minimalExports.Writer.create()) {
|
|
10284
|
-
if (message.mesh?.$case ===
|
|
10290
|
+
if (message.mesh?.$case === "box") {
|
|
10285
10291
|
PBMeshRenderer_BoxMesh.encode(message.mesh.box, writer.uint32(10).fork()).ldelim();
|
|
10286
10292
|
}
|
|
10287
|
-
if (message.mesh?.$case ===
|
|
10293
|
+
if (message.mesh?.$case === "sphere") {
|
|
10288
10294
|
PBMeshRenderer_SphereMesh.encode(message.mesh.sphere, writer.uint32(18).fork()).ldelim();
|
|
10289
10295
|
}
|
|
10290
|
-
if (message.mesh?.$case ===
|
|
10296
|
+
if (message.mesh?.$case === "cylinder") {
|
|
10291
10297
|
PBMeshRenderer_CylinderMesh.encode(message.mesh.cylinder, writer.uint32(26).fork()).ldelim();
|
|
10292
10298
|
}
|
|
10293
|
-
if (message.mesh?.$case ===
|
|
10299
|
+
if (message.mesh?.$case === "plane") {
|
|
10294
10300
|
PBMeshRenderer_PlaneMesh.encode(message.mesh.plane, writer.uint32(34).fork()).ldelim();
|
|
10295
10301
|
}
|
|
10296
10302
|
return writer;
|
|
@@ -10303,16 +10309,16 @@
|
|
|
10303
10309
|
const tag = reader.uint32();
|
|
10304
10310
|
switch (tag >>> 3) {
|
|
10305
10311
|
case 1:
|
|
10306
|
-
message.mesh = { $case:
|
|
10312
|
+
message.mesh = { $case: "box", box: PBMeshRenderer_BoxMesh.decode(reader, reader.uint32()) };
|
|
10307
10313
|
break;
|
|
10308
10314
|
case 2:
|
|
10309
|
-
message.mesh = { $case:
|
|
10315
|
+
message.mesh = { $case: "sphere", sphere: PBMeshRenderer_SphereMesh.decode(reader, reader.uint32()) };
|
|
10310
10316
|
break;
|
|
10311
10317
|
case 3:
|
|
10312
|
-
message.mesh = { $case:
|
|
10318
|
+
message.mesh = { $case: "cylinder", cylinder: PBMeshRenderer_CylinderMesh.decode(reader, reader.uint32()) };
|
|
10313
10319
|
break;
|
|
10314
10320
|
case 4:
|
|
10315
|
-
message.mesh = { $case:
|
|
10321
|
+
message.mesh = { $case: "plane", plane: PBMeshRenderer_PlaneMesh.decode(reader, reader.uint32()) };
|
|
10316
10322
|
break;
|
|
10317
10323
|
default:
|
|
10318
10324
|
reader.skipType(tag & 7);
|
|
@@ -10320,7 +10326,7 @@
|
|
|
10320
10326
|
}
|
|
10321
10327
|
}
|
|
10322
10328
|
return message;
|
|
10323
|
-
}
|
|
10329
|
+
},
|
|
10324
10330
|
};
|
|
10325
10331
|
function createBasePBMeshRenderer_BoxMesh() {
|
|
10326
10332
|
return { uvs: [] };
|
|
@@ -10361,7 +10367,7 @@
|
|
|
10361
10367
|
}
|
|
10362
10368
|
}
|
|
10363
10369
|
return message;
|
|
10364
|
-
}
|
|
10370
|
+
},
|
|
10365
10371
|
};
|
|
10366
10372
|
function createBasePBMeshRenderer_CylinderMesh() {
|
|
10367
10373
|
return { radiusTop: undefined, radiusBottom: undefined };
|
|
@@ -10398,7 +10404,7 @@
|
|
|
10398
10404
|
}
|
|
10399
10405
|
}
|
|
10400
10406
|
return message;
|
|
10401
|
-
}
|
|
10407
|
+
},
|
|
10402
10408
|
};
|
|
10403
10409
|
function createBasePBMeshRenderer_PlaneMesh() {
|
|
10404
10410
|
return { uvs: [] };
|
|
@@ -10439,7 +10445,7 @@
|
|
|
10439
10445
|
}
|
|
10440
10446
|
}
|
|
10441
10447
|
return message;
|
|
10442
|
-
}
|
|
10448
|
+
},
|
|
10443
10449
|
};
|
|
10444
10450
|
function createBasePBMeshRenderer_SphereMesh() {
|
|
10445
10451
|
return {};
|
|
@@ -10464,7 +10470,7 @@
|
|
|
10464
10470
|
}
|
|
10465
10471
|
}
|
|
10466
10472
|
return message;
|
|
10467
|
-
}
|
|
10473
|
+
},
|
|
10468
10474
|
};
|
|
10469
10475
|
|
|
10470
10476
|
/**
|
|
@@ -10514,14 +10520,14 @@
|
|
|
10514
10520
|
NftFrameType[NftFrameType["NFT_NONE"] = 22] = "NFT_NONE";
|
|
10515
10521
|
})(exports.NftFrameType || (exports.NftFrameType = {}));
|
|
10516
10522
|
function createBasePBNftShape() {
|
|
10517
|
-
return { src:
|
|
10523
|
+
return { src: "", style: undefined, color: undefined };
|
|
10518
10524
|
}
|
|
10519
10525
|
/**
|
|
10520
10526
|
* Internal
|
|
10521
10527
|
*/
|
|
10522
10528
|
const PBNftShape = {
|
|
10523
10529
|
encode(message, writer = minimalExports.Writer.create()) {
|
|
10524
|
-
if (message.src !==
|
|
10530
|
+
if (message.src !== "") {
|
|
10525
10531
|
writer.uint32(10).string(message.src);
|
|
10526
10532
|
}
|
|
10527
10533
|
if (message.style !== undefined) {
|
|
@@ -10554,7 +10560,7 @@
|
|
|
10554
10560
|
}
|
|
10555
10561
|
}
|
|
10556
10562
|
return message;
|
|
10557
|
-
}
|
|
10563
|
+
},
|
|
10558
10564
|
};
|
|
10559
10565
|
|
|
10560
10566
|
/**
|
|
@@ -10577,258 +10583,6 @@
|
|
|
10577
10583
|
};
|
|
10578
10584
|
|
|
10579
10585
|
/* eslint-disable */
|
|
10580
|
-
function createBasePBRaycastResult() {
|
|
10581
|
-
return { timestamp: 0, origin: undefined, direction: undefined, hits: [] };
|
|
10582
|
-
}
|
|
10583
|
-
/**
|
|
10584
|
-
* Internal
|
|
10585
|
-
*/
|
|
10586
|
-
const PBRaycastResult = {
|
|
10587
|
-
encode(message, writer = minimalExports.Writer.create()) {
|
|
10588
|
-
if (message.timestamp !== 0) {
|
|
10589
|
-
writer.uint32(8).int32(message.timestamp);
|
|
10590
|
-
}
|
|
10591
|
-
if (message.origin !== undefined) {
|
|
10592
|
-
Vector3.encode(message.origin, writer.uint32(18).fork()).ldelim();
|
|
10593
|
-
}
|
|
10594
|
-
if (message.direction !== undefined) {
|
|
10595
|
-
Vector3.encode(message.direction, writer.uint32(26).fork()).ldelim();
|
|
10596
|
-
}
|
|
10597
|
-
for (const v of message.hits) {
|
|
10598
|
-
RaycastHit.encode(v, writer.uint32(34).fork()).ldelim();
|
|
10599
|
-
}
|
|
10600
|
-
return writer;
|
|
10601
|
-
},
|
|
10602
|
-
decode(input, length) {
|
|
10603
|
-
const reader = input instanceof minimalExports.Reader ? input : new minimalExports.Reader(input);
|
|
10604
|
-
let end = length === undefined ? reader.len : reader.pos + length;
|
|
10605
|
-
const message = createBasePBRaycastResult();
|
|
10606
|
-
while (reader.pos < end) {
|
|
10607
|
-
const tag = reader.uint32();
|
|
10608
|
-
switch (tag >>> 3) {
|
|
10609
|
-
case 1:
|
|
10610
|
-
message.timestamp = reader.int32();
|
|
10611
|
-
break;
|
|
10612
|
-
case 2:
|
|
10613
|
-
message.origin = Vector3.decode(reader, reader.uint32());
|
|
10614
|
-
break;
|
|
10615
|
-
case 3:
|
|
10616
|
-
message.direction = Vector3.decode(reader, reader.uint32());
|
|
10617
|
-
break;
|
|
10618
|
-
case 4:
|
|
10619
|
-
message.hits.push(RaycastHit.decode(reader, reader.uint32()));
|
|
10620
|
-
break;
|
|
10621
|
-
default:
|
|
10622
|
-
reader.skipType(tag & 7);
|
|
10623
|
-
break;
|
|
10624
|
-
}
|
|
10625
|
-
}
|
|
10626
|
-
return message;
|
|
10627
|
-
}
|
|
10628
|
-
};
|
|
10629
|
-
function createBaseRaycastHit() {
|
|
10630
|
-
return {
|
|
10631
|
-
position: undefined,
|
|
10632
|
-
origin: undefined,
|
|
10633
|
-
direction: undefined,
|
|
10634
|
-
normalHit: undefined,
|
|
10635
|
-
length: 0,
|
|
10636
|
-
meshName: undefined,
|
|
10637
|
-
entityId: undefined
|
|
10638
|
-
};
|
|
10639
|
-
}
|
|
10640
|
-
/**
|
|
10641
|
-
* Internal
|
|
10642
|
-
*/
|
|
10643
|
-
const RaycastHit = {
|
|
10644
|
-
encode(message, writer = minimalExports.Writer.create()) {
|
|
10645
|
-
if (message.position !== undefined) {
|
|
10646
|
-
Vector3.encode(message.position, writer.uint32(10).fork()).ldelim();
|
|
10647
|
-
}
|
|
10648
|
-
if (message.origin !== undefined) {
|
|
10649
|
-
Vector3.encode(message.origin, writer.uint32(18).fork()).ldelim();
|
|
10650
|
-
}
|
|
10651
|
-
if (message.direction !== undefined) {
|
|
10652
|
-
Vector3.encode(message.direction, writer.uint32(26).fork()).ldelim();
|
|
10653
|
-
}
|
|
10654
|
-
if (message.normalHit !== undefined) {
|
|
10655
|
-
Vector3.encode(message.normalHit, writer.uint32(34).fork()).ldelim();
|
|
10656
|
-
}
|
|
10657
|
-
if (message.length !== 0) {
|
|
10658
|
-
writer.uint32(45).float(message.length);
|
|
10659
|
-
}
|
|
10660
|
-
if (message.meshName !== undefined) {
|
|
10661
|
-
writer.uint32(50).string(message.meshName);
|
|
10662
|
-
}
|
|
10663
|
-
if (message.entityId !== undefined) {
|
|
10664
|
-
writer.uint32(56).int64(message.entityId);
|
|
10665
|
-
}
|
|
10666
|
-
return writer;
|
|
10667
|
-
},
|
|
10668
|
-
decode(input, length) {
|
|
10669
|
-
const reader = input instanceof minimalExports.Reader ? input : new minimalExports.Reader(input);
|
|
10670
|
-
let end = length === undefined ? reader.len : reader.pos + length;
|
|
10671
|
-
const message = createBaseRaycastHit();
|
|
10672
|
-
while (reader.pos < end) {
|
|
10673
|
-
const tag = reader.uint32();
|
|
10674
|
-
switch (tag >>> 3) {
|
|
10675
|
-
case 1:
|
|
10676
|
-
message.position = Vector3.decode(reader, reader.uint32());
|
|
10677
|
-
break;
|
|
10678
|
-
case 2:
|
|
10679
|
-
message.origin = Vector3.decode(reader, reader.uint32());
|
|
10680
|
-
break;
|
|
10681
|
-
case 3:
|
|
10682
|
-
message.direction = Vector3.decode(reader, reader.uint32());
|
|
10683
|
-
break;
|
|
10684
|
-
case 4:
|
|
10685
|
-
message.normalHit = Vector3.decode(reader, reader.uint32());
|
|
10686
|
-
break;
|
|
10687
|
-
case 5:
|
|
10688
|
-
message.length = reader.float();
|
|
10689
|
-
break;
|
|
10690
|
-
case 6:
|
|
10691
|
-
message.meshName = reader.string();
|
|
10692
|
-
break;
|
|
10693
|
-
case 7:
|
|
10694
|
-
message.entityId = longToNumber(reader.int64());
|
|
10695
|
-
break;
|
|
10696
|
-
default:
|
|
10697
|
-
reader.skipType(tag & 7);
|
|
10698
|
-
break;
|
|
10699
|
-
}
|
|
10700
|
-
}
|
|
10701
|
-
return message;
|
|
10702
|
-
}
|
|
10703
|
-
};
|
|
10704
|
-
var globalThis$1 = (() => {
|
|
10705
|
-
if (typeof globalThis$1 !== 'undefined')
|
|
10706
|
-
return globalThis$1;
|
|
10707
|
-
if (typeof self !== 'undefined')
|
|
10708
|
-
return self;
|
|
10709
|
-
if (typeof window !== 'undefined')
|
|
10710
|
-
return window;
|
|
10711
|
-
if (typeof global !== 'undefined')
|
|
10712
|
-
return global;
|
|
10713
|
-
throw 'Unable to locate global object';
|
|
10714
|
-
})();
|
|
10715
|
-
function longToNumber(long) {
|
|
10716
|
-
if (long.gt(Number.MAX_SAFE_INTEGER)) {
|
|
10717
|
-
throw new globalThis$1.Error('Value is larger than Number.MAX_SAFE_INTEGER');
|
|
10718
|
-
}
|
|
10719
|
-
return long.toNumber();
|
|
10720
|
-
}
|
|
10721
|
-
if (minimalExports.util.Long !== longExports) {
|
|
10722
|
-
minimalExports.util.Long = longExports;
|
|
10723
|
-
minimalExports.configure();
|
|
10724
|
-
}
|
|
10725
|
-
|
|
10726
|
-
function createBasePBPointerEventsResult() {
|
|
10727
|
-
return { commands: [] };
|
|
10728
|
-
}
|
|
10729
|
-
/**
|
|
10730
|
-
* Internal
|
|
10731
|
-
*/
|
|
10732
|
-
const PBPointerEventsResult = {
|
|
10733
|
-
encode(message, writer = minimalExports.Writer.create()) {
|
|
10734
|
-
for (const v of message.commands) {
|
|
10735
|
-
PBPointerEventsResult_PointerCommand.encode(v, writer.uint32(10).fork()).ldelim();
|
|
10736
|
-
}
|
|
10737
|
-
return writer;
|
|
10738
|
-
},
|
|
10739
|
-
decode(input, length) {
|
|
10740
|
-
const reader = input instanceof minimalExports.Reader ? input : new minimalExports.Reader(input);
|
|
10741
|
-
let end = length === undefined ? reader.len : reader.pos + length;
|
|
10742
|
-
const message = createBasePBPointerEventsResult();
|
|
10743
|
-
while (reader.pos < end) {
|
|
10744
|
-
const tag = reader.uint32();
|
|
10745
|
-
switch (tag >>> 3) {
|
|
10746
|
-
case 1:
|
|
10747
|
-
message.commands.push(PBPointerEventsResult_PointerCommand.decode(reader, reader.uint32()));
|
|
10748
|
-
break;
|
|
10749
|
-
default:
|
|
10750
|
-
reader.skipType(tag & 7);
|
|
10751
|
-
break;
|
|
10752
|
-
}
|
|
10753
|
-
}
|
|
10754
|
-
return message;
|
|
10755
|
-
}
|
|
10756
|
-
};
|
|
10757
|
-
function createBasePBPointerEventsResult_PointerCommand() {
|
|
10758
|
-
return { button: 0, hit: undefined, state: 0, timestamp: 0, analog: undefined };
|
|
10759
|
-
}
|
|
10760
|
-
/**
|
|
10761
|
-
* Internal
|
|
10762
|
-
*/
|
|
10763
|
-
const PBPointerEventsResult_PointerCommand = {
|
|
10764
|
-
encode(message, writer = minimalExports.Writer.create()) {
|
|
10765
|
-
if (message.button !== 0) {
|
|
10766
|
-
writer.uint32(8).int32(message.button);
|
|
10767
|
-
}
|
|
10768
|
-
if (message.hit !== undefined) {
|
|
10769
|
-
RaycastHit.encode(message.hit, writer.uint32(18).fork()).ldelim();
|
|
10770
|
-
}
|
|
10771
|
-
if (message.state !== 0) {
|
|
10772
|
-
writer.uint32(32).int32(message.state);
|
|
10773
|
-
}
|
|
10774
|
-
if (message.timestamp !== 0) {
|
|
10775
|
-
writer.uint32(40).int32(message.timestamp);
|
|
10776
|
-
}
|
|
10777
|
-
if (message.analog !== undefined) {
|
|
10778
|
-
writer.uint32(53).float(message.analog);
|
|
10779
|
-
}
|
|
10780
|
-
return writer;
|
|
10781
|
-
},
|
|
10782
|
-
decode(input, length) {
|
|
10783
|
-
const reader = input instanceof minimalExports.Reader ? input : new minimalExports.Reader(input);
|
|
10784
|
-
let end = length === undefined ? reader.len : reader.pos + length;
|
|
10785
|
-
const message = createBasePBPointerEventsResult_PointerCommand();
|
|
10786
|
-
while (reader.pos < end) {
|
|
10787
|
-
const tag = reader.uint32();
|
|
10788
|
-
switch (tag >>> 3) {
|
|
10789
|
-
case 1:
|
|
10790
|
-
message.button = reader.int32();
|
|
10791
|
-
break;
|
|
10792
|
-
case 2:
|
|
10793
|
-
message.hit = RaycastHit.decode(reader, reader.uint32());
|
|
10794
|
-
break;
|
|
10795
|
-
case 4:
|
|
10796
|
-
message.state = reader.int32();
|
|
10797
|
-
break;
|
|
10798
|
-
case 5:
|
|
10799
|
-
message.timestamp = reader.int32();
|
|
10800
|
-
break;
|
|
10801
|
-
case 6:
|
|
10802
|
-
message.analog = reader.float();
|
|
10803
|
-
break;
|
|
10804
|
-
default:
|
|
10805
|
-
reader.skipType(tag & 7);
|
|
10806
|
-
break;
|
|
10807
|
-
}
|
|
10808
|
-
}
|
|
10809
|
-
return message;
|
|
10810
|
-
}
|
|
10811
|
-
};
|
|
10812
|
-
|
|
10813
|
-
/**
|
|
10814
|
-
*
|
|
10815
|
-
*/
|
|
10816
|
-
const PointerEventsResultSchema = {
|
|
10817
|
-
COMPONENT_ID: 1063,
|
|
10818
|
-
serialize(value, builder) {
|
|
10819
|
-
const writer = PBPointerEventsResult.encode(value);
|
|
10820
|
-
const buffer = new Uint8Array(writer.finish(), 0, writer.len);
|
|
10821
|
-
builder.writeBuffer(buffer, false);
|
|
10822
|
-
},
|
|
10823
|
-
deserialize(reader) {
|
|
10824
|
-
return PBPointerEventsResult.decode(reader.buffer(), reader.remainingBytes());
|
|
10825
|
-
},
|
|
10826
|
-
create() {
|
|
10827
|
-
// TODO: this is a hack.
|
|
10828
|
-
return PBPointerEventsResult.decode(new Uint8Array());
|
|
10829
|
-
}
|
|
10830
|
-
};
|
|
10831
|
-
|
|
10832
10586
|
exports.PointerEventType = void 0;
|
|
10833
10587
|
(function (PointerEventType) {
|
|
10834
10588
|
PointerEventType[PointerEventType["PET_UP"] = 0] = "PET_UP";
|
|
@@ -10836,28 +10590,28 @@
|
|
|
10836
10590
|
PointerEventType[PointerEventType["PET_HOVER_ENTER"] = 2] = "PET_HOVER_ENTER";
|
|
10837
10591
|
PointerEventType[PointerEventType["PET_HOVER_LEAVE"] = 3] = "PET_HOVER_LEAVE";
|
|
10838
10592
|
})(exports.PointerEventType || (exports.PointerEventType = {}));
|
|
10839
|
-
function
|
|
10593
|
+
function createBasePBPointerEvents() {
|
|
10840
10594
|
return { pointerEvents: [] };
|
|
10841
10595
|
}
|
|
10842
10596
|
/**
|
|
10843
10597
|
* Internal
|
|
10844
10598
|
*/
|
|
10845
|
-
const
|
|
10599
|
+
const PBPointerEvents = {
|
|
10846
10600
|
encode(message, writer = minimalExports.Writer.create()) {
|
|
10847
10601
|
for (const v of message.pointerEvents) {
|
|
10848
|
-
|
|
10602
|
+
PBPointerEvents_Entry.encode(v, writer.uint32(10).fork()).ldelim();
|
|
10849
10603
|
}
|
|
10850
10604
|
return writer;
|
|
10851
10605
|
},
|
|
10852
10606
|
decode(input, length) {
|
|
10853
10607
|
const reader = input instanceof minimalExports.Reader ? input : new minimalExports.Reader(input);
|
|
10854
10608
|
let end = length === undefined ? reader.len : reader.pos + length;
|
|
10855
|
-
const message =
|
|
10609
|
+
const message = createBasePBPointerEvents();
|
|
10856
10610
|
while (reader.pos < end) {
|
|
10857
10611
|
const tag = reader.uint32();
|
|
10858
10612
|
switch (tag >>> 3) {
|
|
10859
10613
|
case 1:
|
|
10860
|
-
message.pointerEvents.push(
|
|
10614
|
+
message.pointerEvents.push(PBPointerEvents_Entry.decode(reader, reader.uint32()));
|
|
10861
10615
|
break;
|
|
10862
10616
|
default:
|
|
10863
10617
|
reader.skipType(tag & 7);
|
|
@@ -10865,15 +10619,15 @@
|
|
|
10865
10619
|
}
|
|
10866
10620
|
}
|
|
10867
10621
|
return message;
|
|
10868
|
-
}
|
|
10622
|
+
},
|
|
10869
10623
|
};
|
|
10870
|
-
function
|
|
10624
|
+
function createBasePBPointerEvents_Info() {
|
|
10871
10625
|
return { button: undefined, hoverText: undefined, maxDistance: undefined, showFeedback: undefined };
|
|
10872
10626
|
}
|
|
10873
10627
|
/**
|
|
10874
10628
|
* Internal
|
|
10875
10629
|
*/
|
|
10876
|
-
const
|
|
10630
|
+
const PBPointerEvents_Info = {
|
|
10877
10631
|
encode(message, writer = minimalExports.Writer.create()) {
|
|
10878
10632
|
if (message.button !== undefined) {
|
|
10879
10633
|
writer.uint32(8).int32(message.button);
|
|
@@ -10892,7 +10646,7 @@
|
|
|
10892
10646
|
decode(input, length) {
|
|
10893
10647
|
const reader = input instanceof minimalExports.Reader ? input : new minimalExports.Reader(input);
|
|
10894
10648
|
let end = length === undefined ? reader.len : reader.pos + length;
|
|
10895
|
-
const message =
|
|
10649
|
+
const message = createBasePBPointerEvents_Info();
|
|
10896
10650
|
while (reader.pos < end) {
|
|
10897
10651
|
const tag = reader.uint32();
|
|
10898
10652
|
switch (tag >>> 3) {
|
|
@@ -10914,28 +10668,28 @@
|
|
|
10914
10668
|
}
|
|
10915
10669
|
}
|
|
10916
10670
|
return message;
|
|
10917
|
-
}
|
|
10671
|
+
},
|
|
10918
10672
|
};
|
|
10919
|
-
function
|
|
10673
|
+
function createBasePBPointerEvents_Entry() {
|
|
10920
10674
|
return { eventType: 0, eventInfo: undefined };
|
|
10921
10675
|
}
|
|
10922
10676
|
/**
|
|
10923
10677
|
* Internal
|
|
10924
10678
|
*/
|
|
10925
|
-
const
|
|
10679
|
+
const PBPointerEvents_Entry = {
|
|
10926
10680
|
encode(message, writer = minimalExports.Writer.create()) {
|
|
10927
10681
|
if (message.eventType !== 0) {
|
|
10928
10682
|
writer.uint32(8).int32(message.eventType);
|
|
10929
10683
|
}
|
|
10930
10684
|
if (message.eventInfo !== undefined) {
|
|
10931
|
-
|
|
10685
|
+
PBPointerEvents_Info.encode(message.eventInfo, writer.uint32(18).fork()).ldelim();
|
|
10932
10686
|
}
|
|
10933
10687
|
return writer;
|
|
10934
10688
|
},
|
|
10935
10689
|
decode(input, length) {
|
|
10936
10690
|
const reader = input instanceof minimalExports.Reader ? input : new minimalExports.Reader(input);
|
|
10937
10691
|
let end = length === undefined ? reader.len : reader.pos + length;
|
|
10938
|
-
const message =
|
|
10692
|
+
const message = createBasePBPointerEvents_Entry();
|
|
10939
10693
|
while (reader.pos < end) {
|
|
10940
10694
|
const tag = reader.uint32();
|
|
10941
10695
|
switch (tag >>> 3) {
|
|
@@ -10943,7 +10697,7 @@
|
|
|
10943
10697
|
message.eventType = reader.int32();
|
|
10944
10698
|
break;
|
|
10945
10699
|
case 2:
|
|
10946
|
-
message.eventInfo =
|
|
10700
|
+
message.eventInfo = PBPointerEvents_Info.decode(reader, reader.uint32());
|
|
10947
10701
|
break;
|
|
10948
10702
|
default:
|
|
10949
10703
|
reader.skipType(tag & 7);
|
|
@@ -10951,25 +10705,283 @@
|
|
|
10951
10705
|
}
|
|
10952
10706
|
}
|
|
10953
10707
|
return message;
|
|
10954
|
-
}
|
|
10708
|
+
},
|
|
10955
10709
|
};
|
|
10956
10710
|
|
|
10957
10711
|
/**
|
|
10958
10712
|
*
|
|
10959
10713
|
*/
|
|
10960
|
-
const
|
|
10714
|
+
const PointerEventsSchema = {
|
|
10961
10715
|
COMPONENT_ID: 1062,
|
|
10962
10716
|
serialize(value, builder) {
|
|
10963
|
-
const writer =
|
|
10717
|
+
const writer = PBPointerEvents.encode(value);
|
|
10718
|
+
const buffer = new Uint8Array(writer.finish(), 0, writer.len);
|
|
10719
|
+
builder.writeBuffer(buffer, false);
|
|
10720
|
+
},
|
|
10721
|
+
deserialize(reader) {
|
|
10722
|
+
return PBPointerEvents.decode(reader.buffer(), reader.remainingBytes());
|
|
10723
|
+
},
|
|
10724
|
+
create() {
|
|
10725
|
+
// TODO: this is a hack.
|
|
10726
|
+
return PBPointerEvents.decode(new Uint8Array());
|
|
10727
|
+
}
|
|
10728
|
+
};
|
|
10729
|
+
|
|
10730
|
+
/* eslint-disable */
|
|
10731
|
+
function createBasePBRaycastResult() {
|
|
10732
|
+
return { timestamp: 0, origin: undefined, direction: undefined, hits: [] };
|
|
10733
|
+
}
|
|
10734
|
+
/**
|
|
10735
|
+
* Internal
|
|
10736
|
+
*/
|
|
10737
|
+
const PBRaycastResult = {
|
|
10738
|
+
encode(message, writer = minimalExports.Writer.create()) {
|
|
10739
|
+
if (message.timestamp !== 0) {
|
|
10740
|
+
writer.uint32(8).int32(message.timestamp);
|
|
10741
|
+
}
|
|
10742
|
+
if (message.origin !== undefined) {
|
|
10743
|
+
Vector3.encode(message.origin, writer.uint32(18).fork()).ldelim();
|
|
10744
|
+
}
|
|
10745
|
+
if (message.direction !== undefined) {
|
|
10746
|
+
Vector3.encode(message.direction, writer.uint32(26).fork()).ldelim();
|
|
10747
|
+
}
|
|
10748
|
+
for (const v of message.hits) {
|
|
10749
|
+
RaycastHit.encode(v, writer.uint32(34).fork()).ldelim();
|
|
10750
|
+
}
|
|
10751
|
+
return writer;
|
|
10752
|
+
},
|
|
10753
|
+
decode(input, length) {
|
|
10754
|
+
const reader = input instanceof minimalExports.Reader ? input : new minimalExports.Reader(input);
|
|
10755
|
+
let end = length === undefined ? reader.len : reader.pos + length;
|
|
10756
|
+
const message = createBasePBRaycastResult();
|
|
10757
|
+
while (reader.pos < end) {
|
|
10758
|
+
const tag = reader.uint32();
|
|
10759
|
+
switch (tag >>> 3) {
|
|
10760
|
+
case 1:
|
|
10761
|
+
message.timestamp = reader.int32();
|
|
10762
|
+
break;
|
|
10763
|
+
case 2:
|
|
10764
|
+
message.origin = Vector3.decode(reader, reader.uint32());
|
|
10765
|
+
break;
|
|
10766
|
+
case 3:
|
|
10767
|
+
message.direction = Vector3.decode(reader, reader.uint32());
|
|
10768
|
+
break;
|
|
10769
|
+
case 4:
|
|
10770
|
+
message.hits.push(RaycastHit.decode(reader, reader.uint32()));
|
|
10771
|
+
break;
|
|
10772
|
+
default:
|
|
10773
|
+
reader.skipType(tag & 7);
|
|
10774
|
+
break;
|
|
10775
|
+
}
|
|
10776
|
+
}
|
|
10777
|
+
return message;
|
|
10778
|
+
},
|
|
10779
|
+
};
|
|
10780
|
+
function createBaseRaycastHit() {
|
|
10781
|
+
return {
|
|
10782
|
+
position: undefined,
|
|
10783
|
+
origin: undefined,
|
|
10784
|
+
direction: undefined,
|
|
10785
|
+
normalHit: undefined,
|
|
10786
|
+
length: 0,
|
|
10787
|
+
meshName: undefined,
|
|
10788
|
+
entityId: undefined,
|
|
10789
|
+
};
|
|
10790
|
+
}
|
|
10791
|
+
/**
|
|
10792
|
+
* Internal
|
|
10793
|
+
*/
|
|
10794
|
+
const RaycastHit = {
|
|
10795
|
+
encode(message, writer = minimalExports.Writer.create()) {
|
|
10796
|
+
if (message.position !== undefined) {
|
|
10797
|
+
Vector3.encode(message.position, writer.uint32(10).fork()).ldelim();
|
|
10798
|
+
}
|
|
10799
|
+
if (message.origin !== undefined) {
|
|
10800
|
+
Vector3.encode(message.origin, writer.uint32(18).fork()).ldelim();
|
|
10801
|
+
}
|
|
10802
|
+
if (message.direction !== undefined) {
|
|
10803
|
+
Vector3.encode(message.direction, writer.uint32(26).fork()).ldelim();
|
|
10804
|
+
}
|
|
10805
|
+
if (message.normalHit !== undefined) {
|
|
10806
|
+
Vector3.encode(message.normalHit, writer.uint32(34).fork()).ldelim();
|
|
10807
|
+
}
|
|
10808
|
+
if (message.length !== 0) {
|
|
10809
|
+
writer.uint32(45).float(message.length);
|
|
10810
|
+
}
|
|
10811
|
+
if (message.meshName !== undefined) {
|
|
10812
|
+
writer.uint32(50).string(message.meshName);
|
|
10813
|
+
}
|
|
10814
|
+
if (message.entityId !== undefined) {
|
|
10815
|
+
writer.uint32(56).int64(message.entityId);
|
|
10816
|
+
}
|
|
10817
|
+
return writer;
|
|
10818
|
+
},
|
|
10819
|
+
decode(input, length) {
|
|
10820
|
+
const reader = input instanceof minimalExports.Reader ? input : new minimalExports.Reader(input);
|
|
10821
|
+
let end = length === undefined ? reader.len : reader.pos + length;
|
|
10822
|
+
const message = createBaseRaycastHit();
|
|
10823
|
+
while (reader.pos < end) {
|
|
10824
|
+
const tag = reader.uint32();
|
|
10825
|
+
switch (tag >>> 3) {
|
|
10826
|
+
case 1:
|
|
10827
|
+
message.position = Vector3.decode(reader, reader.uint32());
|
|
10828
|
+
break;
|
|
10829
|
+
case 2:
|
|
10830
|
+
message.origin = Vector3.decode(reader, reader.uint32());
|
|
10831
|
+
break;
|
|
10832
|
+
case 3:
|
|
10833
|
+
message.direction = Vector3.decode(reader, reader.uint32());
|
|
10834
|
+
break;
|
|
10835
|
+
case 4:
|
|
10836
|
+
message.normalHit = Vector3.decode(reader, reader.uint32());
|
|
10837
|
+
break;
|
|
10838
|
+
case 5:
|
|
10839
|
+
message.length = reader.float();
|
|
10840
|
+
break;
|
|
10841
|
+
case 6:
|
|
10842
|
+
message.meshName = reader.string();
|
|
10843
|
+
break;
|
|
10844
|
+
case 7:
|
|
10845
|
+
message.entityId = longToNumber(reader.int64());
|
|
10846
|
+
break;
|
|
10847
|
+
default:
|
|
10848
|
+
reader.skipType(tag & 7);
|
|
10849
|
+
break;
|
|
10850
|
+
}
|
|
10851
|
+
}
|
|
10852
|
+
return message;
|
|
10853
|
+
},
|
|
10854
|
+
};
|
|
10855
|
+
var tsProtoGlobalThis = (() => {
|
|
10856
|
+
if (typeof globalThis !== "undefined") {
|
|
10857
|
+
return globalThis;
|
|
10858
|
+
}
|
|
10859
|
+
if (typeof self !== "undefined") {
|
|
10860
|
+
return self;
|
|
10861
|
+
}
|
|
10862
|
+
if (typeof window !== "undefined") {
|
|
10863
|
+
return window;
|
|
10864
|
+
}
|
|
10865
|
+
if (typeof global !== "undefined") {
|
|
10866
|
+
return global;
|
|
10867
|
+
}
|
|
10868
|
+
throw "Unable to locate global object";
|
|
10869
|
+
})();
|
|
10870
|
+
function longToNumber(long) {
|
|
10871
|
+
if (long.gt(Number.MAX_SAFE_INTEGER)) {
|
|
10872
|
+
throw new tsProtoGlobalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
|
|
10873
|
+
}
|
|
10874
|
+
return long.toNumber();
|
|
10875
|
+
}
|
|
10876
|
+
if (minimalExports.util.Long !== longExports) {
|
|
10877
|
+
minimalExports.util.Long = longExports;
|
|
10878
|
+
minimalExports.configure();
|
|
10879
|
+
}
|
|
10880
|
+
|
|
10881
|
+
/* eslint-disable */
|
|
10882
|
+
function createBasePBPointerEventsResult() {
|
|
10883
|
+
return { commands: [] };
|
|
10884
|
+
}
|
|
10885
|
+
/**
|
|
10886
|
+
* Internal
|
|
10887
|
+
*/
|
|
10888
|
+
const PBPointerEventsResult = {
|
|
10889
|
+
encode(message, writer = minimalExports.Writer.create()) {
|
|
10890
|
+
for (const v of message.commands) {
|
|
10891
|
+
PBPointerEventsResult_PointerCommand.encode(v, writer.uint32(10).fork()).ldelim();
|
|
10892
|
+
}
|
|
10893
|
+
return writer;
|
|
10894
|
+
},
|
|
10895
|
+
decode(input, length) {
|
|
10896
|
+
const reader = input instanceof minimalExports.Reader ? input : new minimalExports.Reader(input);
|
|
10897
|
+
let end = length === undefined ? reader.len : reader.pos + length;
|
|
10898
|
+
const message = createBasePBPointerEventsResult();
|
|
10899
|
+
while (reader.pos < end) {
|
|
10900
|
+
const tag = reader.uint32();
|
|
10901
|
+
switch (tag >>> 3) {
|
|
10902
|
+
case 1:
|
|
10903
|
+
message.commands.push(PBPointerEventsResult_PointerCommand.decode(reader, reader.uint32()));
|
|
10904
|
+
break;
|
|
10905
|
+
default:
|
|
10906
|
+
reader.skipType(tag & 7);
|
|
10907
|
+
break;
|
|
10908
|
+
}
|
|
10909
|
+
}
|
|
10910
|
+
return message;
|
|
10911
|
+
},
|
|
10912
|
+
};
|
|
10913
|
+
function createBasePBPointerEventsResult_PointerCommand() {
|
|
10914
|
+
return { button: 0, hit: undefined, state: 0, timestamp: 0, analog: undefined };
|
|
10915
|
+
}
|
|
10916
|
+
/**
|
|
10917
|
+
* Internal
|
|
10918
|
+
*/
|
|
10919
|
+
const PBPointerEventsResult_PointerCommand = {
|
|
10920
|
+
encode(message, writer = minimalExports.Writer.create()) {
|
|
10921
|
+
if (message.button !== 0) {
|
|
10922
|
+
writer.uint32(8).int32(message.button);
|
|
10923
|
+
}
|
|
10924
|
+
if (message.hit !== undefined) {
|
|
10925
|
+
RaycastHit.encode(message.hit, writer.uint32(18).fork()).ldelim();
|
|
10926
|
+
}
|
|
10927
|
+
if (message.state !== 0) {
|
|
10928
|
+
writer.uint32(32).int32(message.state);
|
|
10929
|
+
}
|
|
10930
|
+
if (message.timestamp !== 0) {
|
|
10931
|
+
writer.uint32(40).int32(message.timestamp);
|
|
10932
|
+
}
|
|
10933
|
+
if (message.analog !== undefined) {
|
|
10934
|
+
writer.uint32(53).float(message.analog);
|
|
10935
|
+
}
|
|
10936
|
+
return writer;
|
|
10937
|
+
},
|
|
10938
|
+
decode(input, length) {
|
|
10939
|
+
const reader = input instanceof minimalExports.Reader ? input : new minimalExports.Reader(input);
|
|
10940
|
+
let end = length === undefined ? reader.len : reader.pos + length;
|
|
10941
|
+
const message = createBasePBPointerEventsResult_PointerCommand();
|
|
10942
|
+
while (reader.pos < end) {
|
|
10943
|
+
const tag = reader.uint32();
|
|
10944
|
+
switch (tag >>> 3) {
|
|
10945
|
+
case 1:
|
|
10946
|
+
message.button = reader.int32();
|
|
10947
|
+
break;
|
|
10948
|
+
case 2:
|
|
10949
|
+
message.hit = RaycastHit.decode(reader, reader.uint32());
|
|
10950
|
+
break;
|
|
10951
|
+
case 4:
|
|
10952
|
+
message.state = reader.int32();
|
|
10953
|
+
break;
|
|
10954
|
+
case 5:
|
|
10955
|
+
message.timestamp = reader.int32();
|
|
10956
|
+
break;
|
|
10957
|
+
case 6:
|
|
10958
|
+
message.analog = reader.float();
|
|
10959
|
+
break;
|
|
10960
|
+
default:
|
|
10961
|
+
reader.skipType(tag & 7);
|
|
10962
|
+
break;
|
|
10963
|
+
}
|
|
10964
|
+
}
|
|
10965
|
+
return message;
|
|
10966
|
+
},
|
|
10967
|
+
};
|
|
10968
|
+
|
|
10969
|
+
/**
|
|
10970
|
+
*
|
|
10971
|
+
*/
|
|
10972
|
+
const PointerEventsResultSchema = {
|
|
10973
|
+
COMPONENT_ID: 1063,
|
|
10974
|
+
serialize(value, builder) {
|
|
10975
|
+
const writer = PBPointerEventsResult.encode(value);
|
|
10964
10976
|
const buffer = new Uint8Array(writer.finish(), 0, writer.len);
|
|
10965
10977
|
builder.writeBuffer(buffer, false);
|
|
10966
10978
|
},
|
|
10967
10979
|
deserialize(reader) {
|
|
10968
|
-
return
|
|
10980
|
+
return PBPointerEventsResult.decode(reader.buffer(), reader.remainingBytes());
|
|
10969
10981
|
},
|
|
10970
10982
|
create() {
|
|
10971
10983
|
// TODO: this is a hack.
|
|
10972
|
-
return
|
|
10984
|
+
return PBPointerEventsResult.decode(new Uint8Array());
|
|
10973
10985
|
}
|
|
10974
10986
|
};
|
|
10975
10987
|
|
|
@@ -11003,7 +11015,7 @@
|
|
|
11003
11015
|
}
|
|
11004
11016
|
}
|
|
11005
11017
|
return message;
|
|
11006
|
-
}
|
|
11018
|
+
},
|
|
11007
11019
|
};
|
|
11008
11020
|
|
|
11009
11021
|
/**
|
|
@@ -11078,7 +11090,7 @@
|
|
|
11078
11090
|
}
|
|
11079
11091
|
}
|
|
11080
11092
|
return message;
|
|
11081
|
-
}
|
|
11093
|
+
},
|
|
11082
11094
|
};
|
|
11083
11095
|
|
|
11084
11096
|
/**
|
|
@@ -11119,9 +11131,10 @@
|
|
|
11119
11131
|
}
|
|
11120
11132
|
};
|
|
11121
11133
|
|
|
11134
|
+
/* eslint-disable */
|
|
11122
11135
|
function createBasePBTextShape() {
|
|
11123
11136
|
return {
|
|
11124
|
-
text:
|
|
11137
|
+
text: "",
|
|
11125
11138
|
font: undefined,
|
|
11126
11139
|
fontSize: undefined,
|
|
11127
11140
|
fontAutoSize: undefined,
|
|
@@ -11141,7 +11154,7 @@
|
|
|
11141
11154
|
outlineWidth: undefined,
|
|
11142
11155
|
shadowColor: undefined,
|
|
11143
11156
|
outlineColor: undefined,
|
|
11144
|
-
textColor: undefined
|
|
11157
|
+
textColor: undefined,
|
|
11145
11158
|
};
|
|
11146
11159
|
}
|
|
11147
11160
|
/**
|
|
@@ -11149,7 +11162,7 @@
|
|
|
11149
11162
|
*/
|
|
11150
11163
|
const PBTextShape = {
|
|
11151
11164
|
encode(message, writer = minimalExports.Writer.create()) {
|
|
11152
|
-
if (message.text !==
|
|
11165
|
+
if (message.text !== "") {
|
|
11153
11166
|
writer.uint32(10).string(message.text);
|
|
11154
11167
|
}
|
|
11155
11168
|
if (message.font !== undefined) {
|
|
@@ -11290,7 +11303,7 @@
|
|
|
11290
11303
|
}
|
|
11291
11304
|
}
|
|
11292
11305
|
return message;
|
|
11293
|
-
}
|
|
11306
|
+
},
|
|
11294
11307
|
};
|
|
11295
11308
|
|
|
11296
11309
|
/**
|
|
@@ -11313,17 +11326,103 @@
|
|
|
11313
11326
|
};
|
|
11314
11327
|
|
|
11315
11328
|
/* eslint-disable */
|
|
11329
|
+
function createBaseBorderRect() {
|
|
11330
|
+
return { top: 0, left: 0, right: 0, bottom: 0 };
|
|
11331
|
+
}
|
|
11332
|
+
/**
|
|
11333
|
+
* Internal
|
|
11334
|
+
*/
|
|
11335
|
+
const BorderRect = {
|
|
11336
|
+
encode(message, writer = minimalExports.Writer.create()) {
|
|
11337
|
+
if (message.top !== 0) {
|
|
11338
|
+
writer.uint32(13).float(message.top);
|
|
11339
|
+
}
|
|
11340
|
+
if (message.left !== 0) {
|
|
11341
|
+
writer.uint32(21).float(message.left);
|
|
11342
|
+
}
|
|
11343
|
+
if (message.right !== 0) {
|
|
11344
|
+
writer.uint32(29).float(message.right);
|
|
11345
|
+
}
|
|
11346
|
+
if (message.bottom !== 0) {
|
|
11347
|
+
writer.uint32(37).float(message.bottom);
|
|
11348
|
+
}
|
|
11349
|
+
return writer;
|
|
11350
|
+
},
|
|
11351
|
+
decode(input, length) {
|
|
11352
|
+
const reader = input instanceof minimalExports.Reader ? input : new minimalExports.Reader(input);
|
|
11353
|
+
let end = length === undefined ? reader.len : reader.pos + length;
|
|
11354
|
+
const message = createBaseBorderRect();
|
|
11355
|
+
while (reader.pos < end) {
|
|
11356
|
+
const tag = reader.uint32();
|
|
11357
|
+
switch (tag >>> 3) {
|
|
11358
|
+
case 1:
|
|
11359
|
+
message.top = reader.float();
|
|
11360
|
+
break;
|
|
11361
|
+
case 2:
|
|
11362
|
+
message.left = reader.float();
|
|
11363
|
+
break;
|
|
11364
|
+
case 3:
|
|
11365
|
+
message.right = reader.float();
|
|
11366
|
+
break;
|
|
11367
|
+
case 4:
|
|
11368
|
+
message.bottom = reader.float();
|
|
11369
|
+
break;
|
|
11370
|
+
default:
|
|
11371
|
+
reader.skipType(tag & 7);
|
|
11372
|
+
break;
|
|
11373
|
+
}
|
|
11374
|
+
}
|
|
11375
|
+
return message;
|
|
11376
|
+
},
|
|
11377
|
+
};
|
|
11378
|
+
|
|
11379
|
+
/* eslint-disable */
|
|
11380
|
+
exports.BackgroundTextureMode = void 0;
|
|
11381
|
+
(function (BackgroundTextureMode) {
|
|
11382
|
+
/**
|
|
11383
|
+
* NINE_SLICES - https://docs.unity3d.com/Manual/UIE-USS-SupportedProperties.html (Slicing section)
|
|
11384
|
+
* https://forum.unity.com/threads/how-does-slicing-in-ui-tookkit-works.1235863/
|
|
11385
|
+
* https://docs.unity3d.com/Manual/9SliceSprites.html
|
|
11386
|
+
* https://developer.mozilla.org/en-US/docs/Web/CSS/border-image-slice
|
|
11387
|
+
*/
|
|
11388
|
+
BackgroundTextureMode[BackgroundTextureMode["NINE_SLICES"] = 0] = "NINE_SLICES";
|
|
11389
|
+
/**
|
|
11390
|
+
* CENTER - CENTER enables the texture to be rendered centered in relation to the
|
|
11391
|
+
* element. If the element is smaller than the texture then the background
|
|
11392
|
+
* should use the element as stencil to cut off the out-of-bounds area
|
|
11393
|
+
*/
|
|
11394
|
+
BackgroundTextureMode[BackgroundTextureMode["CENTER"] = 1] = "CENTER";
|
|
11395
|
+
/**
|
|
11396
|
+
* STRETCH - STRETCH enables the texture to cover all the area of the container,
|
|
11397
|
+
* adopting its aspect ratio.
|
|
11398
|
+
*/
|
|
11399
|
+
BackgroundTextureMode[BackgroundTextureMode["STRETCH"] = 2] = "STRETCH";
|
|
11400
|
+
})(exports.BackgroundTextureMode || (exports.BackgroundTextureMode = {}));
|
|
11316
11401
|
function createBasePBUiBackground() {
|
|
11317
|
-
return {
|
|
11402
|
+
return { color: undefined, texture: undefined, textureMode: 0, textureSlices: undefined, uvs: [] };
|
|
11318
11403
|
}
|
|
11319
11404
|
/**
|
|
11320
11405
|
* Internal
|
|
11321
11406
|
*/
|
|
11322
11407
|
const PBUiBackground = {
|
|
11323
11408
|
encode(message, writer = minimalExports.Writer.create()) {
|
|
11324
|
-
if (message.
|
|
11325
|
-
Color4.encode(message.
|
|
11409
|
+
if (message.color !== undefined) {
|
|
11410
|
+
Color4.encode(message.color, writer.uint32(10).fork()).ldelim();
|
|
11411
|
+
}
|
|
11412
|
+
if (message.texture !== undefined) {
|
|
11413
|
+
TextureUnion.encode(message.texture, writer.uint32(18).fork()).ldelim();
|
|
11414
|
+
}
|
|
11415
|
+
if (message.textureMode !== 0) {
|
|
11416
|
+
writer.uint32(24).int32(message.textureMode);
|
|
11326
11417
|
}
|
|
11418
|
+
if (message.textureSlices !== undefined) {
|
|
11419
|
+
BorderRect.encode(message.textureSlices, writer.uint32(34).fork()).ldelim();
|
|
11420
|
+
}
|
|
11421
|
+
writer.uint32(42).fork();
|
|
11422
|
+
for (const v of message.uvs) {
|
|
11423
|
+
writer.float(v);
|
|
11424
|
+
}
|
|
11425
|
+
writer.ldelim();
|
|
11327
11426
|
return writer;
|
|
11328
11427
|
},
|
|
11329
11428
|
decode(input, length) {
|
|
@@ -11334,7 +11433,27 @@
|
|
|
11334
11433
|
const tag = reader.uint32();
|
|
11335
11434
|
switch (tag >>> 3) {
|
|
11336
11435
|
case 1:
|
|
11337
|
-
message.
|
|
11436
|
+
message.color = Color4.decode(reader, reader.uint32());
|
|
11437
|
+
break;
|
|
11438
|
+
case 2:
|
|
11439
|
+
message.texture = TextureUnion.decode(reader, reader.uint32());
|
|
11440
|
+
break;
|
|
11441
|
+
case 3:
|
|
11442
|
+
message.textureMode = reader.int32();
|
|
11443
|
+
break;
|
|
11444
|
+
case 4:
|
|
11445
|
+
message.textureSlices = BorderRect.decode(reader, reader.uint32());
|
|
11446
|
+
break;
|
|
11447
|
+
case 5:
|
|
11448
|
+
if ((tag & 7) === 2) {
|
|
11449
|
+
const end2 = reader.uint32() + reader.pos;
|
|
11450
|
+
while (reader.pos < end2) {
|
|
11451
|
+
message.uvs.push(reader.float());
|
|
11452
|
+
}
|
|
11453
|
+
}
|
|
11454
|
+
else {
|
|
11455
|
+
message.uvs.push(reader.float());
|
|
11456
|
+
}
|
|
11338
11457
|
break;
|
|
11339
11458
|
default:
|
|
11340
11459
|
reader.skipType(tag & 7);
|
|
@@ -11342,7 +11461,7 @@
|
|
|
11342
11461
|
}
|
|
11343
11462
|
}
|
|
11344
11463
|
return message;
|
|
11345
|
-
}
|
|
11464
|
+
},
|
|
11346
11465
|
};
|
|
11347
11466
|
|
|
11348
11467
|
/**
|
|
@@ -11364,16 +11483,326 @@
|
|
|
11364
11483
|
}
|
|
11365
11484
|
};
|
|
11366
11485
|
|
|
11486
|
+
/* eslint-disable */
|
|
11487
|
+
function createBasePBUiDropdown() {
|
|
11488
|
+
return {
|
|
11489
|
+
acceptEmpty: false,
|
|
11490
|
+
emptyLabel: undefined,
|
|
11491
|
+
options: [],
|
|
11492
|
+
selectedIndex: undefined,
|
|
11493
|
+
disabled: false,
|
|
11494
|
+
color: undefined,
|
|
11495
|
+
textAlign: undefined,
|
|
11496
|
+
font: undefined,
|
|
11497
|
+
fontSize: undefined,
|
|
11498
|
+
};
|
|
11499
|
+
}
|
|
11500
|
+
/**
|
|
11501
|
+
* Internal
|
|
11502
|
+
*/
|
|
11503
|
+
const PBUiDropdown = {
|
|
11504
|
+
encode(message, writer = minimalExports.Writer.create()) {
|
|
11505
|
+
if (message.acceptEmpty === true) {
|
|
11506
|
+
writer.uint32(8).bool(message.acceptEmpty);
|
|
11507
|
+
}
|
|
11508
|
+
if (message.emptyLabel !== undefined) {
|
|
11509
|
+
writer.uint32(18).string(message.emptyLabel);
|
|
11510
|
+
}
|
|
11511
|
+
for (const v of message.options) {
|
|
11512
|
+
writer.uint32(26).string(v);
|
|
11513
|
+
}
|
|
11514
|
+
if (message.selectedIndex !== undefined) {
|
|
11515
|
+
writer.uint32(32).int32(message.selectedIndex);
|
|
11516
|
+
}
|
|
11517
|
+
if (message.disabled === true) {
|
|
11518
|
+
writer.uint32(40).bool(message.disabled);
|
|
11519
|
+
}
|
|
11520
|
+
if (message.color !== undefined) {
|
|
11521
|
+
Color4.encode(message.color, writer.uint32(50).fork()).ldelim();
|
|
11522
|
+
}
|
|
11523
|
+
if (message.textAlign !== undefined) {
|
|
11524
|
+
writer.uint32(80).int32(message.textAlign);
|
|
11525
|
+
}
|
|
11526
|
+
if (message.font !== undefined) {
|
|
11527
|
+
writer.uint32(88).int32(message.font);
|
|
11528
|
+
}
|
|
11529
|
+
if (message.fontSize !== undefined) {
|
|
11530
|
+
writer.uint32(96).int32(message.fontSize);
|
|
11531
|
+
}
|
|
11532
|
+
return writer;
|
|
11533
|
+
},
|
|
11534
|
+
decode(input, length) {
|
|
11535
|
+
const reader = input instanceof minimalExports.Reader ? input : new minimalExports.Reader(input);
|
|
11536
|
+
let end = length === undefined ? reader.len : reader.pos + length;
|
|
11537
|
+
const message = createBasePBUiDropdown();
|
|
11538
|
+
while (reader.pos < end) {
|
|
11539
|
+
const tag = reader.uint32();
|
|
11540
|
+
switch (tag >>> 3) {
|
|
11541
|
+
case 1:
|
|
11542
|
+
message.acceptEmpty = reader.bool();
|
|
11543
|
+
break;
|
|
11544
|
+
case 2:
|
|
11545
|
+
message.emptyLabel = reader.string();
|
|
11546
|
+
break;
|
|
11547
|
+
case 3:
|
|
11548
|
+
message.options.push(reader.string());
|
|
11549
|
+
break;
|
|
11550
|
+
case 4:
|
|
11551
|
+
message.selectedIndex = reader.int32();
|
|
11552
|
+
break;
|
|
11553
|
+
case 5:
|
|
11554
|
+
message.disabled = reader.bool();
|
|
11555
|
+
break;
|
|
11556
|
+
case 6:
|
|
11557
|
+
message.color = Color4.decode(reader, reader.uint32());
|
|
11558
|
+
break;
|
|
11559
|
+
case 10:
|
|
11560
|
+
message.textAlign = reader.int32();
|
|
11561
|
+
break;
|
|
11562
|
+
case 11:
|
|
11563
|
+
message.font = reader.int32();
|
|
11564
|
+
break;
|
|
11565
|
+
case 12:
|
|
11566
|
+
message.fontSize = reader.int32();
|
|
11567
|
+
break;
|
|
11568
|
+
default:
|
|
11569
|
+
reader.skipType(tag & 7);
|
|
11570
|
+
break;
|
|
11571
|
+
}
|
|
11572
|
+
}
|
|
11573
|
+
return message;
|
|
11574
|
+
},
|
|
11575
|
+
};
|
|
11576
|
+
|
|
11577
|
+
/**
|
|
11578
|
+
*
|
|
11579
|
+
*/
|
|
11580
|
+
const UiDropdownSchema = {
|
|
11581
|
+
COMPONENT_ID: 1094,
|
|
11582
|
+
serialize(value, builder) {
|
|
11583
|
+
const writer = PBUiDropdown.encode(value);
|
|
11584
|
+
const buffer = new Uint8Array(writer.finish(), 0, writer.len);
|
|
11585
|
+
builder.writeBuffer(buffer, false);
|
|
11586
|
+
},
|
|
11587
|
+
deserialize(reader) {
|
|
11588
|
+
return PBUiDropdown.decode(reader.buffer(), reader.remainingBytes());
|
|
11589
|
+
},
|
|
11590
|
+
create() {
|
|
11591
|
+
// TODO: this is a hack.
|
|
11592
|
+
return PBUiDropdown.decode(new Uint8Array());
|
|
11593
|
+
}
|
|
11594
|
+
};
|
|
11595
|
+
|
|
11596
|
+
/* eslint-disable */
|
|
11597
|
+
function createBasePBUiDropdownResult() {
|
|
11598
|
+
return { value: 0 };
|
|
11599
|
+
}
|
|
11600
|
+
/**
|
|
11601
|
+
* Internal
|
|
11602
|
+
*/
|
|
11603
|
+
const PBUiDropdownResult = {
|
|
11604
|
+
encode(message, writer = minimalExports.Writer.create()) {
|
|
11605
|
+
if (message.value !== 0) {
|
|
11606
|
+
writer.uint32(8).int32(message.value);
|
|
11607
|
+
}
|
|
11608
|
+
return writer;
|
|
11609
|
+
},
|
|
11610
|
+
decode(input, length) {
|
|
11611
|
+
const reader = input instanceof minimalExports.Reader ? input : new minimalExports.Reader(input);
|
|
11612
|
+
let end = length === undefined ? reader.len : reader.pos + length;
|
|
11613
|
+
const message = createBasePBUiDropdownResult();
|
|
11614
|
+
while (reader.pos < end) {
|
|
11615
|
+
const tag = reader.uint32();
|
|
11616
|
+
switch (tag >>> 3) {
|
|
11617
|
+
case 1:
|
|
11618
|
+
message.value = reader.int32();
|
|
11619
|
+
break;
|
|
11620
|
+
default:
|
|
11621
|
+
reader.skipType(tag & 7);
|
|
11622
|
+
break;
|
|
11623
|
+
}
|
|
11624
|
+
}
|
|
11625
|
+
return message;
|
|
11626
|
+
},
|
|
11627
|
+
};
|
|
11628
|
+
|
|
11629
|
+
/**
|
|
11630
|
+
*
|
|
11631
|
+
*/
|
|
11632
|
+
const UiDropdownResultSchema = {
|
|
11633
|
+
COMPONENT_ID: 1096,
|
|
11634
|
+
serialize(value, builder) {
|
|
11635
|
+
const writer = PBUiDropdownResult.encode(value);
|
|
11636
|
+
const buffer = new Uint8Array(writer.finish(), 0, writer.len);
|
|
11637
|
+
builder.writeBuffer(buffer, false);
|
|
11638
|
+
},
|
|
11639
|
+
deserialize(reader) {
|
|
11640
|
+
return PBUiDropdownResult.decode(reader.buffer(), reader.remainingBytes());
|
|
11641
|
+
},
|
|
11642
|
+
create() {
|
|
11643
|
+
// TODO: this is a hack.
|
|
11644
|
+
return PBUiDropdownResult.decode(new Uint8Array());
|
|
11645
|
+
}
|
|
11646
|
+
};
|
|
11647
|
+
|
|
11648
|
+
/* eslint-disable */
|
|
11649
|
+
function createBasePBUiInput() {
|
|
11650
|
+
return {
|
|
11651
|
+
placeholder: "",
|
|
11652
|
+
color: undefined,
|
|
11653
|
+
placeholderColor: undefined,
|
|
11654
|
+
disabled: false,
|
|
11655
|
+
textAlign: undefined,
|
|
11656
|
+
font: undefined,
|
|
11657
|
+
fontSize: undefined,
|
|
11658
|
+
};
|
|
11659
|
+
}
|
|
11660
|
+
/**
|
|
11661
|
+
* Internal
|
|
11662
|
+
*/
|
|
11663
|
+
const PBUiInput = {
|
|
11664
|
+
encode(message, writer = minimalExports.Writer.create()) {
|
|
11665
|
+
if (message.placeholder !== "") {
|
|
11666
|
+
writer.uint32(10).string(message.placeholder);
|
|
11667
|
+
}
|
|
11668
|
+
if (message.color !== undefined) {
|
|
11669
|
+
Color4.encode(message.color, writer.uint32(18).fork()).ldelim();
|
|
11670
|
+
}
|
|
11671
|
+
if (message.placeholderColor !== undefined) {
|
|
11672
|
+
Color4.encode(message.placeholderColor, writer.uint32(26).fork()).ldelim();
|
|
11673
|
+
}
|
|
11674
|
+
if (message.disabled === true) {
|
|
11675
|
+
writer.uint32(32).bool(message.disabled);
|
|
11676
|
+
}
|
|
11677
|
+
if (message.textAlign !== undefined) {
|
|
11678
|
+
writer.uint32(80).int32(message.textAlign);
|
|
11679
|
+
}
|
|
11680
|
+
if (message.font !== undefined) {
|
|
11681
|
+
writer.uint32(88).int32(message.font);
|
|
11682
|
+
}
|
|
11683
|
+
if (message.fontSize !== undefined) {
|
|
11684
|
+
writer.uint32(96).int32(message.fontSize);
|
|
11685
|
+
}
|
|
11686
|
+
return writer;
|
|
11687
|
+
},
|
|
11688
|
+
decode(input, length) {
|
|
11689
|
+
const reader = input instanceof minimalExports.Reader ? input : new minimalExports.Reader(input);
|
|
11690
|
+
let end = length === undefined ? reader.len : reader.pos + length;
|
|
11691
|
+
const message = createBasePBUiInput();
|
|
11692
|
+
while (reader.pos < end) {
|
|
11693
|
+
const tag = reader.uint32();
|
|
11694
|
+
switch (tag >>> 3) {
|
|
11695
|
+
case 1:
|
|
11696
|
+
message.placeholder = reader.string();
|
|
11697
|
+
break;
|
|
11698
|
+
case 2:
|
|
11699
|
+
message.color = Color4.decode(reader, reader.uint32());
|
|
11700
|
+
break;
|
|
11701
|
+
case 3:
|
|
11702
|
+
message.placeholderColor = Color4.decode(reader, reader.uint32());
|
|
11703
|
+
break;
|
|
11704
|
+
case 4:
|
|
11705
|
+
message.disabled = reader.bool();
|
|
11706
|
+
break;
|
|
11707
|
+
case 10:
|
|
11708
|
+
message.textAlign = reader.int32();
|
|
11709
|
+
break;
|
|
11710
|
+
case 11:
|
|
11711
|
+
message.font = reader.int32();
|
|
11712
|
+
break;
|
|
11713
|
+
case 12:
|
|
11714
|
+
message.fontSize = reader.int32();
|
|
11715
|
+
break;
|
|
11716
|
+
default:
|
|
11717
|
+
reader.skipType(tag & 7);
|
|
11718
|
+
break;
|
|
11719
|
+
}
|
|
11720
|
+
}
|
|
11721
|
+
return message;
|
|
11722
|
+
},
|
|
11723
|
+
};
|
|
11724
|
+
|
|
11725
|
+
/**
|
|
11726
|
+
*
|
|
11727
|
+
*/
|
|
11728
|
+
const UiInputSchema = {
|
|
11729
|
+
COMPONENT_ID: 1093,
|
|
11730
|
+
serialize(value, builder) {
|
|
11731
|
+
const writer = PBUiInput.encode(value);
|
|
11732
|
+
const buffer = new Uint8Array(writer.finish(), 0, writer.len);
|
|
11733
|
+
builder.writeBuffer(buffer, false);
|
|
11734
|
+
},
|
|
11735
|
+
deserialize(reader) {
|
|
11736
|
+
return PBUiInput.decode(reader.buffer(), reader.remainingBytes());
|
|
11737
|
+
},
|
|
11738
|
+
create() {
|
|
11739
|
+
// TODO: this is a hack.
|
|
11740
|
+
return PBUiInput.decode(new Uint8Array());
|
|
11741
|
+
}
|
|
11742
|
+
};
|
|
11743
|
+
|
|
11744
|
+
/* eslint-disable */
|
|
11745
|
+
function createBasePBUiInputResult() {
|
|
11746
|
+
return { value: "" };
|
|
11747
|
+
}
|
|
11748
|
+
/**
|
|
11749
|
+
* Internal
|
|
11750
|
+
*/
|
|
11751
|
+
const PBUiInputResult = {
|
|
11752
|
+
encode(message, writer = minimalExports.Writer.create()) {
|
|
11753
|
+
if (message.value !== "") {
|
|
11754
|
+
writer.uint32(10).string(message.value);
|
|
11755
|
+
}
|
|
11756
|
+
return writer;
|
|
11757
|
+
},
|
|
11758
|
+
decode(input, length) {
|
|
11759
|
+
const reader = input instanceof minimalExports.Reader ? input : new minimalExports.Reader(input);
|
|
11760
|
+
let end = length === undefined ? reader.len : reader.pos + length;
|
|
11761
|
+
const message = createBasePBUiInputResult();
|
|
11762
|
+
while (reader.pos < end) {
|
|
11763
|
+
const tag = reader.uint32();
|
|
11764
|
+
switch (tag >>> 3) {
|
|
11765
|
+
case 1:
|
|
11766
|
+
message.value = reader.string();
|
|
11767
|
+
break;
|
|
11768
|
+
default:
|
|
11769
|
+
reader.skipType(tag & 7);
|
|
11770
|
+
break;
|
|
11771
|
+
}
|
|
11772
|
+
}
|
|
11773
|
+
return message;
|
|
11774
|
+
},
|
|
11775
|
+
};
|
|
11776
|
+
|
|
11777
|
+
/**
|
|
11778
|
+
*
|
|
11779
|
+
*/
|
|
11780
|
+
const UiInputResultSchema = {
|
|
11781
|
+
COMPONENT_ID: 1095,
|
|
11782
|
+
serialize(value, builder) {
|
|
11783
|
+
const writer = PBUiInputResult.encode(value);
|
|
11784
|
+
const buffer = new Uint8Array(writer.finish(), 0, writer.len);
|
|
11785
|
+
builder.writeBuffer(buffer, false);
|
|
11786
|
+
},
|
|
11787
|
+
deserialize(reader) {
|
|
11788
|
+
return PBUiInputResult.decode(reader.buffer(), reader.remainingBytes());
|
|
11789
|
+
},
|
|
11790
|
+
create() {
|
|
11791
|
+
// TODO: this is a hack.
|
|
11792
|
+
return PBUiInputResult.decode(new Uint8Array());
|
|
11793
|
+
}
|
|
11794
|
+
};
|
|
11795
|
+
|
|
11367
11796
|
/* eslint-disable */
|
|
11368
11797
|
function createBasePBUiText() {
|
|
11369
|
-
return { value:
|
|
11798
|
+
return { value: "", color: undefined, textAlign: undefined, font: undefined, fontSize: undefined };
|
|
11370
11799
|
}
|
|
11371
11800
|
/**
|
|
11372
11801
|
* Internal
|
|
11373
11802
|
*/
|
|
11374
11803
|
const PBUiText = {
|
|
11375
11804
|
encode(message, writer = minimalExports.Writer.create()) {
|
|
11376
|
-
if (message.value !==
|
|
11805
|
+
if (message.value !== "") {
|
|
11377
11806
|
writer.uint32(10).string(message.value);
|
|
11378
11807
|
}
|
|
11379
11808
|
if (message.color !== undefined) {
|
|
@@ -11418,7 +11847,7 @@
|
|
|
11418
11847
|
}
|
|
11419
11848
|
}
|
|
11420
11849
|
return message;
|
|
11421
|
-
}
|
|
11850
|
+
},
|
|
11422
11851
|
};
|
|
11423
11852
|
|
|
11424
11853
|
/**
|
|
@@ -11561,7 +11990,7 @@
|
|
|
11561
11990
|
paddingRightUnit: 0,
|
|
11562
11991
|
paddingRight: 0,
|
|
11563
11992
|
paddingBottomUnit: 0,
|
|
11564
|
-
paddingBottom: 0
|
|
11993
|
+
paddingBottom: 0,
|
|
11565
11994
|
};
|
|
11566
11995
|
}
|
|
11567
11996
|
/**
|
|
@@ -11890,7 +12319,7 @@
|
|
|
11890
12319
|
}
|
|
11891
12320
|
}
|
|
11892
12321
|
return message;
|
|
11893
|
-
}
|
|
12322
|
+
},
|
|
11894
12323
|
};
|
|
11895
12324
|
|
|
11896
12325
|
/**
|
|
@@ -11942,7 +12371,7 @@
|
|
|
11942
12371
|
}
|
|
11943
12372
|
}
|
|
11944
12373
|
return message;
|
|
11945
|
-
}
|
|
12374
|
+
},
|
|
11946
12375
|
};
|
|
11947
12376
|
|
|
11948
12377
|
/**
|
|
@@ -11978,13 +12407,17 @@
|
|
|
11978
12407
|
/** @public */ const MeshCollider$2 = engine => engine.defineComponentFromSchema(MeshColliderSchema, MeshColliderSchema.COMPONENT_ID);
|
|
11979
12408
|
/** @public */ const MeshRenderer$2 = engine => engine.defineComponentFromSchema(MeshRendererSchema, MeshRendererSchema.COMPONENT_ID);
|
|
11980
12409
|
/** @public */ const NftShape$1 = engine => engine.defineComponentFromSchema(NftShapeSchema, NftShapeSchema.COMPONENT_ID);
|
|
12410
|
+
/** @public */ const PointerEvents$1 = engine => engine.defineComponentFromSchema(PointerEventsSchema, PointerEventsSchema.COMPONENT_ID);
|
|
11981
12411
|
/** @public */ const PointerEventsResult$1 = engine => engine.defineComponentFromSchema(PointerEventsResultSchema, PointerEventsResultSchema.COMPONENT_ID);
|
|
11982
|
-
/** @public */ const PointerHoverFeedback$1 = engine => engine.defineComponentFromSchema(PointerHoverFeedbackSchema, PointerHoverFeedbackSchema.COMPONENT_ID);
|
|
11983
12412
|
/** @public */ const PointerLock$1 = engine => engine.defineComponentFromSchema(PointerLockSchema, PointerLockSchema.COMPONENT_ID);
|
|
11984
12413
|
/** @public */ const Raycast$1 = engine => engine.defineComponentFromSchema(RaycastSchema, RaycastSchema.COMPONENT_ID);
|
|
11985
12414
|
/** @public */ const RaycastResult$1 = engine => engine.defineComponentFromSchema(RaycastResultSchema, RaycastResultSchema.COMPONENT_ID);
|
|
11986
12415
|
/** @public */ const TextShape$1 = engine => engine.defineComponentFromSchema(TextShapeSchema, TextShapeSchema.COMPONENT_ID);
|
|
11987
12416
|
/** @public */ const UiBackground$1 = engine => engine.defineComponentFromSchema(UiBackgroundSchema, UiBackgroundSchema.COMPONENT_ID);
|
|
12417
|
+
/** @public */ const UiDropdown$1 = engine => engine.defineComponentFromSchema(UiDropdownSchema, UiDropdownSchema.COMPONENT_ID);
|
|
12418
|
+
/** @public */ const UiDropdownResult$1 = engine => engine.defineComponentFromSchema(UiDropdownResultSchema, UiDropdownResultSchema.COMPONENT_ID);
|
|
12419
|
+
/** @public */ const UiInput$1 = engine => engine.defineComponentFromSchema(UiInputSchema, UiInputSchema.COMPONENT_ID);
|
|
12420
|
+
/** @public */ const UiInputResult$1 = engine => engine.defineComponentFromSchema(UiInputResultSchema, UiInputResultSchema.COMPONENT_ID);
|
|
11988
12421
|
/** @public */ const UiText$1 = engine => engine.defineComponentFromSchema(UiTextSchema, UiTextSchema.COMPONENT_ID);
|
|
11989
12422
|
/** @public */ const UiTransform$1 = engine => engine.defineComponentFromSchema(UiTransformSchema, UiTransformSchema.COMPONENT_ID);
|
|
11990
12423
|
/** @public */ const VisibilityComponent$1 = engine => engine.defineComponentFromSchema(VisibilityComponentSchema, VisibilityComponentSchema.COMPONENT_ID);
|
|
@@ -12278,19 +12711,24 @@
|
|
|
12278
12711
|
PBMeshRenderer_SphereMesh: PBMeshRenderer_SphereMesh,
|
|
12279
12712
|
get NftFrameType () { return exports.NftFrameType; },
|
|
12280
12713
|
PBNftShape: PBNftShape,
|
|
12714
|
+
get PointerEventType () { return exports.PointerEventType; },
|
|
12715
|
+
PBPointerEvents: PBPointerEvents,
|
|
12716
|
+
PBPointerEvents_Info: PBPointerEvents_Info,
|
|
12717
|
+
PBPointerEvents_Entry: PBPointerEvents_Entry,
|
|
12281
12718
|
PBPointerEventsResult: PBPointerEventsResult,
|
|
12282
12719
|
PBPointerEventsResult_PointerCommand: PBPointerEventsResult_PointerCommand,
|
|
12283
|
-
get PointerEventType () { return exports.PointerEventType; },
|
|
12284
|
-
PBPointerHoverFeedback: PBPointerHoverFeedback,
|
|
12285
|
-
PBPointerHoverFeedback_Info: PBPointerHoverFeedback_Info,
|
|
12286
|
-
PBPointerHoverFeedback_Entry: PBPointerHoverFeedback_Entry,
|
|
12287
12720
|
PBPointerLock: PBPointerLock,
|
|
12288
12721
|
get RaycastQueryType () { return exports.RaycastQueryType; },
|
|
12289
12722
|
PBRaycast: PBRaycast,
|
|
12290
12723
|
PBRaycastResult: PBRaycastResult,
|
|
12291
12724
|
RaycastHit: RaycastHit,
|
|
12292
12725
|
PBTextShape: PBTextShape,
|
|
12726
|
+
get BackgroundTextureMode () { return exports.BackgroundTextureMode; },
|
|
12293
12727
|
PBUiBackground: PBUiBackground,
|
|
12728
|
+
PBUiDropdown: PBUiDropdown,
|
|
12729
|
+
PBUiDropdownResult: PBUiDropdownResult,
|
|
12730
|
+
PBUiInput: PBUiInput,
|
|
12731
|
+
PBUiInputResult: PBUiInputResult,
|
|
12294
12732
|
PBUiText: PBUiText,
|
|
12295
12733
|
get YGPositionType () { return exports.YGPositionType; },
|
|
12296
12734
|
get YGAlign () { return exports.YGAlign; },
|
|
@@ -12313,13 +12751,17 @@
|
|
|
12313
12751
|
CameraModeArea: CameraModeArea$1,
|
|
12314
12752
|
GltfContainer: GltfContainer$1,
|
|
12315
12753
|
NftShape: NftShape$1,
|
|
12754
|
+
PointerEvents: PointerEvents$1,
|
|
12316
12755
|
PointerEventsResult: PointerEventsResult$1,
|
|
12317
|
-
PointerHoverFeedback: PointerHoverFeedback$1,
|
|
12318
12756
|
PointerLock: PointerLock$1,
|
|
12319
12757
|
Raycast: Raycast$1,
|
|
12320
12758
|
RaycastResult: RaycastResult$1,
|
|
12321
12759
|
TextShape: TextShape$1,
|
|
12322
12760
|
UiBackground: UiBackground$1,
|
|
12761
|
+
UiDropdown: UiDropdown$1,
|
|
12762
|
+
UiDropdownResult: UiDropdownResult$1,
|
|
12763
|
+
UiInput: UiInput$1,
|
|
12764
|
+
UiInputResult: UiInputResult$1,
|
|
12323
12765
|
UiText: UiText$1,
|
|
12324
12766
|
UiTransform: UiTransform$1,
|
|
12325
12767
|
VisibilityComponent: VisibilityComponent$1
|
|
@@ -14117,7 +14559,7 @@
|
|
|
14117
14559
|
}
|
|
14118
14560
|
|
|
14119
14561
|
function createPointerEventSystem(engine, inputSystem) {
|
|
14120
|
-
const
|
|
14562
|
+
const PointerEvents = PointerEvents$1(engine);
|
|
14121
14563
|
let EventType;
|
|
14122
14564
|
(function (EventType) {
|
|
14123
14565
|
EventType[EventType["Click"] = 0] = "Click";
|
|
@@ -14126,31 +14568,28 @@
|
|
|
14126
14568
|
})(EventType || (EventType = {}));
|
|
14127
14569
|
const getDefaultOpts = (opts = {}) => ({
|
|
14128
14570
|
button: 3 /* InputAction.IA_ANY */,
|
|
14129
|
-
hoverText: 'Interact',
|
|
14130
|
-
maxDistance: 100,
|
|
14131
14571
|
...opts
|
|
14132
14572
|
});
|
|
14133
14573
|
const eventsMap = new Map();
|
|
14134
14574
|
function getEvent(entity) {
|
|
14135
14575
|
return (eventsMap.get(entity) || eventsMap.set(entity, new Map()).get(entity));
|
|
14136
14576
|
}
|
|
14137
|
-
function
|
|
14138
|
-
if (opts.hoverText) {
|
|
14139
|
-
const pointerEvent =
|
|
14140
|
-
PointerHoverFeedback.create(entity);
|
|
14577
|
+
function setPointerEvent(entity, type, opts) {
|
|
14578
|
+
if (opts.hoverText || opts.showFeedback) {
|
|
14579
|
+
const pointerEvent = PointerEvents.getMutableOrNull(entity) || PointerEvents.create(entity);
|
|
14141
14580
|
pointerEvent.pointerEvents.push({
|
|
14142
14581
|
eventType: type,
|
|
14143
14582
|
eventInfo: {
|
|
14144
14583
|
button: opts.button,
|
|
14145
|
-
showFeedback:
|
|
14584
|
+
showFeedback: opts.showFeedback,
|
|
14146
14585
|
hoverText: opts.hoverText,
|
|
14147
14586
|
maxDistance: opts.maxDistance
|
|
14148
14587
|
}
|
|
14149
14588
|
});
|
|
14150
14589
|
}
|
|
14151
14590
|
}
|
|
14152
|
-
function
|
|
14153
|
-
const pointerEvent =
|
|
14591
|
+
function removePointerEvent(entity, type, button) {
|
|
14592
|
+
const pointerEvent = PointerEvents.getMutableOrNull(entity);
|
|
14154
14593
|
if (!pointerEvent)
|
|
14155
14594
|
return;
|
|
14156
14595
|
pointerEvent.pointerEvents = pointerEvent.pointerEvents.filter((pointer) => !(pointer.eventInfo?.button === button && pointer.eventType === type));
|
|
@@ -14165,7 +14604,7 @@
|
|
|
14165
14604
|
const event = getEvent(entity);
|
|
14166
14605
|
const pointerEvent = event.get(type);
|
|
14167
14606
|
if (pointerEvent?.opts.hoverText) {
|
|
14168
|
-
|
|
14607
|
+
removePointerEvent(entity, getPointerEvent(type), pointerEvent.opts.button);
|
|
14169
14608
|
}
|
|
14170
14609
|
event.delete(type);
|
|
14171
14610
|
}
|
|
@@ -14229,7 +14668,7 @@
|
|
|
14229
14668
|
removeEvent(entity, EventType.Click);
|
|
14230
14669
|
// Set new event
|
|
14231
14670
|
getEvent(entity).set(EventType.Click, { cb, opts: options });
|
|
14232
|
-
|
|
14671
|
+
setPointerEvent(entity, 1 /* PointerEventType.PET_DOWN */, options);
|
|
14233
14672
|
},
|
|
14234
14673
|
/**
|
|
14235
14674
|
* @public
|
|
@@ -14242,7 +14681,7 @@
|
|
|
14242
14681
|
const options = getDefaultOpts(opts);
|
|
14243
14682
|
removeEvent(entity, EventType.Down);
|
|
14244
14683
|
getEvent(entity).set(EventType.Down, { cb, opts: options });
|
|
14245
|
-
|
|
14684
|
+
setPointerEvent(entity, 1 /* PointerEventType.PET_DOWN */, options);
|
|
14246
14685
|
},
|
|
14247
14686
|
/**
|
|
14248
14687
|
* @public
|
|
@@ -14255,7 +14694,7 @@
|
|
|
14255
14694
|
const options = getDefaultOpts(opts);
|
|
14256
14695
|
removeEvent(entity, EventType.Up);
|
|
14257
14696
|
getEvent(entity).set(EventType.Up, { cb, opts: options });
|
|
14258
|
-
|
|
14697
|
+
setPointerEvent(entity, 0 /* PointerEventType.PET_UP */, options);
|
|
14259
14698
|
}
|
|
14260
14699
|
};
|
|
14261
14700
|
}
|
|
@@ -14277,6 +14716,64 @@
|
|
|
14277
14716
|
|
|
14278
14717
|
const executeTask = createTaskSystem(engine).executeTask;
|
|
14279
14718
|
|
|
14719
|
+
/**
|
|
14720
|
+
* Transform parenting: cyclic dependency checker
|
|
14721
|
+
* It checks only in modified Transforms
|
|
14722
|
+
*
|
|
14723
|
+
* Add this system with:
|
|
14724
|
+
* ```ts
|
|
14725
|
+
* engine.addSystem(cyclicParentingChecker(engine))
|
|
14726
|
+
* ````
|
|
14727
|
+
* And then it will check every tick the parenting.
|
|
14728
|
+
*
|
|
14729
|
+
* @public
|
|
14730
|
+
*
|
|
14731
|
+
* @params engine
|
|
14732
|
+
* @returns a system
|
|
14733
|
+
*/
|
|
14734
|
+
function cyclicParentingChecker(engine) {
|
|
14735
|
+
const Transform = Transform$1(engine);
|
|
14736
|
+
return () => {
|
|
14737
|
+
for (const entity of Transform.dirtyIterator()) {
|
|
14738
|
+
let transform = Transform.getOrNull(entity);
|
|
14739
|
+
while (transform && transform.parent) {
|
|
14740
|
+
if (transform.parent === entity) {
|
|
14741
|
+
console.error(`There is a cyclic parent with entity ${entity}`);
|
|
14742
|
+
break;
|
|
14743
|
+
}
|
|
14744
|
+
else {
|
|
14745
|
+
transform = Transform.getOrNull(transform.parent);
|
|
14746
|
+
}
|
|
14747
|
+
}
|
|
14748
|
+
}
|
|
14749
|
+
};
|
|
14750
|
+
}
|
|
14751
|
+
|
|
14752
|
+
/** @public */ const AudioSource = AudioSource$1(engine);
|
|
14753
|
+
/** @public */ const AudioStream = AudioStream$1(engine);
|
|
14754
|
+
/** @public */ const AvatarAttach = AvatarAttach$1(engine);
|
|
14755
|
+
/** @public */ const AvatarModifierArea = AvatarModifierArea$1(engine);
|
|
14756
|
+
/** @public */ const AvatarShape = AvatarShape$1(engine);
|
|
14757
|
+
/** @public */ const Billboard = Billboard$1(engine);
|
|
14758
|
+
/** @public */ const CameraMode = CameraMode$1(engine);
|
|
14759
|
+
/** @public */ const CameraModeArea = CameraModeArea$1(engine);
|
|
14760
|
+
/** @public */ const GltfContainer = GltfContainer$1(engine);
|
|
14761
|
+
/** @public */ const NftShape = NftShape$1(engine);
|
|
14762
|
+
/** @public */ const PointerEvents = PointerEvents$1(engine);
|
|
14763
|
+
/** @public */ const PointerEventsResult = PointerEventsResult$1(engine);
|
|
14764
|
+
/** @public */ const PointerLock = PointerLock$1(engine);
|
|
14765
|
+
/** @public */ const Raycast = Raycast$1(engine);
|
|
14766
|
+
/** @public */ const RaycastResult = RaycastResult$1(engine);
|
|
14767
|
+
/** @public */ const TextShape = TextShape$1(engine);
|
|
14768
|
+
/** @public */ const UiBackground = UiBackground$1(engine);
|
|
14769
|
+
/** @public */ const UiDropdown = UiDropdown$1(engine);
|
|
14770
|
+
/** @public */ const UiDropdownResult = UiDropdownResult$1(engine);
|
|
14771
|
+
/** @public */ const UiInput = UiInput$1(engine);
|
|
14772
|
+
/** @public */ const UiInputResult = UiInputResult$1(engine);
|
|
14773
|
+
/** @public */ const UiText = UiText$1(engine);
|
|
14774
|
+
/** @public */ const UiTransform = UiTransform$1(engine);
|
|
14775
|
+
/** @public */ const VisibilityComponent = VisibilityComponent$1(engine);
|
|
14776
|
+
|
|
14280
14777
|
/* eslint-disable */
|
|
14281
14778
|
exports.CameraType = void 0;
|
|
14282
14779
|
(function (CameraType) {
|
|
@@ -14284,6 +14781,25 @@
|
|
|
14284
14781
|
CameraType[CameraType["CT_THIRD_PERSON"] = 1] = "CT_THIRD_PERSON";
|
|
14285
14782
|
})(exports.CameraType || (exports.CameraType = {}));
|
|
14286
14783
|
|
|
14784
|
+
/* eslint-disable */
|
|
14785
|
+
exports.InputAction = void 0;
|
|
14786
|
+
(function (InputAction) {
|
|
14787
|
+
InputAction[InputAction["IA_POINTER"] = 0] = "IA_POINTER";
|
|
14788
|
+
InputAction[InputAction["IA_PRIMARY"] = 1] = "IA_PRIMARY";
|
|
14789
|
+
InputAction[InputAction["IA_SECONDARY"] = 2] = "IA_SECONDARY";
|
|
14790
|
+
InputAction[InputAction["IA_ANY"] = 3] = "IA_ANY";
|
|
14791
|
+
InputAction[InputAction["IA_FORWARD"] = 4] = "IA_FORWARD";
|
|
14792
|
+
InputAction[InputAction["IA_BACKWARD"] = 5] = "IA_BACKWARD";
|
|
14793
|
+
InputAction[InputAction["IA_RIGHT"] = 6] = "IA_RIGHT";
|
|
14794
|
+
InputAction[InputAction["IA_LEFT"] = 7] = "IA_LEFT";
|
|
14795
|
+
InputAction[InputAction["IA_JUMP"] = 8] = "IA_JUMP";
|
|
14796
|
+
InputAction[InputAction["IA_WALK"] = 9] = "IA_WALK";
|
|
14797
|
+
InputAction[InputAction["IA_ACTION_3"] = 10] = "IA_ACTION_3";
|
|
14798
|
+
InputAction[InputAction["IA_ACTION_4"] = 11] = "IA_ACTION_4";
|
|
14799
|
+
InputAction[InputAction["IA_ACTION_5"] = 12] = "IA_ACTION_5";
|
|
14800
|
+
InputAction[InputAction["IA_ACTION_6"] = 13] = "IA_ACTION_6";
|
|
14801
|
+
})(exports.InputAction || (exports.InputAction = {}));
|
|
14802
|
+
|
|
14287
14803
|
/* eslint-disable */
|
|
14288
14804
|
exports.TextAlignMode = void 0;
|
|
14289
14805
|
(function (TextAlignMode) {
|
|
@@ -14304,79 +14820,6 @@
|
|
|
14304
14820
|
Font[Font["F_MONOSPACE"] = 2] = "F_MONOSPACE";
|
|
14305
14821
|
})(exports.Font || (exports.Font = {}));
|
|
14306
14822
|
|
|
14307
|
-
/**
|
|
14308
|
-
* Transform parenting: cyclic dependency checker
|
|
14309
|
-
* It checks only in modified Transforms
|
|
14310
|
-
*
|
|
14311
|
-
* Add this system with:
|
|
14312
|
-
* ```ts
|
|
14313
|
-
* engine.addSystem(cyclicParentingChecker(engine))
|
|
14314
|
-
* ````
|
|
14315
|
-
* And then it will check every tick the parenting.
|
|
14316
|
-
*
|
|
14317
|
-
* @public
|
|
14318
|
-
*
|
|
14319
|
-
* @params engine
|
|
14320
|
-
* @returns a system
|
|
14321
|
-
*/
|
|
14322
|
-
function cyclicParentingChecker(engine) {
|
|
14323
|
-
const Transform = Transform$1(engine);
|
|
14324
|
-
return () => {
|
|
14325
|
-
for (const entity of Transform.dirtyIterator()) {
|
|
14326
|
-
let transform = Transform.getOrNull(entity);
|
|
14327
|
-
while (transform && transform.parent) {
|
|
14328
|
-
if (transform.parent === entity) {
|
|
14329
|
-
console.error(`There is a cyclic parent with entity ${entity}`);
|
|
14330
|
-
break;
|
|
14331
|
-
}
|
|
14332
|
-
else {
|
|
14333
|
-
transform = Transform.getOrNull(transform.parent);
|
|
14334
|
-
}
|
|
14335
|
-
}
|
|
14336
|
-
}
|
|
14337
|
-
};
|
|
14338
|
-
}
|
|
14339
|
-
|
|
14340
|
-
/** @public */ const AudioSource = AudioSource$1(engine);
|
|
14341
|
-
/** @public */ const AudioStream = AudioStream$1(engine);
|
|
14342
|
-
/** @public */ const AvatarAttach = AvatarAttach$1(engine);
|
|
14343
|
-
/** @public */ const AvatarModifierArea = AvatarModifierArea$1(engine);
|
|
14344
|
-
/** @public */ const AvatarShape = AvatarShape$1(engine);
|
|
14345
|
-
/** @public */ const Billboard = Billboard$1(engine);
|
|
14346
|
-
/** @public */ const CameraMode = CameraMode$1(engine);
|
|
14347
|
-
/** @public */ const CameraModeArea = CameraModeArea$1(engine);
|
|
14348
|
-
/** @public */ const GltfContainer = GltfContainer$1(engine);
|
|
14349
|
-
/** @public */ const NftShape = NftShape$1(engine);
|
|
14350
|
-
/** @public */ const PointerEventsResult = PointerEventsResult$1(engine);
|
|
14351
|
-
/** @public */ const PointerHoverFeedback = PointerHoverFeedback$1(engine);
|
|
14352
|
-
/** @public */ const PointerLock = PointerLock$1(engine);
|
|
14353
|
-
/** @public */ const Raycast = Raycast$1(engine);
|
|
14354
|
-
/** @public */ const RaycastResult = RaycastResult$1(engine);
|
|
14355
|
-
/** @public */ const TextShape = TextShape$1(engine);
|
|
14356
|
-
/** @public */ const UiBackground = UiBackground$1(engine);
|
|
14357
|
-
/** @public */ const UiText = UiText$1(engine);
|
|
14358
|
-
/** @public */ const UiTransform = UiTransform$1(engine);
|
|
14359
|
-
/** @public */ const VisibilityComponent = VisibilityComponent$1(engine);
|
|
14360
|
-
|
|
14361
|
-
/* eslint-disable */
|
|
14362
|
-
exports.InputAction = void 0;
|
|
14363
|
-
(function (InputAction) {
|
|
14364
|
-
InputAction[InputAction["IA_POINTER"] = 0] = "IA_POINTER";
|
|
14365
|
-
InputAction[InputAction["IA_PRIMARY"] = 1] = "IA_PRIMARY";
|
|
14366
|
-
InputAction[InputAction["IA_SECONDARY"] = 2] = "IA_SECONDARY";
|
|
14367
|
-
InputAction[InputAction["IA_ANY"] = 3] = "IA_ANY";
|
|
14368
|
-
InputAction[InputAction["IA_FORWARD"] = 4] = "IA_FORWARD";
|
|
14369
|
-
InputAction[InputAction["IA_BACKWARD"] = 5] = "IA_BACKWARD";
|
|
14370
|
-
InputAction[InputAction["IA_RIGHT"] = 6] = "IA_RIGHT";
|
|
14371
|
-
InputAction[InputAction["IA_LEFT"] = 7] = "IA_LEFT";
|
|
14372
|
-
InputAction[InputAction["IA_JUMP"] = 8] = "IA_JUMP";
|
|
14373
|
-
InputAction[InputAction["IA_WALK"] = 9] = "IA_WALK";
|
|
14374
|
-
InputAction[InputAction["IA_ACTION_3"] = 10] = "IA_ACTION_3";
|
|
14375
|
-
InputAction[InputAction["IA_ACTION_4"] = 11] = "IA_ACTION_4";
|
|
14376
|
-
InputAction[InputAction["IA_ACTION_5"] = 12] = "IA_ACTION_5";
|
|
14377
|
-
InputAction[InputAction["IA_ACTION_6"] = 13] = "IA_ACTION_6";
|
|
14378
|
-
})(exports.InputAction || (exports.InputAction = {}));
|
|
14379
|
-
|
|
14380
14823
|
// The order of the following imports matters. Please do not auto-sort
|
|
14381
14824
|
// export components for global engine
|
|
14382
14825
|
const Transform = Transform$1(engine);
|
|
@@ -39678,25 +40121,6 @@
|
|
|
39678
40121
|
}
|
|
39679
40122
|
|
|
39680
40123
|
const CANVAS_ROOT_ENTITY = 0;
|
|
39681
|
-
/**
|
|
39682
|
-
* @public
|
|
39683
|
-
*/
|
|
39684
|
-
function parseUiTransform(props = {}) {
|
|
39685
|
-
const { position, padding, margin, height, minHeight, maxHeight, width, maxWidth, minWidth, ...otherProps } = props;
|
|
39686
|
-
return {
|
|
39687
|
-
...defaultUiTransform,
|
|
39688
|
-
...otherProps,
|
|
39689
|
-
...parsePosition(position, 'position'),
|
|
39690
|
-
...parsePosition(margin, 'margin'),
|
|
39691
|
-
...parsePosition(padding, 'padding'),
|
|
39692
|
-
...parseSize(height, 'height'),
|
|
39693
|
-
...parseSize(minHeight, 'minHeight'),
|
|
39694
|
-
...parseSize(maxHeight, 'maxHeight'),
|
|
39695
|
-
...parseSize(width, 'width'),
|
|
39696
|
-
...parseSize(minWidth, 'minWidth'),
|
|
39697
|
-
...parseSize(maxWidth, 'maxWidth')
|
|
39698
|
-
};
|
|
39699
|
-
}
|
|
39700
40124
|
const defaultUiTransform = {
|
|
39701
40125
|
parent: CANVAS_ROOT_ENTITY,
|
|
39702
40126
|
rightOf: 0,
|
|
@@ -39746,31 +40170,235 @@
|
|
|
39746
40170
|
widthUnit: 0 /* YGUnit.YGU_UNDEFINED */,
|
|
39747
40171
|
heightUnit: 0 /* YGUnit.YGU_UNDEFINED */
|
|
39748
40172
|
};
|
|
40173
|
+
/**
|
|
40174
|
+
* @public
|
|
40175
|
+
*/
|
|
40176
|
+
|
|
40177
|
+
function parseUiTransform(props = {}) {
|
|
40178
|
+
const { position, padding, margin, height, minHeight, maxHeight, width, maxWidth, minWidth, ...otherProps } = props;
|
|
40179
|
+
return {
|
|
40180
|
+
...defaultUiTransform,
|
|
40181
|
+
...otherProps,
|
|
40182
|
+
...parsePosition(position, 'position'),
|
|
40183
|
+
...parsePosition(margin, 'margin'),
|
|
40184
|
+
...parsePosition(padding, 'padding'),
|
|
40185
|
+
...parseSize(height, 'height'),
|
|
40186
|
+
...parseSize(minHeight, 'minHeight'),
|
|
40187
|
+
...parseSize(maxHeight, 'maxHeight'),
|
|
40188
|
+
...parseSize(width, 'width'),
|
|
40189
|
+
...parseSize(minWidth, 'minWidth'),
|
|
40190
|
+
...parseSize(maxWidth, 'maxWidth')
|
|
40191
|
+
};
|
|
40192
|
+
}
|
|
40193
|
+
|
|
40194
|
+
function isAvatarTexture(props) {
|
|
40195
|
+
return !!props.avatarTexture;
|
|
40196
|
+
}
|
|
40197
|
+
function isTexture(props) {
|
|
40198
|
+
return !!props.texture;
|
|
40199
|
+
}
|
|
40200
|
+
function getTexture(props) {
|
|
40201
|
+
if (isTexture(props) && props.texture) {
|
|
40202
|
+
return {
|
|
40203
|
+
tex: {
|
|
40204
|
+
$case: 'texture',
|
|
40205
|
+
texture: props.texture
|
|
40206
|
+
}
|
|
40207
|
+
};
|
|
40208
|
+
}
|
|
40209
|
+
if (isAvatarTexture(props) && props.avatarTexture) {
|
|
40210
|
+
return {
|
|
40211
|
+
tex: {
|
|
40212
|
+
$case: 'avatarTexture',
|
|
40213
|
+
avatarTexture: props.avatarTexture
|
|
40214
|
+
}
|
|
40215
|
+
};
|
|
40216
|
+
}
|
|
40217
|
+
return undefined;
|
|
40218
|
+
}
|
|
40219
|
+
/**
|
|
40220
|
+
* @public
|
|
40221
|
+
*/
|
|
40222
|
+
|
|
40223
|
+
function parseUiBackground(props) {
|
|
40224
|
+
if (!props || !Object.keys(props).length)
|
|
40225
|
+
return undefined;
|
|
40226
|
+
const texture = getTexture(props);
|
|
40227
|
+
return {
|
|
40228
|
+
...props,
|
|
40229
|
+
uvs: props.uvs ?? [],
|
|
40230
|
+
texture,
|
|
40231
|
+
textureMode: props.textureMode ?? 1 /* BackgroundTextureMode.CENTER */
|
|
40232
|
+
};
|
|
40233
|
+
}
|
|
40234
|
+
|
|
40235
|
+
/**
|
|
40236
|
+
* @internal
|
|
40237
|
+
*/
|
|
40238
|
+
function parseProps(props) {
|
|
40239
|
+
const { uiTransform, uiBackground, ...otherProps } = props;
|
|
40240
|
+
const uiTransformProps = parseUiTransform(uiTransform);
|
|
40241
|
+
const uiBackgroundProps = uiBackground
|
|
40242
|
+
? { uiBackground: parseUiBackground(uiBackground) }
|
|
40243
|
+
: undefined;
|
|
40244
|
+
return {
|
|
40245
|
+
...otherProps,
|
|
40246
|
+
uiTransform: uiTransformProps,
|
|
40247
|
+
...uiBackgroundProps
|
|
40248
|
+
};
|
|
40249
|
+
}
|
|
39749
40250
|
|
|
39750
40251
|
const listeners = {
|
|
39751
|
-
|
|
40252
|
+
onMouseDown: undefined,
|
|
40253
|
+
onMouseUp: undefined
|
|
39752
40254
|
};
|
|
39753
40255
|
const listenersKey = Object.keys(listeners);
|
|
39754
40256
|
const isListener = (key) => listenersKey.includes(key);
|
|
39755
40257
|
|
|
40258
|
+
function parseUiDropdown(props) {
|
|
40259
|
+
return {
|
|
40260
|
+
acceptEmpty: false,
|
|
40261
|
+
options: [],
|
|
40262
|
+
selectedIndex: props.acceptEmpty ? -1 : 0,
|
|
40263
|
+
disabled: false,
|
|
40264
|
+
...props
|
|
40265
|
+
};
|
|
40266
|
+
}
|
|
39756
40267
|
/**
|
|
39757
40268
|
* @public
|
|
39758
40269
|
*/
|
|
39759
|
-
|
|
39760
|
-
|
|
39761
|
-
const
|
|
39762
|
-
|
|
40270
|
+
|
|
40271
|
+
function Dropdown(props) {
|
|
40272
|
+
const { uiTransform, uiBackground, onMouseDown, onMouseUp, ...otherProps } = props;
|
|
40273
|
+
const dropdownProps = parseUiDropdown(otherProps);
|
|
40274
|
+
const commonProps = parseProps({
|
|
40275
|
+
uiTransform,
|
|
40276
|
+
uiBackground,
|
|
40277
|
+
onMouseDown,
|
|
40278
|
+
onMouseUp
|
|
40279
|
+
});
|
|
40280
|
+
return ReactEcs$1.createElement("entity", { ...commonProps, uiDropdown: dropdownProps });
|
|
40281
|
+
}
|
|
40282
|
+
|
|
40283
|
+
function parseUiInput(props) {
|
|
40284
|
+
return {
|
|
40285
|
+
disabled: false,
|
|
40286
|
+
placeholder: '',
|
|
40287
|
+
...props
|
|
40288
|
+
};
|
|
39763
40289
|
}
|
|
39764
|
-
|
|
39765
|
-
|
|
40290
|
+
/**
|
|
40291
|
+
* @public
|
|
40292
|
+
*/
|
|
40293
|
+
|
|
40294
|
+
function Input(props) {
|
|
40295
|
+
const { uiTransform, uiBackground, onMouseDown, onMouseUp, ...otherProps } = props;
|
|
40296
|
+
const inputProps = parseUiInput(otherProps);
|
|
40297
|
+
const commonProps = parseProps({
|
|
40298
|
+
uiTransform,
|
|
40299
|
+
uiBackground,
|
|
40300
|
+
onMouseDown,
|
|
40301
|
+
onMouseUp
|
|
40302
|
+
});
|
|
40303
|
+
return ReactEcs$1.createElement("entity", { ...commonProps, uiInput: inputProps });
|
|
39766
40304
|
}
|
|
39767
40305
|
|
|
40306
|
+
/**
|
|
40307
|
+
* @public
|
|
40308
|
+
*/
|
|
40309
|
+
|
|
40310
|
+
function Label(props) {
|
|
40311
|
+
const { uiTransform, uiBackground, onMouseDown, onMouseUp, ...uiTextProps } = props;
|
|
40312
|
+
const commonProps = parseProps({
|
|
40313
|
+
uiTransform,
|
|
40314
|
+
uiBackground,
|
|
40315
|
+
onMouseDown,
|
|
40316
|
+
onMouseUp
|
|
40317
|
+
});
|
|
40318
|
+
return ReactEcs$1.createElement("entity", { ...commonProps, uiText: uiTextProps });
|
|
40319
|
+
}
|
|
40320
|
+
|
|
40321
|
+
function getButtonProps(props) {
|
|
40322
|
+
if (props.type === 'primary') {
|
|
40323
|
+
return {
|
|
40324
|
+
uiBackground: { color: { r: 0.98, g: 0.17, b: 0.33, a: 1 } },
|
|
40325
|
+
uiText: { color: { r: 1, g: 1, b: 1, a: 1 } }
|
|
40326
|
+
};
|
|
40327
|
+
}
|
|
40328
|
+
if (props.type === 'secondary') {
|
|
40329
|
+
return {
|
|
40330
|
+
uiBackground: { color: { r: 1, g: 1, b: 1, a: 1 } },
|
|
40331
|
+
uiText: { color: { r: 0.98, g: 0.17, b: 0.33, a: 1 } }
|
|
40332
|
+
};
|
|
40333
|
+
}
|
|
40334
|
+
return {};
|
|
40335
|
+
}
|
|
40336
|
+
/**
|
|
40337
|
+
* @public
|
|
40338
|
+
*/
|
|
40339
|
+
|
|
40340
|
+
function Button(props) {
|
|
40341
|
+
const { uiTransform, uiBackground, onMouseDown, onMouseUp, ...uiTextProps } = props;
|
|
40342
|
+
const buttonProps = getButtonProps(props);
|
|
40343
|
+
const uiBackgroundProps = parseUiBackground({
|
|
40344
|
+
...buttonProps.uiBackground,
|
|
40345
|
+
...uiBackground
|
|
40346
|
+
});
|
|
40347
|
+
const textProps = {
|
|
40348
|
+
...buttonProps.uiText,
|
|
40349
|
+
...uiTextProps
|
|
40350
|
+
};
|
|
40351
|
+
const uiTransformProps = parseUiTransform({
|
|
40352
|
+
height: 36,
|
|
40353
|
+
...uiTransform
|
|
40354
|
+
});
|
|
40355
|
+
return (ReactEcs$1.createElement("entity", { onMouseDown: onMouseDown, onMouseUp: onMouseUp, uiTransform: uiTransformProps, uiText: textProps, uiBackground: uiBackgroundProps }));
|
|
40356
|
+
}
|
|
40357
|
+
|
|
40358
|
+
/**
|
|
40359
|
+
* @public
|
|
40360
|
+
*/
|
|
40361
|
+
|
|
40362
|
+
function UiEntity(props) {
|
|
40363
|
+
return ReactEcs$1.createElement("entity", { ...parseProps(props) });
|
|
40364
|
+
}
|
|
40365
|
+
|
|
40366
|
+
function propsChanged(component, prevProps, nextProps) {
|
|
40367
|
+
if (prevProps && !nextProps) {
|
|
40368
|
+
return { type: 'delete', component };
|
|
40369
|
+
}
|
|
40370
|
+
if (!nextProps) {
|
|
40371
|
+
return;
|
|
40372
|
+
}
|
|
40373
|
+
if (!prevProps && nextProps) {
|
|
40374
|
+
return { type: 'add', props: nextProps, component };
|
|
40375
|
+
}
|
|
40376
|
+
if (isListener(component)) {
|
|
40377
|
+
if (!isEqual(prevProps, nextProps)) {
|
|
40378
|
+
return { type: 'put', component, props: nextProps };
|
|
40379
|
+
}
|
|
40380
|
+
}
|
|
40381
|
+
const changes = {};
|
|
40382
|
+
for (const k in prevProps) {
|
|
40383
|
+
const propKey = k;
|
|
40384
|
+
if (!isEqual(prevProps[propKey], nextProps[propKey])) {
|
|
40385
|
+
changes[propKey] = nextProps[propKey];
|
|
40386
|
+
}
|
|
40387
|
+
}
|
|
40388
|
+
if (!Object.keys(changes).length) {
|
|
40389
|
+
return;
|
|
40390
|
+
}
|
|
40391
|
+
return { type: 'put', props: changes, component };
|
|
40392
|
+
}
|
|
39768
40393
|
// as any HACK so every time we add a new component, we must add also the component here.
|
|
39769
40394
|
const entityComponent = {
|
|
39770
40395
|
uiText: undefined,
|
|
39771
40396
|
uiBackground: undefined,
|
|
39772
40397
|
uiTransform: undefined,
|
|
39773
|
-
|
|
40398
|
+
onMouseDown: undefined,
|
|
40399
|
+
onMouseUp: undefined,
|
|
40400
|
+
uiInput: undefined,
|
|
40401
|
+
uiDropdown: undefined
|
|
39774
40402
|
};
|
|
39775
40403
|
const componentKeys = Object.keys(entityComponent);
|
|
39776
40404
|
function isEqual(val1, val2) {
|
|
@@ -39852,8 +40480,6 @@
|
|
|
39852
40480
|
return null;
|
|
39853
40481
|
},
|
|
39854
40482
|
/* istanbul ignore next */
|
|
39855
|
-
removeChildFromContainer() { },
|
|
39856
|
-
/* istanbul ignore next */
|
|
39857
40483
|
commitMount(_instance, _type, _props, _internalInstanceHandle) { },
|
|
39858
40484
|
/* istanbul ignore next */
|
|
39859
40485
|
resetTextContent(_instance) { },
|
|
@@ -39894,61 +40520,55 @@
|
|
|
39894
40520
|
}
|
|
39895
40521
|
};
|
|
39896
40522
|
|
|
39897
|
-
function propsChanged(component, prevProps, nextProps) {
|
|
39898
|
-
if (prevProps && !nextProps) {
|
|
39899
|
-
return { type: 'delete', component };
|
|
39900
|
-
}
|
|
39901
|
-
if (!nextProps) {
|
|
39902
|
-
return;
|
|
39903
|
-
}
|
|
39904
|
-
if (!prevProps && nextProps) {
|
|
39905
|
-
return { type: 'add', props: nextProps, component };
|
|
39906
|
-
}
|
|
39907
|
-
if (isListener(component)) {
|
|
39908
|
-
if (!isEqual(prevProps, nextProps)) {
|
|
39909
|
-
return { type: 'put', component, props: nextProps };
|
|
39910
|
-
}
|
|
39911
|
-
}
|
|
39912
|
-
const changes = {};
|
|
39913
|
-
for (const k in prevProps) {
|
|
39914
|
-
const propKey = k;
|
|
39915
|
-
if (!isEqual(prevProps[propKey], nextProps[propKey])) {
|
|
39916
|
-
changes[propKey] = nextProps[propKey];
|
|
39917
|
-
}
|
|
39918
|
-
}
|
|
39919
|
-
if (!Object.keys(changes).length) {
|
|
39920
|
-
return;
|
|
39921
|
-
}
|
|
39922
|
-
return { type: 'put', props: changes, component };
|
|
39923
|
-
}
|
|
39924
40523
|
function createReconciler(engine, pointerEvents) {
|
|
40524
|
+
// Store all the entities so when we destroy the UI we can also destroy them
|
|
39925
40525
|
const entities = new Set();
|
|
40526
|
+
// Store the onChange callbacks to be runned every time a Result has changed
|
|
40527
|
+
const changeEvents = new Map();
|
|
40528
|
+
// Initialize components
|
|
39926
40529
|
const UiTransform = UiTransform$1(engine);
|
|
39927
40530
|
const UiText = UiText$1(engine);
|
|
39928
40531
|
const UiBackground = UiBackground$1(engine);
|
|
40532
|
+
const UiInput = UiInput$1(engine);
|
|
40533
|
+
const UiInputResult = UiInputResult$1(engine);
|
|
40534
|
+
const UiDropdown = UiDropdown$1(engine);
|
|
40535
|
+
const UiDropdownResult = UiDropdownResult$1(engine);
|
|
40536
|
+
// Component ID Helper
|
|
39929
40537
|
const getComponentId = {
|
|
39930
40538
|
uiTransform: UiTransform._id,
|
|
39931
40539
|
uiText: UiText._id,
|
|
39932
|
-
uiBackground: UiBackground._id
|
|
40540
|
+
uiBackground: UiBackground._id,
|
|
40541
|
+
uiInput: UiInput._id,
|
|
40542
|
+
uiDropdown: UiDropdown._id
|
|
39933
40543
|
};
|
|
39934
40544
|
function updateTree(instance, props) {
|
|
39935
40545
|
upsertComponent(instance, props, 'uiTransform');
|
|
39936
40546
|
}
|
|
39937
40547
|
function upsertListener(instance, update) {
|
|
39938
|
-
// TODO: This handles only onClick listener for the moment
|
|
39939
40548
|
if (update.type === 'delete' || !update.props) {
|
|
39940
|
-
|
|
40549
|
+
if (update.component === 'onMouseDown') {
|
|
40550
|
+
pointerEvents.removeOnPointerDown(instance.entity);
|
|
40551
|
+
}
|
|
40552
|
+
else if (update.component === 'onMouseUp') {
|
|
40553
|
+
pointerEvents.removeOnPointerUp(instance.entity);
|
|
40554
|
+
}
|
|
39941
40555
|
return;
|
|
39942
40556
|
}
|
|
39943
40557
|
if (update.props) {
|
|
39944
|
-
|
|
40558
|
+
const pointerEvent = update.component === 'onMouseDown'
|
|
40559
|
+
? pointerEvents.onPointerDown
|
|
40560
|
+
: pointerEvents.onPointerUp;
|
|
40561
|
+
pointerEvent(instance.entity, update.props, {
|
|
39945
40562
|
button: 0 /* InputAction.IA_POINTER */,
|
|
39946
|
-
|
|
40563
|
+
// We add this showFeedBack so the pointerEventSystem creates a PointerEvent component with our entity
|
|
40564
|
+
// This is needed for the renderer to know which entities are clickeables
|
|
40565
|
+
showFeedback: true
|
|
39947
40566
|
});
|
|
39948
40567
|
}
|
|
39949
40568
|
}
|
|
39950
40569
|
function removeComponent(instance, component) {
|
|
39951
|
-
const
|
|
40570
|
+
const componentId = getComponentId[component];
|
|
40571
|
+
const Component = engine.getComponent(componentId);
|
|
39952
40572
|
Component.deleteFrom(instance.entity);
|
|
39953
40573
|
}
|
|
39954
40574
|
function upsertComponent(instance, props, componentName) {
|
|
@@ -39958,10 +40578,17 @@
|
|
|
39958
40578
|
Component.create(instance.entity);
|
|
39959
40579
|
for (const key in props) {
|
|
39960
40580
|
const keyProp = key;
|
|
39961
|
-
|
|
40581
|
+
if (key === 'onChange') {
|
|
40582
|
+
const onChange = props[keyProp];
|
|
40583
|
+
updateOnChange(instance.entity, componentId, { fn: onChange });
|
|
40584
|
+
}
|
|
40585
|
+
else {
|
|
40586
|
+
component[keyProp] = props[keyProp];
|
|
40587
|
+
}
|
|
39962
40588
|
}
|
|
39963
40589
|
}
|
|
39964
40590
|
function removeChildEntity(instance) {
|
|
40591
|
+
changeEvents.delete(instance.entity);
|
|
39965
40592
|
engine.removeEntity(instance.entity);
|
|
39966
40593
|
for (const child of instance._child) {
|
|
39967
40594
|
removeChildEntity(child);
|
|
@@ -40007,6 +40634,14 @@
|
|
|
40007
40634
|
parentInstance._child.splice(childIndex, 1);
|
|
40008
40635
|
removeChildEntity(child);
|
|
40009
40636
|
}
|
|
40637
|
+
function updateOnChange(entity, componentId, state) {
|
|
40638
|
+
const event = changeEvents.get(entity) ||
|
|
40639
|
+
changeEvents.set(entity, new Map()).get(entity);
|
|
40640
|
+
const oldState = event.get(componentId);
|
|
40641
|
+
const fn = state?.fn;
|
|
40642
|
+
const value = state?.value ?? oldState?.value;
|
|
40643
|
+
event.set(componentId, { fn, value });
|
|
40644
|
+
}
|
|
40010
40645
|
const hostConfig = {
|
|
40011
40646
|
...noopConfig,
|
|
40012
40647
|
createInstance(type, props) {
|
|
@@ -40045,7 +40680,7 @@
|
|
|
40045
40680
|
.map((component) => propsChanged(component, oldProps[component], newProps[component]))
|
|
40046
40681
|
.filter(isNotUndefined);
|
|
40047
40682
|
},
|
|
40048
|
-
commitUpdate(instance, updatePayload, _type,
|
|
40683
|
+
commitUpdate(instance, updatePayload, _type, _prevProps, _nextProps, _internalHandle) {
|
|
40049
40684
|
for (const update of updatePayload) {
|
|
40050
40685
|
if (isListener(update.component)) {
|
|
40051
40686
|
upsertListener(instance, update);
|
|
@@ -40071,14 +40706,36 @@
|
|
|
40071
40706
|
child.parent = parentInstance.entity;
|
|
40072
40707
|
updateTree(child, { rightOf: child.rightOf, parent: child.parent });
|
|
40073
40708
|
updateTree(beforeChild, { rightOf: beforeChild.rightOf });
|
|
40709
|
+
},
|
|
40710
|
+
removeChildFromContainer(parenInstance, child) {
|
|
40711
|
+
removeChildEntity(child);
|
|
40074
40712
|
}
|
|
40075
40713
|
};
|
|
40076
40714
|
const reconciler = reactReconcilerExports(hostConfig);
|
|
40077
40715
|
const root = reconciler.createContainer({}, 0, null, false, null, '',
|
|
40078
40716
|
/* istanbul ignore next */
|
|
40079
40717
|
function () { }, null);
|
|
40718
|
+
// Maybe this could be something similar to Input system, but since we
|
|
40719
|
+
// are going to use this only here, i prefer to scope it here.
|
|
40720
|
+
function handleOnChange(componentId, resultComponent) {
|
|
40721
|
+
for (const [entity, Result] of engine.getEntitiesWith(resultComponent)) {
|
|
40722
|
+
const entityState = changeEvents.get(entity)?.get(componentId);
|
|
40723
|
+
if (entityState?.fn && Result.value !== entityState.value) {
|
|
40724
|
+
// Call onChange callback and update internal timestamp
|
|
40725
|
+
entityState.fn(Result.value);
|
|
40726
|
+
updateOnChange(entity, componentId, {
|
|
40727
|
+
fn: entityState.fn,
|
|
40728
|
+
value: Result.value
|
|
40729
|
+
});
|
|
40730
|
+
}
|
|
40731
|
+
}
|
|
40732
|
+
}
|
|
40080
40733
|
return {
|
|
40081
40734
|
update: function (component) {
|
|
40735
|
+
if (changeEvents.size) {
|
|
40736
|
+
handleOnChange(UiInput._id, UiInputResult);
|
|
40737
|
+
handleOnChange(UiDropdown._id, UiDropdownResult);
|
|
40738
|
+
}
|
|
40082
40739
|
return reconciler.updateContainer(component, root, null);
|
|
40083
40740
|
},
|
|
40084
40741
|
getEntities: () => Array.from(entities)
|
|
@@ -40464,13 +41121,17 @@
|
|
|
40464
41121
|
ECSComponentIDs[ECSComponentIDs["MeshCollider"] = 1019] = "MeshCollider";
|
|
40465
41122
|
ECSComponentIDs[ECSComponentIDs["MeshRenderer"] = 1018] = "MeshRenderer";
|
|
40466
41123
|
ECSComponentIDs[ECSComponentIDs["NftShape"] = 1040] = "NftShape";
|
|
41124
|
+
ECSComponentIDs[ECSComponentIDs["PointerEvents"] = 1062] = "PointerEvents";
|
|
40467
41125
|
ECSComponentIDs[ECSComponentIDs["PointerEventsResult"] = 1063] = "PointerEventsResult";
|
|
40468
|
-
ECSComponentIDs[ECSComponentIDs["PointerHoverFeedback"] = 1062] = "PointerHoverFeedback";
|
|
40469
41126
|
ECSComponentIDs[ECSComponentIDs["PointerLock"] = 1074] = "PointerLock";
|
|
40470
41127
|
ECSComponentIDs[ECSComponentIDs["Raycast"] = 1067] = "Raycast";
|
|
40471
41128
|
ECSComponentIDs[ECSComponentIDs["RaycastResult"] = 1068] = "RaycastResult";
|
|
40472
41129
|
ECSComponentIDs[ECSComponentIDs["TextShape"] = 1030] = "TextShape";
|
|
40473
41130
|
ECSComponentIDs[ECSComponentIDs["UiBackground"] = 1053] = "UiBackground";
|
|
41131
|
+
ECSComponentIDs[ECSComponentIDs["UiDropdown"] = 1094] = "UiDropdown";
|
|
41132
|
+
ECSComponentIDs[ECSComponentIDs["UiDropdownResult"] = 1096] = "UiDropdownResult";
|
|
41133
|
+
ECSComponentIDs[ECSComponentIDs["UiInput"] = 1093] = "UiInput";
|
|
41134
|
+
ECSComponentIDs[ECSComponentIDs["UiInputResult"] = 1095] = "UiInputResult";
|
|
40474
41135
|
ECSComponentIDs[ECSComponentIDs["UiText"] = 1052] = "UiText";
|
|
40475
41136
|
ECSComponentIDs[ECSComponentIDs["UiTransform"] = 1050] = "UiTransform";
|
|
40476
41137
|
ECSComponentIDs[ECSComponentIDs["VisibilityComponent"] = 1081] = "VisibilityComponent";
|
|
@@ -40527,15 +41188,19 @@
|
|
|
40527
41188
|
exports.AvatarShape = AvatarShape;
|
|
40528
41189
|
exports.AvatarTexture = AvatarTexture;
|
|
40529
41190
|
exports.Billboard = Billboard;
|
|
41191
|
+
exports.BorderRect = BorderRect;
|
|
41192
|
+
exports.Button = Button;
|
|
40530
41193
|
exports.CANVAS_ROOT_ENTITY = CANVAS_ROOT_ENTITY;
|
|
40531
41194
|
exports.CameraMode = CameraMode;
|
|
40532
41195
|
exports.CameraModeArea = CameraModeArea;
|
|
40533
|
-
exports.Container = Container;
|
|
40534
41196
|
exports.DEG2RAD = DEG2RAD;
|
|
41197
|
+
exports.Dropdown = Dropdown;
|
|
40535
41198
|
exports.Engine = Engine;
|
|
40536
41199
|
exports.EntityContainer = EntityContainer;
|
|
40537
41200
|
exports.Epsilon = Epsilon;
|
|
40538
41201
|
exports.GltfContainer = GltfContainer;
|
|
41202
|
+
exports.Input = Input;
|
|
41203
|
+
exports.Label = Label;
|
|
40539
41204
|
exports.Material = Material;
|
|
40540
41205
|
exports.MeshCollider = MeshCollider;
|
|
40541
41206
|
exports.MeshRenderer = MeshRenderer;
|
|
@@ -40569,21 +41234,25 @@
|
|
|
40569
41234
|
exports.PBMeshRenderer_PlaneMesh = PBMeshRenderer_PlaneMesh;
|
|
40570
41235
|
exports.PBMeshRenderer_SphereMesh = PBMeshRenderer_SphereMesh;
|
|
40571
41236
|
exports.PBNftShape = PBNftShape;
|
|
41237
|
+
exports.PBPointerEvents = PBPointerEvents;
|
|
40572
41238
|
exports.PBPointerEventsResult = PBPointerEventsResult;
|
|
40573
41239
|
exports.PBPointerEventsResult_PointerCommand = PBPointerEventsResult_PointerCommand;
|
|
40574
|
-
exports.
|
|
40575
|
-
exports.
|
|
40576
|
-
exports.PBPointerHoverFeedback_Info = PBPointerHoverFeedback_Info;
|
|
41240
|
+
exports.PBPointerEvents_Entry = PBPointerEvents_Entry;
|
|
41241
|
+
exports.PBPointerEvents_Info = PBPointerEvents_Info;
|
|
40577
41242
|
exports.PBPointerLock = PBPointerLock;
|
|
40578
41243
|
exports.PBRaycast = PBRaycast;
|
|
40579
41244
|
exports.PBRaycastResult = PBRaycastResult;
|
|
40580
41245
|
exports.PBTextShape = PBTextShape;
|
|
40581
41246
|
exports.PBUiBackground = PBUiBackground;
|
|
41247
|
+
exports.PBUiDropdown = PBUiDropdown;
|
|
41248
|
+
exports.PBUiDropdownResult = PBUiDropdownResult;
|
|
41249
|
+
exports.PBUiInput = PBUiInput;
|
|
41250
|
+
exports.PBUiInputResult = PBUiInputResult;
|
|
40582
41251
|
exports.PBUiText = PBUiText;
|
|
40583
41252
|
exports.PBUiTransform = PBUiTransform;
|
|
40584
41253
|
exports.PBVisibilityComponent = PBVisibilityComponent;
|
|
41254
|
+
exports.PointerEvents = PointerEvents;
|
|
40585
41255
|
exports.PointerEventsResult = PointerEventsResult;
|
|
40586
|
-
exports.PointerHoverFeedback = PointerHoverFeedback;
|
|
40587
41256
|
exports.PointerLock = PointerLock;
|
|
40588
41257
|
exports.RAD2DEG = RAD2DEG;
|
|
40589
41258
|
exports.Raycast = Raycast;
|
|
@@ -40598,7 +41267,11 @@
|
|
|
40598
41267
|
exports.ToLinearSpace = ToLinearSpace;
|
|
40599
41268
|
exports.Transform = Transform;
|
|
40600
41269
|
exports.UiBackground = UiBackground;
|
|
41270
|
+
exports.UiDropdown = UiDropdown;
|
|
41271
|
+
exports.UiDropdownResult = UiDropdownResult;
|
|
40601
41272
|
exports.UiEntity = UiEntity;
|
|
41273
|
+
exports.UiInput = UiInput;
|
|
41274
|
+
exports.UiInputResult = UiInputResult;
|
|
40602
41275
|
exports.UiText = UiText;
|
|
40603
41276
|
exports.UiTransform = UiTransform;
|
|
40604
41277
|
exports.VisibilityComponent = VisibilityComponent;
|