@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/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: '', anchorPointId: 0 };
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 globalThis$2 = (() => {
9433
- if (typeof globalThis$2 !== 'undefined')
9434
- return globalThis$2;
9435
- if (typeof self !== 'undefined')
9432
+ var tsProtoGlobalThis$1 = (() => {
9433
+ if (typeof globalThis !== "undefined") {
9434
+ return globalThis;
9435
+ }
9436
+ if (typeof self !== "undefined") {
9436
9437
  return self;
9437
- if (typeof window !== 'undefined')
9438
+ }
9439
+ if (typeof window !== "undefined") {
9438
9440
  return window;
9439
- if (typeof global !== 'undefined')
9441
+ }
9442
+ if (typeof global !== "undefined") {
9440
9443
  return global;
9441
- throw 'Unable to locate global object';
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 globalThis$2.Error('Value is larger than Number.MAX_SAFE_INTEGER');
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: '', wrapMode: undefined, filterMode: undefined };
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: '', wrapMode: undefined, filterMode: undefined };
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 === 'texture') {
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 === 'avatarTexture') {
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: 'texture', texture: Texture.decode(reader, reader.uint32()) };
9826
+ message.tex = { $case: "texture", texture: Texture.decode(reader, reader.uint32()) };
9821
9827
  break;
9822
9828
  case 2:
9823
- message.tex = { $case: 'avatarTexture', avatarTexture: AvatarTexture.decode(reader, reader.uint32()) };
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 === 'unlit') {
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 === 'pbr') {
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: 'unlit', unlit: PBMaterial_UnlitMaterial.decode(reader, reader.uint32()) };
9873
+ message.material = { $case: "unlit", unlit: PBMaterial_UnlitMaterial.decode(reader, reader.uint32()) };
9868
9874
  break;
9869
9875
  case 2:
9870
- message.material = { $case: 'pbr', pbr: PBMaterial_PbrMaterial.decode(reader, reader.uint32()) };
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 === 'box') {
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 === 'sphere') {
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 === 'cylinder') {
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 === 'plane') {
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: 'box', box: PBMeshCollider_BoxMesh.decode(reader, reader.uint32()) };
10130
+ message.mesh = { $case: "box", box: PBMeshCollider_BoxMesh.decode(reader, reader.uint32()) };
10125
10131
  break;
10126
10132
  case 3:
10127
- message.mesh = { $case: 'sphere', sphere: PBMeshCollider_SphereMesh.decode(reader, reader.uint32()) };
10133
+ message.mesh = { $case: "sphere", sphere: PBMeshCollider_SphereMesh.decode(reader, reader.uint32()) };
10128
10134
  break;
10129
10135
  case 4:
10130
- message.mesh = { $case: 'cylinder', cylinder: PBMeshCollider_CylinderMesh.decode(reader, reader.uint32()) };
10136
+ message.mesh = { $case: "cylinder", cylinder: PBMeshCollider_CylinderMesh.decode(reader, reader.uint32()) };
10131
10137
  break;
10132
10138
  case 5:
10133
- message.mesh = { $case: 'plane', plane: PBMeshCollider_PlaneMesh.decode(reader, reader.uint32()) };
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 === 'box') {
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 === 'sphere') {
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 === 'cylinder') {
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 === 'plane') {
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: 'box', box: PBMeshRenderer_BoxMesh.decode(reader, reader.uint32()) };
10312
+ message.mesh = { $case: "box", box: PBMeshRenderer_BoxMesh.decode(reader, reader.uint32()) };
10307
10313
  break;
10308
10314
  case 2:
10309
- message.mesh = { $case: 'sphere', sphere: PBMeshRenderer_SphereMesh.decode(reader, reader.uint32()) };
10315
+ message.mesh = { $case: "sphere", sphere: PBMeshRenderer_SphereMesh.decode(reader, reader.uint32()) };
10310
10316
  break;
10311
10317
  case 3:
10312
- message.mesh = { $case: 'cylinder', cylinder: PBMeshRenderer_CylinderMesh.decode(reader, reader.uint32()) };
10318
+ message.mesh = { $case: "cylinder", cylinder: PBMeshRenderer_CylinderMesh.decode(reader, reader.uint32()) };
10313
10319
  break;
10314
10320
  case 4:
