@dcl/ecs 7.9.5 → 7.9.6-16908909596.commit-3302d67

package/dist-cjs/systems/events.d.ts

@@ -17,6 +17,12 @@ export type EventSystemOptions = {
     showFeedback?: boolean;
     showHighlight?: boolean;
 };
+/**
+ * @public
+ */
+export type EventSystemOptionsCallback = EventSystemOptions & {
+    cb: EventSystemCallback;
+};
 export declare const getDefaultOpts: (opts?: Partial<EventSystemOptions>) => EventSystemOptions;
 /**
  * @public
@@ -46,11 +52,37 @@ export interface PointerEventsSystem {
      * @param entity - Entity where the callback was attached
      */
     removeOnPointerHoverLeave(entity: Entity): void;
+    /**
+     * @public
+     * Remove the callback for onPointerDrag event
+     * @param entity - Entity where the callback was attached
+     */
+    removeOnPointerDrag(entity: Entity): void;
+    /**
+     * @public
+     * Remove the callback for onPointerDragLocked event
+     * @param entity - Entity where the callback was attached
+     */
+    removeOnPointerDragLocked(entity: Entity): void;
+    /**
+     * @public
+     * Remove the callback for onPointerDragEnd event
+     * @param entity - Entity where the callback was attached
+     */
+    removeOnPointerDragEnd(entity: Entity): void;
+    /**
+     * @public
+     * Execute callbacks when the user presses one of the InputButtons pointing at the entity
+     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
+     */
+    onPointerDown(pointerData: {
+        entity: Entity;
+        optsList: EventSystemOptionsCallback[];
+    }): void;
     /**
      * @public
      * Execute callback when the user press the InputButton pointing at the entity
      * @param pointerData - Entity to attach the callback, Opts to trigger Feedback and Button
-     * @param cb - Function to execute when click fires
      */
     onPointerDown(pointerData: {
         entity: Entity;
@@ -63,6 +95,15 @@ export interface PointerEventsSystem {
      * @param opts - Opts to trigger Feedback and Button
      */
     onPointerDown(entity: Entity, cb: EventSystemCallback, opts?: Partial<EventSystemOptions>): void;
+    /**
+     * @public
+     * Execute callbacks when the user releases one of the InputButtons pointing at the entity
+     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
+     */
+    onPointerUp(pointerData: {
+        entity: Entity;
+        optsList: EventSystemOptionsCallback[];
+    }): void;
     /**
      * @public
      * Execute callback when the user releases the InputButton pointing at the entity
@@ -100,6 +141,64 @@ export interface PointerEventsSystem {
         entity: Entity;
         opts?: Partial<EventSystemOptions>;
     }, cb: EventSystemCallback): void;
+    /**
+     * @public
+     * Execute callbacks when the user drags the pointer from inside the entity
+     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
+     */
+    onPointerDrag(pointerData: {
+        entity: Entity;
+        optsList: EventSystemOptionsCallback[];
+    }): void;
+    /**
+     * @public
+     * Execute callback when the user clicks and drags the pointer from inside the entity
+     * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
+     * @param cb - Function to execute when click fires
+     */
+    onPointerDrag(pointerData: {
+        entity: Entity;
+        opts?: Partial<EventSystemOptions>;
+    }, cb: EventSystemCallback): void;
+    /**
+     * @public
+     * Execute callbacks when the user drags the pointer from inside the entity, locking the cursor in place.
+     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
+     */
+    onPointerDragLocked(pointerData: {
+        entity: Entity;
+        optsList: EventSystemOptionsCallback[];
+    }): void;
+    /**
+     * @public
+     * Execute callback when the user clicks and drags the pointer from inside the entity,
+     * locking the cursor in place
+     * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
+     * @param cb - Function to execute when click fires
+     */
+    onPointerDragLocked(pointerData: {
+        entity: Entity;
+        opts?: Partial<EventSystemOptions>;
+    }, cb: EventSystemCallback): void;
+    /**
+     * @public
+     * Execute callbacks when the user releases a button after a drag
+     * @param pointerData - Entity to attach the callbacks, list of options to trigger Feedback, Button, and Callback
+     */
+    onPointerDragEnd(pointerData: {
+        entity: Entity;
+        optsList: EventSystemOptionsCallback[];
+    }): void;
+    /**
+     * @public
+     * Execute callback when the user releases the button after a drag
+     * @param pointerData - Entity to attach the callback - Opts to trigger Feedback and Button
+     * @param cb - Function to execute when click fires
+     */
+    onPointerDragEnd(pointerData: {
+        entity: Entity;
+        opts?: Partial<EventSystemOptions>;
+    }, cb: EventSystemCallback): void;
 }
 /**
  * @public

package/dist-cjs/systems/events.js

@@ -45,6 +45,9 @@ function createPointerEventsSystem(engine, inputSystem) {
         EventType[EventType["Up"] = 2] = "Up";
         EventType[EventType["HoverEnter"] = 3] = "HoverEnter";
         EventType[EventType["HoverLeave"] = 4] = "HoverLeave";
+        EventType[EventType["Drag"] = 5] = "Drag";
+        EventType[EventType["DragLocked"] = 6] = "DragLocked";
+        EventType[EventType["DragEnd"] = 7] = "DragEnd";
     })(EventType || (EventType = {}));
     const eventsMap = new Map();
     function getEvent(entity) {
@@ -79,77 +82,148 @@ function createPointerEventsSystem(engine, inputSystem) {
         else if (eventType === EventType.HoverEnter) {
             return 2 /* PointerEventType.PET_HOVER_ENTER */;
         }
+        else if (eventType === EventType.Drag) {
+            return 5 /* PointerEventType.PET_DRAG */;
+        }
+        else if (eventType === EventType.DragLocked) {
+            return 4 /* PointerEventType.PET_DRAG_LOCKED */;
+        }
+        else if (eventType === EventType.DragEnd) {
+            return 6 /* PointerEventType.PET_DRAG_END */;
+        }
         return 1 /* PointerEventType.PET_DOWN */;
     }
