@dcl/playground-assets 7.1.4-4491693391.commit-569ecab → 7.1.4-4495128859.commit-9f954df

package/dist/index.js

@@ -7748,6 +7748,7 @@
     };
 
     /* eslint-disable */
+    /** AvatarAnchorPointType determines the part of the avatar's body that anchors the Entity. */
     /**
      * @public
      */
@@ -7873,12 +7874,15 @@
     };
 
     /* eslint-disable */
+    /** AvatarModifierType is an effect that should be applied to avatars inside the region. */
     /**
      * @public
      */
     exports.AvatarModifierType = void 0;
     (function (AvatarModifierType) {
+        /** AMT_HIDE_AVATARS - avatars are invisible */
         AvatarModifierType[AvatarModifierType["AMT_HIDE_AVATARS"] = 0] = "AMT_HIDE_AVATARS";
+        /** AMT_DISABLE_PASSPORTS - selecting (e.g. clicking) an avatar will not bring up their profile. */
         AvatarModifierType[AvatarModifierType["AMT_DISABLE_PASSPORTS"] = 1] = "AMT_DISABLE_PASSPORTS";
     })(exports.AvatarModifierType || (exports.AvatarModifierType = {}));
     function createBasePBAvatarModifierArea() {
@@ -9486,7 +9490,7 @@
                         message.expressionTriggerId = reader.string();
                         break;
                     case 8:
-                        message.expressionTriggerTimestamp = longToNumber$1(reader.int64());
+                        message.expressionTriggerTimestamp = longToNumber(reader.int64());
                         break;
                     case 9:
                         message.talking = reader.bool();
@@ -9505,7 +9509,7 @@
             return message;
         },
     };
-    var tsProtoGlobalThis$3 = (() => {
+    var tsProtoGlobalThis$2 = (() => {
         if (typeof globalThis !== "undefined") {
             return globalThis;
         }
@@ -9520,9 +9524,9 @@
         }
         throw "Unable to locate global object";
     })();
-    function longToNumber$1(long) {
+    function longToNumber(long) {
         if (long.gt(Number.MAX_SAFE_INTEGER)) {
-            throw new tsProtoGlobalThis$3.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+            throw new tsProtoGlobalThis$2.Error("Value is larger than Number.MAX_SAFE_INTEGER");
         }
         return long.toNumber();
     }
@@ -9557,6 +9561,7 @@
     };
 
     /* eslint-disable */
+    /** BillboardMode indicates one or more axis for automatic rotation, in OR-able bit flag form. */
     /**
      * @public
      */
@@ -9566,6 +9571,7 @@
         BillboardMode[BillboardMode["BM_X"] = 1] = "BM_X";
         BillboardMode[BillboardMode["BM_Y"] = 2] = "BM_Y";
         BillboardMode[BillboardMode["BM_Z"] = 4] = "BM_Z";
+        /** BM_ALL - bitwise combination BM_X | BM_Y | BM_Z */
         BillboardMode[BillboardMode["BM_ALL"] = 7] = "BM_ALL";
     })(exports.BillboardMode || (exports.BillboardMode = {}));
     function createBasePBBillboard() {
@@ -10294,14 +10300,33 @@
     };
 
     /* eslint-disable */
