@dcl/ecs 7.1.12-4959459822.commit-47fda0f → 7.1.12-4960633446.commit-728c1f7

package/dist/components/generated/pb/decentraland/sdk/components/gltf_container.gen.js

@@ -7,11 +7,9 @@ function createBasePBGltfContainer() {
 /**
  * @public
  */
-/**
- * @internal
- */
-export const PBGltfContainer = {
-    encode(message, writer = _m0.Writer.create()) {
+export var PBGltfContainer;
+(function (PBGltfContainer) {
+    function encode(message, writer = _m0.Writer.create()) {
         if (message.src !== "") {
             writer.uint32(10).string(message.src);
         }
@@ -22,8 +20,9 @@ export const PBGltfContainer = {
             writer.uint32(40).uint32(message.invisibleMeshesCollisionMask);
         }
         return writer;
-    },
-    decode(input, length) {
+    }
+    PBGltfContainer.encode = encode;
+    function decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBasePBGltfContainer();
@@ -31,29 +30,30 @@ export const PBGltfContainer = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    if (tag != 10) {
+                    if (tag !== 10) {
                         break;
                     }
                     message.src = reader.string();
                     continue;
                 case 4:
-                    if (tag != 32) {
+                    if (tag !== 32) {
                         break;
                     }
                     message.visibleMeshesCollisionMask = reader.uint32();
                     continue;
                 case 5:
-                    if (tag != 40) {
+                    if (tag !== 40) {
                         break;
                     }
                     message.invisibleMeshesCollisionMask = reader.uint32();
                     continue;
             }
-            if ((tag & 7) == 4 || tag == 0) {
+            if ((tag & 7) === 4 || tag === 0) {
                 break;
             }
             reader.skipType(tag & 7);
         }
         return message;
-    },
-};
+    }
+    PBGltfContainer.decode = decode;
+})(PBGltfContainer || (PBGltfContainer = {}));

package/dist/components/generated/pb/decentraland/sdk/components/gltf_container_loading_state.gen.d.ts

@@ -1,3 +1,4 @@
+import _m0 from "protobufjs/minimal";
 import { LoadingState } from "./common/loading_state.gen";
 /**
  * GltfContainerLoadingState is set by the engine and provides information about
@@ -9,3 +10,10 @@ import { LoadingState } from "./common/loading_state.gen";
 export interface PBGltfContainerLoadingState {
     currentState: LoadingState;
 }
+/**
+ * @public
+ */
+export declare namespace PBGltfContainerLoadingState {
+    function encode(message: PBGltfContainerLoadingState, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBGltfContainerLoadingState;
+}

package/dist/components/generated/pb/decentraland/sdk/components/gltf_container_loading_state.gen.js

@@ -7,17 +7,16 @@ function createBasePBGltfContainerLoadingState() {
 /**
  * @public
  */
-/**
- * @internal
- */
-export const PBGltfContainerLoadingState = {
-    encode(message, writer = _m0.Writer.create()) {
+export var PBGltfContainerLoadingState;
+(function (PBGltfContainerLoadingState) {
+    function encode(message, writer = _m0.Writer.create()) {
         if (message.currentState !== 0) {
             writer.uint32(8).int32(message.currentState);
         }
         return writer;
-    },
-    decode(input, length) {
+    }
+    PBGltfContainerLoadingState.encode = encode;
+    function decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBasePBGltfContainerLoadingState();
@@ -25,17 +24,18 @@ export const PBGltfContainerLoadingState = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    if (tag != 8) {
+                    if (tag !== 8) {
                         break;
                     }
                     message.currentState = reader.int32();
                     continue;
             }
-            if ((tag & 7) == 4 || tag == 0) {
+            if ((tag & 7) === 4 || tag === 0) {
                 break;
             }
             reader.skipType(tag & 7);
         }
         return message;
-    },
-};
+    }
+    PBGltfContainerLoadingState.decode = decode;
+})(PBGltfContainerLoadingState || (PBGltfContainerLoadingState = {}));

package/dist/components/generated/pb/decentraland/sdk/components/material.gen.d.ts

@@ -1,3 +1,4 @@
+import _m0 from "protobufjs/minimal";
 import { Color3, Color4 } from "../../common/colors.gen";
 import { TextureUnion } from "../../common/texture.gen";
 /**
@@ -72,3 +73,24 @@ export interface PBMaterial_PbrMaterial {
     /** default = 1 */
     directIntensity?: number | undefined;
 }
+/**
+ * @public
+ */
+export declare namespace PBMaterial {
+    function encode(message: PBMaterial, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMaterial;
+}
+/**
+ * @public
+ */
+export declare namespace PBMaterial_UnlitMaterial {
+    function encode(message: PBMaterial_UnlitMaterial, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMaterial_UnlitMaterial;
+}
+/**
+ * @public
+ */
+export declare namespace PBMaterial_PbrMaterial {
+    function encode(message: PBMaterial_PbrMaterial, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMaterial_PbrMaterial;
+}

package/dist/components/generated/pb/decentraland/sdk/components/material.gen.js

@@ -20,11 +20,9 @@ function createBasePBMaterial() {
 /**
  * @public
  */
-/**
- * @internal
- */
-export const PBMaterial = {
-    encode(message, writer = _m0.Writer.create()) {
+export var PBMaterial;
+(function (PBMaterial) {
+    function encode(message, writer = _m0.Writer.create()) {
         switch (message.material?.$case) {
             case "unlit":
                 PBMaterial_UnlitMaterial.encode(message.material.unlit, writer.uint32(10).fork()).ldelim();
@@ -34,8 +32,9 @@ export const PBMaterial = {
                 break;
         }
         return writer;
-    },
-    decode(input, length) {
+    }
+    PBMaterial.encode = encode;
+    function decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBasePBMaterial();
@@ -43,37 +42,36 @@ export const PBMaterial = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    if (tag != 10) {
+                    if (tag !== 10) {
                         break;
                     }
                     message.material = { $case: "unlit", unlit: PBMaterial_UnlitMaterial.decode(reader, reader.uint32()) };
                     continue;
                 case 2:
-                    if (tag != 18) {
+                    if (tag !== 18) {
                         break;
                     }
                     message.material = { $case: "pbr", pbr: PBMaterial_PbrMaterial.decode(reader, reader.uint32()) };
                     continue;
             }
-            if ((tag & 7) == 4 || tag == 0) {
+            if ((tag & 7) === 4 || tag === 0) {
                 break;
             }
             reader.skipType(tag & 7);
         }
         return message;
-    },
-};
+    }
+    PBMaterial.decode = decode;
+})(PBMaterial || (PBMaterial = {}));
 function createBasePBMaterial_UnlitMaterial() {
     return { texture: undefined, alphaTest: undefined, castShadows: undefined, diffuseColor: undefined };
 }
 /**
  * @public
  */
-/**
- * @internal
- */
-export const PBMaterial_UnlitMaterial = {
-    encode(message, writer = _m0.Writer.create()) {
+export var PBMaterial_UnlitMaterial;
+(function (PBMaterial_UnlitMaterial) {
+    function encode(message, writer = _m0.Writer.create()) {
         if (message.texture !== undefined) {
             TextureUnion.encode(message.texture, writer.uint32(10).fork()).ldelim();
         }
@@ -87,8 +85,9 @@ export const PBMaterial_UnlitMaterial = {
             Color4.encode(message.diffuseColor, writer.uint32(34).fork()).ldelim();
         }
         return writer;
-    },
-    decode(input, length) {
+    }
+    PBMaterial_UnlitMaterial.encode = encode;
+    function decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBasePBMaterial_UnlitMaterial();
@@ -96,38 +95,39 @@ export const PBMaterial_UnlitMaterial = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    if (tag != 10) {
+                    if (tag !== 10) {
                         break;
                     }
                     message.texture = TextureUnion.decode(reader, reader.uint32());
                     continue;
                 case 2:
-                    if (tag != 21) {
+                    if (tag !== 21) {
                         break;
                     }
                     message.alphaTest = reader.float();
                     continue;
                 case 3:
-                    if (tag != 24) {
+                    if (tag !== 24) {
                         break;
                     }
                     message.castShadows = reader.bool();
                     continue;
                 case 4:
-                    if (tag != 34) {
+                    if (tag !== 34) {
                         break;
                     }
                     message.diffuseColor = Color4.decode(reader, reader.uint32());
                     continue;
             }
-            if ((tag & 7) == 4 || tag == 0) {
+            if ((tag & 7) === 4 || tag === 0) {
                 break;
             }
             reader.skipType(tag & 7);
         }
         return message;
-    },
-};
+    }
+    PBMaterial_UnlitMaterial.decode = decode;
+})(PBMaterial_UnlitMaterial || (PBMaterial_UnlitMaterial = {}));
 function createBasePBMaterial_PbrMaterial() {
     return {
         texture: undefined,
@@ -151,11 +151,9 @@ function createBasePBMaterial_PbrMaterial() {
 /**
  * @public
  */
-/**
- * @internal
- */
-export const PBMaterial_PbrMaterial = {
-    encode(message, writer = _m0.Writer.create()) {
+export var PBMaterial_PbrMaterial;
+(function (PBMaterial_PbrMaterial) {
+    function encode(message, writer = _m0.Writer.create()) {
         if (message.texture !== undefined) {
             TextureUnion.encode(message.texture, writer.uint32(10).fork()).ldelim();
         }
@@ -205,8 +203,9 @@ export const PBMaterial_PbrMaterial = {
             writer.uint32(133).float(message.directIntensity);
         }
         return writer;
-    },
-    decode(input, length) {
+    }
+    PBMaterial_PbrMaterial.encode = encode;
+    function decode(input, length) {
         const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBasePBMaterial_PbrMaterial();
@@ -214,107 +213,108 @@ export const PBMaterial_PbrMaterial = {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
-                    if (tag != 10) {
+                    if (tag !== 10) {
                         break;
                     }
                     message.texture = TextureUnion.decode(reader, reader.uint32());
                     continue;
                 case 2:
-                    if (tag != 21) {
+                    if (tag !== 21) {
                         break;
                     }
                     message.alphaTest = reader.float();
                     continue;
                 case 3:
-                    if (tag != 24) {
+                    if (tag !== 24) {
                         break;
                     }
                     message.castShadows = reader.bool();
                     continue;
                 case 4:
-                    if (tag != 34) {
+                    if (tag !== 34) {
                         break;
                     }
                     message.alphaTexture = TextureUnion.decode(reader, reader.uint32());
                     continue;
                 case 5:
-                    if (tag != 42) {
+                    if (tag !== 42) {
                         break;
                     }
                     message.emissiveTexture = TextureUnion.decode(reader, reader.uint32());
                     continue;
                 case 6:
-                    if (tag != 50) {
+                    if (tag !== 50) {
                         break;
                     }
                     message.bumpTexture = TextureUnion.decode(reader, reader.uint32());
                     continue;
                 case 7:
-                    if (tag != 58) {
+                    if (tag !== 58) {
                         break;
                     }
                     message.albedoColor = Color4.decode(reader, reader.uint32());
                     continue;
                 case 8:
-                    if (tag != 66) {
+                    if (tag !== 66) {
                         break;
                     }
                     message.emissiveColor = Color3.decode(reader, reader.uint32());
                     continue;
                 case 9:
-                    if (tag != 74) {
+                    if (tag !== 74) {
                         break;
                     }
                     message.reflectivityColor = Color3.decode(reader, reader.uint32());
                     continue;
                 case 10:
-                    if (tag != 80) {
+                    if (tag !== 80) {
                         break;
                     }
                     message.transparencyMode = reader.int32();
                     continue;
                 case 11:
-                    if (tag != 93) {
+                    if (tag !== 93) {
                         break;
                     }
                     message.metallic = reader.float();
                     continue;
                 case 12:
-                    if (tag != 101) {
+                    if (tag !== 101) {
                         break;
                     }
                     message.roughness = reader.float();
                     continue;
                 case 13:
-                    if (tag != 109) {
+                    if (tag !== 109) {
                         break;
                     }
                     message.glossiness = reader.float();
                     continue;
                 case 14:
-                    if (tag != 117) {
+                    if (tag !== 117) {
                         break;
                     }
                     message.specularIntensity = reader.float();
                     continue;
                 case 15:
-                    if (tag != 125) {
+                    if (tag !== 125) {
                         break;
                     }
                     message.emissiveIntensity = reader.float();
                     continue;
                 case 16:
-                    if (tag != 133) {
+                    if (tag !== 133) {
                         break;
                     }
                     message.directIntensity = reader.float();
                     continue;
             }
-            if ((tag & 7) == 4 || tag == 0) {
+            if ((tag & 7) === 4 || tag === 0) {
                 break;
             }
             reader.skipType(tag & 7);
         }
         return message;
-    },
-};
+    }
+    PBMaterial_PbrMaterial.decode = decode;
+})(PBMaterial_PbrMaterial || (PBMaterial_PbrMaterial = {}));

package/dist/components/generated/pb/decentraland/sdk/components/mesh_collider.gen.d.ts

@@ -1,3 +1,4 @@
+import _m0 from "protobufjs/minimal";
 /** ColliderLayer determines the kind of collision to detect, in OR-able bit flag form. */
 /**
  * @public
@@ -82,3 +83,38 @@ export interface PBMeshCollider_PlaneMesh {
  */
 export interface PBMeshCollider_SphereMesh {
 }
+/**
+ * @public
+ */
+export declare namespace PBMeshCollider {
+    function encode(message: PBMeshCollider, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider;
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshCollider_BoxMesh {
+    function encode(_: PBMeshCollider_BoxMesh, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider_BoxMesh;
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshCollider_CylinderMesh {
+    function encode(message: PBMeshCollider_CylinderMesh, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider_CylinderMesh;
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshCollider_PlaneMesh {
+    function encode(_: PBMeshCollider_PlaneMesh, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider_PlaneMesh;
+}
+/**
+ * @public
+ */
+export declare namespace PBMeshCollider_SphereMesh {
+    function encode(_: PBMeshCollider_SphereMesh, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider_SphereMesh;
+}