10315
- message.mesh = { $case: 'plane', plane: PBMeshRenderer_PlaneMesh.decode(reader, reader.uint32()) };
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: '', style: undefined, color: undefined };
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 createBasePBPointerHoverFeedback() {
10593
+ function createBasePBPointerEvents() {
10840
10594
  return { pointerEvents: [] };
10841
10595
  }
10842
10596
  /**
10843
10597
  * Internal
10844
10598
  */
10845
- const PBPointerHoverFeedback = {
10599
+ const PBPointerEvents = {
10846
10600
  encode(message, writer = minimalExports.Writer.create()) {
10847
10601
  for (const v of message.pointerEvents) {
10848
- PBPointerHoverFeedback_Entry.encode(v, writer.uint32(10).fork()).ldelim();
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 = createBasePBPointerHoverFeedback();
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(PBPointerHoverFeedback_Entry.decode(reader, reader.uint32()));
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 createBasePBPointerHoverFeedback_Info() {
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 PBPointerHoverFeedback_Info = {
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 = createBasePBPointerHoverFeedback_Info();
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 createBasePBPointerHoverFeedback_Entry() {
10673
+ function createBasePBPointerEvents_Entry() {
10920
10674
  return { eventType: 0, eventInfo: undefined };
10921
10675
  }
10922
10676
  /**
10923
10677
  * Internal
10924
10678
  */
10925
- const PBPointerHoverFeedback_Entry = {
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
- PBPointerHoverFeedback_Info.encode(message.eventInfo, writer.uint32(18).fork()).ldelim();
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 = createBasePBPointerHoverFeedback_Entry();
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 = PBPointerHoverFeedback_Info.decode(reader, reader.uint32());
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 PointerHoverFeedbackSchema = {
10714
+ const PointerEventsSchema = {
10961
10715
  COMPONENT_ID: 1062,
10962
10716
  serialize(value, builder) {
10963
- const writer = PBPointerHoverFeedback.encode(value);
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 PBPointerHoverFeedback.decode(reader.buffer(), reader.remainingBytes());
10980
+ return PBPointerEventsResult.decode(reader.buffer(), reader.remainingBytes());
10969
10981
  },
10970
10982
  create() {
10971
10983
  // TODO: this is a hack.
10972
- return PBPointerHoverFeedback.decode(new Uint8Array());
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 { backgroundColor: undefined };
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.backgroundColor !== undefined) {
11325
- Color4.encode(message.backgroundColor, writer.uint32(10).fork()).ldelim();
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.backgroundColor = Color4.decode(reader, reader.uint32());
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: '', color: undefined, textAlign: undefined, font: undefined, fontSize: undefined };
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 PointerHoverFeedback = PointerHoverFeedback$1(engine);
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 setHoverFeedback(entity, type, opts) {
14138
- if (opts.hoverText) {
14139
- const pointerEvent = PointerHoverFeedback.getMutableOrNull(entity) ||
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: true,
14584
+ showFeedback: opts.showFeedback,
14146
14585
  hoverText: opts.hoverText,
14147
14586
  maxDistance: opts.maxDistance
14148
14587
  }
14149
14588
  });
14150
14589
  }
14151
14590
  }
14152
- function removeHoverFeedback(entity, type, button) {
14153
- const pointerEvent = PointerHoverFeedback.getMutableOrNull(entity);
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
- removeHoverFeedback(entity, getPointerEvent(type), pointerEvent.opts.button);
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
- setHoverFeedback(entity, 1 /* PointerEventType.PET_DOWN */, options);
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
- setHoverFeedback(entity, 1 /* PointerEventType.PET_DOWN */, options);
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
- setHoverFeedback(entity, 0 /* PointerEventType.PET_UP */, options);
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
- onClick: undefined
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
- function UiEntity(props) {
39760
- const { uiTransform, ...otherProps } = props;
39761
- const uiTransformProps = parseUiTransform(uiTransform);
39762
- return ReactEcs$1.createElement("entity", { uiTransform: uiTransformProps, ...otherProps });
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
- function Container({ width, height, children }) {
39765
- return (ReactEcs$1.createElement(UiEntity, { uiTransform: { width, height, display: 0 /* YGDisplay.YGD_FLEX */ } }, children));
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
- onClick: undefined
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
- pointerEvents.removeOnPointerDown(instance.entity);
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
- pointerEvents.onPointerDown(instance.entity, update.props, {
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
- hoverText: ''
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 Component = engine.getComponent(getComponentId[component]);
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
- component[keyProp] = props[keyProp];
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, _prevPropsProps, _nextProps, _internalHandle) {
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.PBPointerHoverFeedback = PBPointerHoverFeedback;
40575
- exports.PBPointerHoverFeedback_Entry = PBPointerHoverFeedback_Entry;
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;