+    /** ColliderLayer determines the kind of collision to detect, in OR-able bit flag form. */
     /**
      * @public
      */
     exports.ColliderLayer = void 0;
     (function (ColliderLayer) {
+        /** CL_NONE - no collisions */
         ColliderLayer[ColliderLayer["CL_NONE"] = 0] = "CL_NONE";
+        /** CL_POINTER - collisions with the player's pointer ray (e.g. mouse cursor hovering) */
         ColliderLayer[ColliderLayer["CL_POINTER"] = 1] = "CL_POINTER";
+        /** CL_PHYSICS - collision affecting your player's physics i.e. walls, floor, moving platfroms */
         ColliderLayer[ColliderLayer["CL_PHYSICS"] = 2] = "CL_PHYSICS";
+        /** CL_VISIBLE_MESHES - all visible meshes, use with extreme care since the performance penalty is high */
+        ColliderLayer[ColliderLayer["CL_VISIBLE_MESHES"] = 4] = "CL_VISIBLE_MESHES";
+        ColliderLayer[ColliderLayer["CL_RESERVED2"] = 8] = "CL_RESERVED2";
+        ColliderLayer[ColliderLayer["CL_RESERVED3"] = 16] = "CL_RESERVED3";
+        ColliderLayer[ColliderLayer["CL_RESERVED4"] = 32] = "CL_RESERVED4";
+        ColliderLayer[ColliderLayer["CL_RESERVED5"] = 64] = "CL_RESERVED5";
+        ColliderLayer[ColliderLayer["CL_RESERVED6"] = 128] = "CL_RESERVED6";
+        ColliderLayer[ColliderLayer["CL_CUSTOM1"] = 256] = "CL_CUSTOM1";
+        ColliderLayer[ColliderLayer["CL_CUSTOM2"] = 512] = "CL_CUSTOM2";
+        ColliderLayer[ColliderLayer["CL_CUSTOM3"] = 1024] = "CL_CUSTOM3";
+        ColliderLayer[ColliderLayer["CL_CUSTOM4"] = 2048] = "CL_CUSTOM4";
+        ColliderLayer[ColliderLayer["CL_CUSTOM5"] = 4096] = "CL_CUSTOM5";
+        ColliderLayer[ColliderLayer["CL_CUSTOM6"] = 8192] = "CL_CUSTOM6";
+        ColliderLayer[ColliderLayer["CL_CUSTOM7"] = 16384] = "CL_CUSTOM7";
+        ColliderLayer[ColliderLayer["CL_CUSTOM8"] = 32768] = "CL_CUSTOM8";
     })(exports.ColliderLayer || (exports.ColliderLayer = {}));
     function createBasePBMeshCollider() {
         return { collisionMask: undefined, mesh: undefined };
@@ -10747,6 +10772,7 @@
     };
 
     /* eslint-disable */
+    /** NftFrameType is a predefined framing style for the image. */
     /**
      * @public
      */
@@ -10849,16 +10875,6 @@
     };
 
     /* eslint-disable */
-    /**
-     * @public
-     */
-    exports.PointerEventType = void 0;
-    (function (PointerEventType) {
-        PointerEventType[PointerEventType["PET_UP"] = 0] = "PET_UP";
-        PointerEventType[PointerEventType["PET_DOWN"] = 1] = "PET_DOWN";
-        PointerEventType[PointerEventType["PET_HOVER_ENTER"] = 2] = "PET_HOVER_ENTER";
-        PointerEventType[PointerEventType["PET_HOVER_LEAVE"] = 3] = "PET_HOVER_LEAVE";
-    })(exports.PointerEventType || (exports.PointerEventType = {}));
     function createBasePBPointerEvents() {
         return { pointerEvents: [] };
     }
@@ -11012,62 +11028,10 @@
     };
 
     /* eslint-disable */