+    function getEventType(pet) {
+        if (pet === 0 /* PointerEventType.PET_UP */) {
+            return EventType.Up;
+        }
+        else if (pet === 2 /* PointerEventType.PET_HOVER_ENTER */) {
+            return EventType.HoverEnter;
+        }
+        else if (pet === 3 /* PointerEventType.PET_HOVER_LEAVE */) {
+            return EventType.HoverLeave;
+        }
+        else if (pet === 5 /* PointerEventType.PET_DRAG */) {
+            return EventType.Drag;
+        }
+        else if (pet === 4 /* PointerEventType.PET_DRAG_LOCKED */) {
+            return EventType.DragLocked;
+        }
+        else if (pet === 6 /* PointerEventType.PET_DRAG_END */) {
+            return EventType.DragEnd;
+        }
+        else {
+            return EventType.Down;
+        }
+    }
     function removeEvent(entity, type) {
         const event = getEvent(entity);
-        const pointerEvent = event.get(type);
-        if (pointerEvent?.opts.hoverText) {
-            removePointerEvent(entity, getPointerEvent(type), pointerEvent.opts.button);
+        const pointerEventList = event.get(type);
+        if (pointerEventList === undefined) {
+            return;
+        }
+        for (const button of pointerEventList.keys()) {
+            removePointerEvent(entity, getPointerEvent(type), button);
         }
         event.delete(type);
     }
     engine.addSystem(function EventSystem() {
-        for (const [entity, event] of eventsMap) {
+        if (eventsMap.size === 0) {
+            return;
+        }
+        for (const entity of eventsMap.keys()) {
             if (engine.getEntityState(entity) === entity_1.EntityState.Removed) {
                 eventsMap.delete(entity);
+            }
+        }
+        for (const command of inputSystem.getInputCommands()) {
+            const entity = command.hit?.entityId;
+            if (entity === undefined) {
+                continue;
+            }
+            const entityMap = eventsMap.get(entity);
+            if (entityMap === undefined) {
                 continue;
             }
-            for (const [eventType, { cb, opts }] of event) {
-                if (eventType === EventType.Click) {
-                    const command = inputSystem.getClick(opts.button, entity);
-                    if (command)
-                        (0, invariant_1.checkNotThenable)(cb(command.up), 'Click event returned a thenable. Only synchronous functions are allowed');
+            const typeMap = entityMap.get(getEventType(command.state));
+            if (typeMap) {
+                const data = typeMap.get(command.button);
+                if (data) {
+                    (0, invariant_1.checkNotThenable)(data.cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
                 }
-                if (eventType === EventType.Down ||
-                    eventType === EventType.Up ||
-                    eventType === EventType.HoverEnter ||
-                    eventType === EventType.HoverLeave) {
-                    const command = inputSystem.getInputCommand(opts.button, getPointerEvent(eventType), entity);
-                    if (command) {
-                        (0, invariant_1.checkNotThenable)(cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
+                const anyData = typeMap.get(3 /* InputAction.IA_ANY */);
+                if (anyData) {
+                    (0, invariant_1.checkNotThenable)(anyData.cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
+                }
+            }
+            // check clicks separately
+            if (command.state === 0 /* PointerEventType.PET_UP */) {
+                const clickMap = entityMap.get(EventType.Click);
+                if (clickMap) {
+                    const data = clickMap.get(command.button);
+                    if (data && inputSystem.getClick(command.button, entity)) {
+                        (0, invariant_1.checkNotThenable)(data.cb(command), 'Click event returned a thenable. Only synchronous functions are allowed');
+                    }
+                    const anyData = clickMap.get(3 /* InputAction.IA_ANY */);
+                    if (anyData && inputSystem.getClick(command.button, entity)) {
+                        (0, invariant_1.checkNotThenable)(anyData.cb(command), 'Event handler returned a thenable. Only synchronous functions are allowed');
                     }
                 }
             }
         }
     });
-    const onPointerDown = (...args) => {
-        const [data, cb, maybeOpts] = args;
-        if (typeof data === 'number') {
-            return onPointerDown({ entity: data, opts: maybeOpts ?? {} }, cb);
-        }
-        const { entity, opts } = data;
-        const options = (0, exports.getDefaultOpts)(opts);
-        removeEvent(entity, EventType.Down);
-        getEvent(entity).set(EventType.Down, { cb, opts: options });
-        setPointerEvent(entity, 1 /* PointerEventType.PET_DOWN */, options);
-    };
-    const onPointerUp = (...args) => {
-        const [data, cb, maybeOpts] = args;
-        if (typeof data === 'number') {
-            return onPointerUp({ entity: data, opts: maybeOpts ?? {} }, cb);
-        }
-        const { entity, opts } = data;
-        const options = (0, exports.getDefaultOpts)(opts);
-        removeEvent(entity, EventType.Up);
-        getEvent(entity).set(EventType.Up, { cb, opts: options });
-        setPointerEvent(entity, 0 /* PointerEventType.PET_UP */, options);
-    };
-    const onPointerHoverEnter = (...args) => {
-        const [data, cb] = args;
-        const { entity, opts } = data;
-        const options = (0, exports.getDefaultOpts)(opts);
-        removeEvent(entity, EventType.HoverEnter);
-        getEvent(entity).set(EventType.HoverEnter, { cb, opts: options });
-        setPointerEvent(entity, 2 /* PointerEventType.PET_HOVER_ENTER */, options);
-    };
-    const onPointerHoverLeave = (...args) => {
-        const [data, cb] = args;
-        const { entity, opts } = data;
-        const options = (0, exports.getDefaultOpts)(opts);
-        removeEvent(entity, EventType.HoverLeave);
-        getEvent(entity).set(EventType.HoverLeave, { cb, opts: options });
-        setPointerEvent(entity, 3 /* PointerEventType.PET_HOVER_LEAVE */, options);
+    // return a function with the correct event type.
+    // we use onPointerDown as the "archetype" for the returned function, but it fits with
+    // all the onPointer* declarations
+    const onPointerFunction = (ty) => {
+        return (arg0, arg1, arg2) => {
+            let entity;
+            let optsList;
+            if (typeof arg0 === 'number') {
+                // called as onPointerDown(entity: Entity, cb: EventSystemCallback, opts?: Partial<EventSystemOptions>): void
+                entity = arg0;
+                const cb = arg1;
+                const opts = arg2;
+                optsList = [{ cb, ...(0, exports.getDefaultOpts)(opts) }];
+            }
+            else if (typeof arg1 === 'function') {
+                // called as onPointerDown(pointerData: { entity: Entity; opts?: Partial<EventSystemOptions> }, cb: EventSystemCallback): void
+                const { entity: e, opts } = arg0;
+                const cb = arg1;
+                entity = e;
+                optsList = [{ cb, ...(0, exports.getDefaultOpts)(opts) }];
+            }
+            else {
+                // called as onPointerDown(pointerData: { entity: Entity; optsList: EventSystemOptionsCallback[] }): void
+                const { entity: e, optsList: o } = arg0;
+                entity = e;
+                optsList = o;
+            }
+            const previous = getEvent(entity).get(ty) ?? new Map();
+            const callbacks = new Map();
+            for (const opts of optsList) {
+                const prevOpts = previous.get(opts.button);
+                if (prevOpts !== undefined) {
+                    if (prevOpts.hoverText !== opts.hoverText ||
+                        prevOpts.maxDistance !== opts.maxDistance ||
+                        prevOpts.showFeedback !== opts.showFeedback ||
+                        prevOpts.showHighlight !== opts.showHighlight) {
+                        removePointerEvent(entity, getPointerEvent(ty), opts.button);
+                        setPointerEvent(entity, getPointerEvent(ty), opts);
+                    }
+                }
+                else {
+                    setPointerEvent(entity, getPointerEvent(ty), opts);
+                }
+                callbacks.set(opts.button, opts);
+            }
+            for (const button of previous.keys()) {
+                if (!callbacks.has(button)) {
+                    removePointerEvent(entity, getPointerEvent(ty), button);
+                }
+            }
+            getEvent(entity).set(ty, callbacks);
+        };
     };
     return {
         removeOnClick(entity) {
@@ -167,19 +241,23 @@ function createPointerEventsSystem(engine, inputSystem) {
         removeOnPointerHoverLeave(entity) {
             removeEvent(entity, EventType.HoverLeave);
         },
-        onClick(value, cb) {
-            const { entity } = value;
-            const options = (0, exports.getDefaultOpts)(value.opts);
-            // Clear previous event with over feedback included
-            removeEvent(entity, EventType.Click);
-            // Set new event
-            getEvent(entity).set(EventType.Click, { cb, opts: options });
-            setPointerEvent(entity, 1 /* PointerEventType.PET_DOWN */, options);
+        removeOnPointerDrag(entity) {
+            removeEvent(entity, EventType.Drag);
+        },
+        removeOnPointerDragLocked(entity) {
+            removeEvent(entity, EventType.DragLocked);
+        },
+        removeOnPointerDragEnd(entity) {
+            removeEvent(entity, EventType.DragEnd);
         },
-        onPointerDown,
-        onPointerUp,
-        onPointerHoverEnter,
-        onPointerHoverLeave
+        onClick: onPointerFunction(EventType.Click),
+        onPointerDown: onPointerFunction(EventType.Down),
+        onPointerUp: onPointerFunction(EventType.Up),
+        onPointerHoverEnter: onPointerFunction(EventType.HoverEnter),
+        onPointerHoverLeave: onPointerFunction(EventType.HoverLeave),
+        onPointerDrag: onPointerFunction(EventType.Drag),
+        onPointerDragLocked: onPointerFunction(EventType.DragLocked),
+        onPointerDragEnd: onPointerFunction(EventType.DragEnd)
     };
 }
 exports.createPointerEventsSystem = createPointerEventsSystem;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dcl/ecs",
   "description": "Decentraland ECS",
-  "version": "7.9.5",
+  "version": "7.9.6-16908909596.commit-3302d67",
   "author": "DCL",
   "bugs": "https://github.com/decentraland/ecs/issues",
   "files": [
@@ -33,5 +33,5 @@
   },
   "types": "./dist/index.d.ts",
   "typings": "./dist/index.d.ts",
-  "commit": "c2e52dbdacd56024b807a1819d4e5a9a2674ab3a"
+  "commit": "3302d67d9b8fa94b40f98fb1d9402a6355df1ec6"
 }

package/dist/components/generated/GltfNodeModifiers.gen.js

@@ -1,25 +0,0 @@
-import { PBGltfNodeModifiers } from './pb/decentraland/sdk/components/gltf_node_modifiers.gen';
-/**
- * @internal
- */
-export const GltfNodeModifiersSchema = {
-    COMPONENT_ID: 1099,
-    serialize(value, builder) {
-        const writer = PBGltfNodeModifiers.encode(value);
-        const buffer = new Uint8Array(writer.finish(), 0, writer.len);
-        builder.writeBuffer(buffer, false);
-    },
-    deserialize(reader) {
-        return PBGltfNodeModifiers.decode(reader.buffer(), reader.remainingBytes());
-    },
-    create() {
-        // TODO: this is a hack.
-        return PBGltfNodeModifiers.decode(new Uint8Array());
-    },
-    jsonSchema: {
-        type: "object",
-        properties: {},
-        serializationType: "protocol-buffer",
-        protocolBuffer: "PBGltfNodeModifiers"
-    }
-};

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

@@ -1,43 +0,0 @@
-import _m0 from "protobufjs/minimal";
-import { PBMaterial } from "./material.gen";
-/**
- * GltfNodeModifiers component is to be used attached to entities that have the GltfContainer component.
- *
- * This allows to override either the Material or the Casting Shadows behaviour of the target GLTF Node.
- *
- * * If the 'path' of the first modifier in the collection is an empty string: the configuration will
- * affect all of the GLTF Nodes (as a global modifier).
- * * Otherwise, for the modifiers whose 'path' is found in the GLTF hierarchy, the modifier will affect only
- * the target Nodes.
- */
-/**
- * @public
- */
-export interface PBGltfNodeModifiers {
-    modifiers: PBGltfNodeModifiers_GltfNodeModifier[];
-}
-/**
- * @public
- */
-export interface PBGltfNodeModifiers_GltfNodeModifier {
-    /** The GLTF hierarchy path of the target Node to be affected */
-    path: string;
-    /** The casting shadows enabled override */
-    castShadows?: boolean | undefined;
-    /** The Material that will be overridden on the target Node */
-    material?: PBMaterial | undefined;
-}
-/**
- * @public
- */
-export declare namespace PBGltfNodeModifiers {
-    function encode(message: PBGltfNodeModifiers, writer?: _m0.Writer): _m0.Writer;
-    function decode(input: _m0.Reader | Uint8Array, length?: number): PBGltfNodeModifiers;
-}
-/**
- * @public
- */
-export declare namespace PBGltfNodeModifiers_GltfNodeModifier {
-    function encode(message: PBGltfNodeModifiers_GltfNodeModifier, writer?: _m0.Writer): _m0.Writer;
-    function decode(input: _m0.Reader | Uint8Array, length?: number): PBGltfNodeModifiers_GltfNodeModifier;
-}

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

@@ -1,98 +0,0 @@
-/* eslint-disable */
-import _m0 from "protobufjs/minimal";
-import { PBMaterial } from "./material.gen";
-const protobufPackageSarasa = "decentraland.sdk.components";
-function createBasePBGltfNodeModifiers() {
-    return { modifiers: [] };
-}
-/**
- * @public
- */
-export var PBGltfNodeModifiers;
-(function (PBGltfNodeModifiers) {
-    function encode(message, writer = _m0.Writer.create()) {
-        for (const v of message.modifiers) {
-            PBGltfNodeModifiers_GltfNodeModifier.encode(v, writer.uint32(10).fork()).ldelim();
-        }
-        return writer;
-    }
-    PBGltfNodeModifiers.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 = createBasePBGltfNodeModifiers();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    if (tag !== 10) {
-                        break;
-                    }
-                    message.modifiers.push(PBGltfNodeModifiers_GltfNodeModifier.decode(reader, reader.uint32()));
-                    continue;
-            }
-            if ((tag & 7) === 4 || tag === 0) {
-                break;
-            }
-            reader.skipType(tag & 7);
-        }
-        return message;
-    }
-    PBGltfNodeModifiers.decode = decode;
-})(PBGltfNodeModifiers || (PBGltfNodeModifiers = {}));
-function createBasePBGltfNodeModifiers_GltfNodeModifier() {
-    return { path: "", castShadows: undefined, material: undefined };
-}
-/**
- * @public
- */
-export var PBGltfNodeModifiers_GltfNodeModifier;
-(function (PBGltfNodeModifiers_GltfNodeModifier) {
-    function encode(message, writer = _m0.Writer.create()) {
-        if (message.path !== "") {
-            writer.uint32(10).string(message.path);
-        }
-        if (message.castShadows !== undefined) {
-            writer.uint32(16).bool(message.castShadows);
-        }
-        if (message.material !== undefined) {
-            PBMaterial.encode(message.material, writer.uint32(26).fork()).ldelim();
-        }
-        return writer;
-    }
-    PBGltfNodeModifiers_GltfNodeModifier.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 = createBasePBGltfNodeModifiers_GltfNodeModifier();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    if (tag !== 10) {
-                        break;
-                    }
-                    message.path = reader.string();
-                    continue;
-                case 2:
-                    if (tag !== 16) {
-                        break;
-                    }
-                    message.castShadows = reader.bool();
-                    continue;
-                case 3:
-                    if (tag !== 26) {
-                        break;
-                    }
-                    message.material = PBMaterial.decode(reader, reader.uint32());
-                    continue;
-            }
-            if ((tag & 7) === 4 || tag === 0) {
-                break;
-            }
-            reader.skipType(tag & 7);
-        }
-        return message;
-    }
-    PBGltfNodeModifiers_GltfNodeModifier.decode = decode;
-})(PBGltfNodeModifiers_GltfNodeModifier || (PBGltfNodeModifiers_GltfNodeModifier = {}));

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

@@ -1,31 +0,0 @@
-import _m0 from "protobufjs/minimal";
-/** Controls the direction for animated skybox transitions */
-/**
- * @public
- */
-export declare const enum TransitionMode {
-    /** TM_FORWARD - transitions forward (default) */
-    TM_FORWARD = 0,
-    /** TM_BACKWARD - transitions backward */
-    TM_BACKWARD = 1
-}
-/**
- * The SkyboxTime component allows controlling the time of day for the skybox,
- * affecting the lighting and appearance of the sky in the scene.
- */
-/**
- * @public
- */
-export interface PBSkyboxTime {
-    /** fixed time of day, represented as a number of seconds since the start of the day, where 0 is 00:00hs, 43200 is 12:00hs and 86400 is 24:00hs */
-    fixedTime: number;
-    /** default = TransitionMode.TM_FORWARD, controls the direction of time transitions */
-    transitionMode?: TransitionMode | undefined;
-}
-/**
- * @public
- */
-export declare namespace PBSkyboxTime {
-    function encode(message: PBSkyboxTime, writer?: _m0.Writer): _m0.Writer;
-    function decode(input: _m0.Reader | Uint8Array, length?: number): PBSkyboxTime;
-}

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

@@ -1,61 +0,0 @@
-/* eslint-disable */
-import _m0 from "protobufjs/minimal";
-const protobufPackageSarasa = "decentraland.sdk.components";
-/** Controls the direction for animated skybox transitions */
-/**
- * @public
- */
-export var TransitionMode;
-(function (TransitionMode) {
-    /** TM_FORWARD - transitions forward (default) */
-    TransitionMode[TransitionMode["TM_FORWARD"] = 0] = "TM_FORWARD";
-    /** TM_BACKWARD - transitions backward */
-    TransitionMode[TransitionMode["TM_BACKWARD"] = 1] = "TM_BACKWARD";
-})(TransitionMode || (TransitionMode = {}));
-function createBasePBSkyboxTime() {
-    return { fixedTime: 0, transitionMode: undefined };
-}
-/**
- * @public
- */
-export var PBSkyboxTime;
-(function (PBSkyboxTime) {
-    function encode(message, writer = _m0.Writer.create()) {
-        if (message.fixedTime !== 0) {
-            writer.uint32(8).uint32(message.fixedTime);
-        }
-        if (message.transitionMode !== undefined) {
-            writer.uint32(16).int32(message.transitionMode);
-        }
-        return writer;
-    }
-    PBSkyboxTime.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 = createBasePBSkyboxTime();
-        while (reader.pos < end) {
-            const tag = reader.uint32();
-            switch (tag >>> 3) {
-                case 1:
-                    if (tag !== 8) {
-                        break;
-                    }
-                    message.fixedTime = reader.uint32();
-                    continue;
-                case 2:
-                    if (tag !== 16) {
-                        break;
-                    }
-                    message.transitionMode = reader.int32();
-                    continue;
-            }
-            if ((tag & 7) === 4 || tag === 0) {
-                break;
-            }
-            reader.skipType(tag & 7);
-        }
-        return message;
-    }
-    PBSkyboxTime.decode = decode;
-})(PBSkyboxTime || (PBSkyboxTime = {}));