-    function createBasePBRaycastResult() {
-        return { timestamp: 0, origin: undefined, direction: undefined, hits: [] };
-    }
-    /**
-     * @public
-     */
-    /**
-     * @internal
-     */
-    const PBRaycastResult = {
-        encode(message, writer = _m0.Writer.create()) {
-            if (message.timestamp !== 0) {
-                writer.uint32(8).int32(message.timestamp);
-            }
-            if (message.origin !== undefined) {
-                Vector3.encode(message.origin, writer.uint32(18).fork()).ldelim();
-            }
-            if (message.direction !== undefined) {
-                Vector3.encode(message.direction, writer.uint32(26).fork()).ldelim();
-            }
-            for (const v of message.hits) {
-                RaycastHit.encode(v, writer.uint32(34).fork()).ldelim();
-            }
-            return writer;
-        },
-        decode(input, length) {
-            const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-            let end = length === undefined ? reader.len : reader.pos + length;
-            const message = createBasePBRaycastResult();
-            while (reader.pos < end) {
-                const tag = reader.uint32();
-                switch (tag >>> 3) {
-                    case 1:
-                        message.timestamp = reader.int32();
-                        break;
-                    case 2:
-                        message.origin = Vector3.decode(reader, reader.uint32());
-                        break;
-                    case 3:
-                        message.direction = Vector3.decode(reader, reader.uint32());
-                        break;
-                    case 4:
-                        message.hits.push(RaycastHit.decode(reader, reader.uint32()));
-                        break;
-                    default:
-                        reader.skipType(tag & 7);
-                        break;
-                }
-            }
-            return message;
-        },
-    };
     function createBaseRaycastHit() {
         return {
             position: undefined,
-            origin: undefined,
+            globalOrigin: undefined,
             direction: undefined,
             normalHit: undefined,
             length: 0,
@@ -11086,8 +11050,8 @@
             if (message.position !== undefined) {
                 Vector3.encode(message.position, writer.uint32(10).fork()).ldelim();
             }
-            if (message.origin !== undefined) {
-                Vector3.encode(message.origin, writer.uint32(18).fork()).ldelim();
+            if (message.globalOrigin !== undefined) {
+                Vector3.encode(message.globalOrigin, writer.uint32(18).fork()).ldelim();
             }
             if (message.direction !== undefined) {
                 Vector3.encode(message.direction, writer.uint32(26).fork()).ldelim();
@@ -11102,7 +11066,7 @@
                 writer.uint32(50).string(message.meshName);
             }
             if (message.entityId !== undefined) {
-                writer.uint32(56).int64(message.entityId);
+                writer.uint32(56).uint32(message.entityId);
             }
             return writer;
         },
@@ -11117,7 +11081,7 @@
                         message.position = Vector3.decode(reader, reader.uint32());
                         break;
                     case 2:
-                        message.origin = Vector3.decode(reader, reader.uint32());
+                        message.globalOrigin = Vector3.decode(reader, reader.uint32());
                         break;
                     case 3:
                         message.direction = Vector3.decode(reader, reader.uint32());
@@ -11132,7 +11096,7 @@
                         message.meshName = reader.string();
                         break;
                     case 7:
-                        message.entityId = longToNumber(reader.int64());
+                        message.entityId = reader.uint32();
                         break;
                     default:
                         reader.skipType(tag & 7);
@@ -11142,31 +11106,6 @@
             return message;
         },
     };
-    var tsProtoGlobalThis$2 = (() => {
-        if (typeof globalThis !== "undefined") {
-            return globalThis;
-        }
-        if (typeof self !== "undefined") {
-            return self;
-        }
-        if (typeof window !== "undefined") {
-            return window;
-        }
-        if (typeof global !== "undefined") {
-            return global;
-        }
-        throw "Unable to locate global object";
-    })();
-    function longToNumber(long) {
-        if (long.gt(Number.MAX_SAFE_INTEGER)) {
-            throw new tsProtoGlobalThis$2.Error("Value is larger than Number.MAX_SAFE_INTEGER");
-        }
-        return long.toNumber();
-    }
-    if (_m0.util.Long !== Long) {
-        _m0.util.Long = Long;
-        _m0.configure();
-    }
 
     /* eslint-disable */
     function createBasePBPointerEventsResult() {
@@ -11190,7 +11129,7 @@
                 writer.uint32(32).int32(message.state);
             }
             if (message.timestamp !== 0) {
-                writer.uint32(40).int32(message.timestamp);
+                writer.uint32(40).uint32(message.timestamp);
             }
             if (message.analog !== undefined) {
                 writer.uint32(53).float(message.analog);
@@ -11214,7 +11153,7 @@
                         message.state = reader.int32();
                         break;
                     case 5:
-                        message.timestamp = reader.int32();
+                        message.timestamp = reader.uint32();
                         break;
                     case 6:
                         message.analog = reader.float();
@@ -11315,16 +11254,29 @@
     };
 
     /* eslint-disable */
+    /** RaycastQueryType indicates whether the ray should stop on the first collition, or continue. */
     /**
      * @public
      */
     exports.RaycastQueryType = void 0;
     (function (RaycastQueryType) {
+        /** RQT_HIT_FIRST - Pick the first (not necessarily the closest) hit within the range */
         RaycastQueryType[RaycastQueryType["RQT_HIT_FIRST"] = 0] = "RQT_HIT_FIRST";
+        /** RQT_QUERY_ALL - Pick all hits within the range */
         RaycastQueryType[RaycastQueryType["RQT_QUERY_ALL"] = 1] = "RQT_QUERY_ALL";
+        /** RQT_NONE - Do not perform the raycast, only set the raycast result with empty hits */
+        RaycastQueryType[RaycastQueryType["RQT_NONE"] = 2] = "RQT_NONE";
     })(exports.RaycastQueryType || (exports.RaycastQueryType = {}));
     function createBasePBRaycast() {
-        return { origin: undefined, direction: undefined, maxDistance: 0, queryType: 0 };
+        return {
+            timestamp: undefined,
+            originOffset: undefined,
+            direction: undefined,
+            maxDistance: 0,
+            queryType: 0,
+            continuous: undefined,
+            collisionMask: undefined,
+        };
     }
     /**
      * @public
@@ -11334,11 +11286,23 @@
      */
     const PBRaycast = {
         encode(message, writer = _m0.Writer.create()) {
-            if (message.origin !== undefined) {
-                Vector3.encode(message.origin, writer.uint32(18).fork()).ldelim();
+            if (message.timestamp !== undefined) {
+                writer.uint32(8).uint32(message.timestamp);
             }
-            if (message.direction !== undefined) {
-                Vector3.encode(message.direction, writer.uint32(26).fork()).ldelim();
+            if (message.originOffset !== undefined) {
+                Vector3.encode(message.originOffset, writer.uint32(18).fork()).ldelim();
+            }
+            if (message.direction?.$case === "localDirection") {
+                Vector3.encode(message.direction.localDirection, writer.uint32(50).fork()).ldelim();
+            }
+            if (message.direction?.$case === "globalDirection") {
+                Vector3.encode(message.direction.globalDirection, writer.uint32(26).fork()).ldelim();
+            }
+            if (message.direction?.$case === "globalTarget") {
+                Vector3.encode(message.direction.globalTarget, writer.uint32(58).fork()).ldelim();
+            }
+            if (message.direction?.$case === "targetEntity") {
+                writer.uint32(80).uint32(message.direction.targetEntity);
             }
             if (message.maxDistance !== 0) {
                 writer.uint32(37).float(message.maxDistance);
@@ -11346,6 +11310,12 @@
             if (message.queryType !== 0) {
                 writer.uint32(40).int32(message.queryType);
             }
+            if (message.continuous !== undefined) {
+                writer.uint32(64).bool(message.continuous);
+            }
+            if (message.collisionMask !== undefined) {
+                writer.uint32(72).uint32(message.collisionMask);
+            }
             return writer;
         },
         decode(input, length) {
@@ -11355,11 +11325,23 @@
             while (reader.pos < end) {
                 const tag = reader.uint32();
                 switch (tag >>> 3) {
+                    case 1:
+                        message.timestamp = reader.uint32();
+                        break;
                     case 2:
-                        message.origin = Vector3.decode(reader, reader.uint32());
+                        message.originOffset = Vector3.decode(reader, reader.uint32());
+                        break;
+                    case 6:
+                        message.direction = { $case: "localDirection", localDirection: Vector3.decode(reader, reader.uint32()) };
                         break;
                     case 3:
-                        message.direction = Vector3.decode(reader, reader.uint32());
+                        message.direction = { $case: "globalDirection", globalDirection: Vector3.decode(reader, reader.uint32()) };
+                        break;
+                    case 7:
+                        message.direction = { $case: "globalTarget", globalTarget: Vector3.decode(reader, reader.uint32()) };
+                        break;
+                    case 10:
+                        message.direction = { $case: "targetEntity", targetEntity: reader.uint32() };
                         break;
                     case 4:
                         message.maxDistance = reader.float();
@@ -11367,6 +11349,12 @@
                     case 5:
                         message.queryType = reader.int32();
                         break;
+                    case 8:
+                        message.continuous = reader.bool();
+                        break;
+                    case 9:
+                        message.collisionMask = reader.uint32();
+                        break;
                     default:
                         reader.skipType(tag & 7);
                         break;
@@ -11401,6 +11389,60 @@
         }
     };
 
+    /* eslint-disable */
+    function createBasePBRaycastResult() {
+        return { timestamp: undefined, globalOrigin: undefined, direction: undefined, hits: [] };
+    }
+    /**
+     * @public
+     */
+    /**
+     * @internal
+     */
+    const PBRaycastResult = {
+        encode(message, writer = _m0.Writer.create()) {
+            if (message.timestamp !== undefined) {
+                writer.uint32(8).uint32(message.timestamp);
+            }
+            if (message.globalOrigin !== undefined) {
+                Vector3.encode(message.globalOrigin, writer.uint32(18).fork()).ldelim();
+            }
+            if (message.direction !== undefined) {
+                Vector3.encode(message.direction, writer.uint32(26).fork()).ldelim();
+            }
+            for (const v of message.hits) {
+                RaycastHit.encode(v, writer.uint32(34).fork()).ldelim();
+            }
+            return writer;
+        },
+        decode(input, length) {
+            const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+            let end = length === undefined ? reader.len : reader.pos + length;
+            const message = createBasePBRaycastResult();
+            while (reader.pos < end) {
+                const tag = reader.uint32();
+                switch (tag >>> 3) {
+                    case 1:
+                        message.timestamp = reader.uint32();
+                        break;
+                    case 2:
+                        message.globalOrigin = Vector3.decode(reader, reader.uint32());
+                        break;
+                    case 3:
+                        message.direction = Vector3.decode(reader, reader.uint32());
+                        break;
+                    case 4:
+                        message.hits.push(RaycastHit.decode(reader, reader.uint32()));
+                        break;
+                    default:
+                        reader.skipType(tag & 7);
+                        break;
+                }
+            }
+            return message;
+        },
+    };
+
     /**
      * @internal
      */
@@ -13327,12 +13369,10 @@
         PBUiTransform: PBUiTransform,
         PBVideoPlayer: PBVideoPlayer,
         PBVisibilityComponent: PBVisibilityComponent,
-        get PointerEventType () { return exports.PointerEventType; },
         PointerEvents: PointerEvents$1,
         PointerEventsResult: PointerEventsResult$1,
         PointerLock: PointerLock$1,
         Raycast: Raycast$1,
-        RaycastHit: RaycastHit,
         get RaycastQueryType () { return exports.RaycastQueryType; },
         RaycastResult: RaycastResult$1,
         TextShape: TextShape$1,
@@ -16227,6 +16267,8 @@
     (function (CameraType) {
         CameraType[CameraType["CT_FIRST_PERSON"] = 0] = "CT_FIRST_PERSON";
         CameraType[CameraType["CT_THIRD_PERSON"] = 1] = "CT_THIRD_PERSON";
+        /** CT_CINEMATIC - controlled by the scene */
+        CameraType[CameraType["CT_CINEMATIC"] = 2] = "CT_CINEMATIC";
     })(exports.CameraType || (exports.CameraType = {}));
 
     /* eslint-disable */
@@ -16250,6 +16292,17 @@
         InputAction[InputAction["IA_ACTION_5"] = 12] = "IA_ACTION_5";
         InputAction[InputAction["IA_ACTION_6"] = 13] = "IA_ACTION_6";
     })(exports.InputAction || (exports.InputAction = {}));
+    /** PointerEventType is a kind of interaction that can be detected. */
+    /**
+     * @public
+     */
+    exports.PointerEventType = void 0;
+    (function (PointerEventType) {
+        PointerEventType[PointerEventType["PET_UP"] = 0] = "PET_UP";
+        PointerEventType[PointerEventType["PET_DOWN"] = 1] = "PET_DOWN";
+        PointerEventType[PointerEventType["PET_HOVER_ENTER"] = 2] = "PET_HOVER_ENTER";
+        PointerEventType[PointerEventType["PET_HOVER_LEAVE"] = 3] = "PET_HOVER_LEAVE";
+    })(exports.PointerEventType || (exports.PointerEventType = {}));
 
     /* eslint-disable */
     /**