@dcl/ecs 7.31.1-41508430758.commit-0af8af0 → 7.32.0

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

@@ -0,0 +1,93 @@
+import _m0 from "protobufjs/minimal";
+import { ColorGradient } from "../../common/gradient.gen";
+/**
+ * PBSkybox overrides the visible sky while the player is inside the scene.
+ * Valid only on the scene root entity (`engine.RootEntity`).
+ *
+ * An unset field keeps the time-of-day default.
+ * Gradient `time` is the normalized time of day: 0 = 00:00, 0.5 = 12:00, 1 = 24:00.
+ * Gradients do not wrap around midnight.
+ * The sun is controlled by `PBSun` and the fog by `PBEnvironmentFog`.
+ *
+ * While active, the overrides are global: they also change how neighbouring parcels look from inside the scene.
+ */
+/**
+ * @public
+ */
+export interface PBSkybox {
+    /**
+     * Replaces the visible sky with an image, given as its source path with the same rules as `Texture.src`.
+     * It must be an equirectangular (latitude-longitude) image with a 2:1 aspect ratio:
+     * the image centre faces +Z, the top row is the zenith and the bottom row the nadir.
+     * Cube cross, 3x2 and six-face layouts are not supported.
+     * The sun, the fog and the ambient lighting do not change: the ambient still follows `sky_colors`.
+     */
+    skyboxTexture?: string | undefined;
+    /**
+     * Procedural sky colors. They also drive the ambient lighting, also while `skybox_texture` is set.
+     * While `skybox_texture` is set they no longer color the visible sky.
+     */
+    skyColors?: PBSkybox_SkyColors | undefined;
+    /** Ignored while `skybox_texture` is set. */
+    clouds?: PBSkybox_Clouds | undefined;
+    /** Ignored while `skybox_texture` is set. */
+    stars?: PBSkybox_Stars | undefined;
+}
+/**
+ * @public
+ */
+export interface PBSkybox_SkyColors {
+    /** the sky straight up */
+    zenith?: ColorGradient | undefined;
+    /** the broad band of sky around the horizon */
+    horizon?: ColorGradient | undefined;
+    /** The sky below the horizon, visible wherever no terrain covers it (landscape disabled, high altitude). */
+    nadir?: ColorGradient | undefined;
+    /** Narrow glow right on the horizon line, like a sunset glow. Unset = follows `horizon` when that is set. */
+    rim?: ColorGradient | undefined;
+}
+/**
+ * @public
+ */
+export interface PBSkybox_Clouds {
+    /** default = 1, from 0 to 1 */
+    opacity?: number | undefined;
+    /** default = 0.01, in radians per second around the sky axis (0.01 is one turn every ~10 minutes). 0 = static, negative reverses the direction */
+    speed?: number | undefined;
+    color?: ColorGradient | undefined;
+}
+/**
+ * @public
+ */
+export interface PBSkybox_Stars {
+    /** default = 4.62, multiplier on the star texture (1 = as authored, values above 1 are HDR). 0 hides the stars, negative values clamp to 0. Stars are visible only at night */
+    brightness?: number | undefined;
+}
+/**
+ * @public
+ */
+export declare namespace PBSkybox {
+    function encode(message: PBSkybox, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBSkybox;
+}
+/**
+ * @public
+ */
+export declare namespace PBSkybox_SkyColors {
+    function encode(message: PBSkybox_SkyColors, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBSkybox_SkyColors;
+}
+/**
+ * @public
+ */
+export declare namespace PBSkybox_Clouds {
+    function encode(message: PBSkybox_Clouds, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBSkybox_Clouds;
+}
+/**
+ * @public
+ */
+export declare namespace PBSkybox_Stars {
+    function encode(message: PBSkybox_Stars, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBSkybox_Stars;
+}

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

@@ -0,0 +1,228 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { ColorGradient } from "../../common/gradient.gen";
+const protobufPackageSarasa = "decentraland.sdk.components";
+function createBasePBSkybox() {
+    return { skyboxTexture: undefined, skyColors: undefined, clouds: undefined, stars: undefined };
+}
+/**
+ * @public
+ */
+export var PBSkybox;
+(function (PBSkybox) {
+    function encode(message, writer = _m0.Writer.create()) {
+        if (message.skyboxTexture !== undefined) {
+            writer.uint32(10).string(message.skyboxTexture);
+        }
+        if (message.skyColors !== undefined) {
+            PBSkybox_SkyColors.encode(message.skyColors, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.clouds !== undefined) {
+            PBSkybox_Clouds.encode(message.clouds, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.stars !== undefined) {
+            PBSkybox_Stars.encode(message.stars, writer.uint32(34).fork()).ldelim();
+        }
+        return writer;
+    }
+    PBSkybox.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 = createBasePBSkybox();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.skyboxTexture = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.skyColors = PBSkybox_SkyColors.decode(reader, reader.uint32());
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.clouds = PBSkybox_Clouds.decode(reader, reader.uint32());
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.stars = PBSkybox_Stars.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBSkybox.decode = decode;
+})(PBSkybox || (PBSkybox = {}));
+function createBasePBSkybox_SkyColors() {
+    return { zenith: undefined, horizon: undefined, nadir: undefined, rim: undefined };
+}
+/**
+ * @public
+ */
+export var PBSkybox_SkyColors;
+(function (PBSkybox_SkyColors) {
+    function encode(message, writer = _m0.Writer.create()) {
+        if (message.zenith !== undefined) {
+            ColorGradient.encode(message.zenith, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.horizon !== undefined) {
+            ColorGradient.encode(message.horizon, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.nadir !== undefined) {
+            ColorGradient.encode(message.nadir, writer.uint32(26).fork()).ldelim();
+        }
+        if (message.rim !== undefined) {
+            ColorGradient.encode(message.rim, writer.uint32(34).fork()).ldelim();
+        }
+        return writer;
+    }
+    PBSkybox_SkyColors.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 = createBasePBSkybox_SkyColors();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.zenith = ColorGradient.decode(reader, reader.uint32());
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.horizon = ColorGradient.decode(reader, reader.uint32());
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.nadir = ColorGradient.decode(reader, reader.uint32());
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.rim = ColorGradient.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBSkybox_SkyColors.decode = decode;
+})(PBSkybox_SkyColors || (PBSkybox_SkyColors = {}));
+function createBasePBSkybox_Clouds() {
+    return { opacity: undefined, speed: undefined, color: undefined };
+}
+/**
+ * @public
+ */
+export var PBSkybox_Clouds;
+(function (PBSkybox_Clouds) {
+    function encode(message, writer = _m0.Writer.create()) {
+        if (message.opacity !== undefined) {
+            writer.uint32(13).float(message.opacity);
+        }
+        if (message.speed !== undefined) {
+            writer.uint32(21).float(message.speed);
+        }
+        if (message.color !== undefined) {
+            ColorGradient.encode(message.color, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    }
+    PBSkybox_Clouds.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 = createBasePBSkybox_Clouds();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 13) {
+                        break;
+                    }
+                    message.opacity = reader.float();
+                    continue;
+                case 2:
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.speed = reader.float();
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.color = ColorGradient.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBSkybox_Clouds.decode = decode;
+})(PBSkybox_Clouds || (PBSkybox_Clouds = {}));
+function createBasePBSkybox_Stars() {
+    return { brightness: undefined };
+}
+/**
+ * @public
+ */
+export var PBSkybox_Stars;
+(function (PBSkybox_Stars) {
+    function encode(message, writer = _m0.Writer.create()) {
+        if (message.brightness !== undefined) {
+            writer.uint32(13).float(message.brightness);
+        }
+        return writer;
+    }
+    PBSkybox_Stars.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 = createBasePBSkybox_Stars();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 13) {
+                        break;
+                    }
+                    message.brightness = reader.float();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBSkybox_Stars.decode = decode;
+})(PBSkybox_Stars || (PBSkybox_Stars = {}));

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

@@ -0,0 +1,37 @@
+import _m0 from "protobufjs/minimal";
+import { ColorGradient } from "../../common/gradient.gen";
+import { Vector3 } from "../../common/vectors.gen";
+/**
+ * PBSun overrides the directional light (sun and moon) while the player is inside the scene.
+ * Valid only on the scene root entity (`engine.RootEntity`).
+ *
+ * An unset field keeps the time-of-day default.
+ * Gradient `time` is the normalized time of day: 0 = 00:00, 0.5 = 12:00, 1 = 24:00.
+ * Gradients do not wrap around midnight.
+ *
+ * While active, the overrides are global: they also change how neighbouring parcels look from inside the scene.
+ */
+/**
+ * @public
+ */
+export interface PBSun {
+    /** tints the directional light and the sun disc */
+    color?: ColorGradient | undefined;
+    /** default = true. false hides the sun and moon discs and the lens flare, but not their light */
+    visible?: boolean | undefined;
+    /** default = 1, multiplier on the renderer's time-of-day light intensity. Negative values clamp to 0 */
+    intensity?: number | undefined;
+    /**
+     * Direction the sunlight travels, in scene space: (0,-1,0) = sun straight overhead. Normalized by the renderer.
+     * Set = the sun stays fixed at every time of day; its color and intensity still follow the time of day.
+     * Unset or zero = the time-of-day path.
+     */
+    direction?: Vector3 | undefined;
+}
+/**
+ * @public
+ */
+export declare namespace PBSun {
+    function encode(message: PBSun, writer?: _m0.Writer): _m0.Writer;
+    function decode(input: _m0.Reader | Uint8Array, length?: number): PBSun;
+}

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

@@ -0,0 +1,70 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { ColorGradient } from "../../common/gradient.gen";
+import { Vector3 } from "../../common/vectors.gen";
+const protobufPackageSarasa = "decentraland.sdk.components";
+function createBasePBSun() {
+    return { color: undefined, visible: undefined, intensity: undefined, direction: undefined };
+}
+/**
+ * @public
+ */
+export var PBSun;
+(function (PBSun) {
+    function encode(message, writer = _m0.Writer.create()) {
+        if (message.color !== undefined) {
+            ColorGradient.encode(message.color, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.visible !== undefined) {
+            writer.uint32(16).bool(message.visible);
+        }
+        if (message.intensity !== undefined) {
+            writer.uint32(29).float(message.intensity);
+        }
+        if (message.direction !== undefined) {
+            Vector3.encode(message.direction, writer.uint32(34).fork()).ldelim();
+        }
+        return writer;
+    }
+    PBSun.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 = createBasePBSun();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.color = ColorGradient.decode(reader, reader.uint32());
+                    continue;
+                case 2:
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.visible = reader.bool();
+                    continue;
+                case 3:
+                    if (tag !== 29) {
+                        break;
+                    }
+                    message.intensity = reader.float();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.direction = Vector3.decode(reader, reader.uint32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    }
+    PBSun.decode = decode;
+})(PBSun || (PBSun = {}));

package/dist/components/generated/types.gen.d.ts

@@ -12,4 +12,5 @@ export * from './pb/decentraland/sdk/components/common/raycast_hit.gen';
 export * from './pb/decentraland/sdk/components/common/texts.gen';
 export * from './pb/decentraland/common/border_rect.gen';
 export * from './pb/decentraland/common/floats.gen';
+export * from './pb/decentraland/common/gradient.gen';
 export * from './pb/decentraland/common/texture.gen';

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

@@ -21,5 +21,7 @@ export * from './pb/decentraland/common/border_rect.gen';
 // export { PbBorderRect }
 export * from './pb/decentraland/common/floats.gen';
 // export { PbFloats }
+export * from './pb/decentraland/common/gradient.gen';
+// export { PbGradient }
 export * from './pb/decentraland/common/texture.gen';
 // export { PbTexture }

package/dist/components/index.d.ts

@@ -23,7 +23,6 @@ import { TriggerAreaComponentDefinitionExtended } from './extended/TriggerArea';
 import { ParticleSystemComponentDefinitionExtended } from './extended/ParticleSystem';
 import { TouchScreenControlsComponentDefinitionExtended } from './extended/TouchScreenControls';
 import { TagsComponentDefinitionExtended } from './manual/Tags';
-import { ICreatedByType } from './manual/CreatedBy';
 export * from './generated/index.gen';
 export type { GrowOnlyValueSetComponentDefinition, LastWriteWinElementSetComponentDefinition, LwwComponentGetter, GSetComponentGetter };
 export declare const Transform: LwwComponentGetter<TransformComponentExtended>;
@@ -58,9 +57,5 @@ export declare const NetworkEntity: (engine: Pick<IEngine, 'defineComponent'>) =
  * @alpha
  */
 export declare const NetworkParent: (engine: Pick<IEngine, 'defineComponent'>) => LastWriteWinElementSetComponentDefinition<INetowrkParentType>;
-/**
- * @public
- */
-export declare const CreatedBy: (engine: Pick<IEngine, 'defineComponent'>) => LastWriteWinElementSetComponentDefinition<ICreatedByType>;
 export { MediaState };
 export type { AudioAnalysisView };

package/dist/components/index.js

@@ -19,7 +19,6 @@ import { defineTriggerAreaComponent } from './extended/TriggerArea';
 import { defineParticleSystemComponent } from './extended/ParticleSystem';
 import { defineTouchScreenControlsComponent } from './extended/TouchScreenControls';
 import defineTagsComponent from './manual/Tags';
-import defineCreatedBy from './manual/CreatedBy';
 export * from './generated/index.gen';
 /* @__PURE__ */
 export const Transform = (engine) => defineTransformComponent(engine);
@@ -66,13 +65,11 @@ export const SyncComponents = (engine) => defineSyncComponent(engine);
 /**
  * @alpha
  */
+/* @__PURE__ */
 export const NetworkEntity = (engine) => defineNetworkEntity(engine);
 /**
  * @alpha
  */
+/* @__PURE__ */
 export const NetworkParent = (engine) => defineNetworkParent(engine);
-/**
- * @public
- */
-export const CreatedBy = (engine) => defineCreatedBy(engine);
 export { MediaState };

package/dist/components/manual/Transform.d.ts

@@ -1,6 +1,5 @@
 import { LastWriteWinElementSetComponentDefinition, IEngine } from '../../engine';
 import { Entity } from '../../engine/entity';
-import type { ISchema } from '../../schemas/ISchema';
 import type { Vector3Type } from '../../schemas/custom/Vector3';
 /**
  * @public
@@ -25,10 +24,6 @@ export interface TransformComponentExtended extends TransformComponent {
      */
     localToWorldDirection(entity: Entity, localDirection: Vector3Type): Vector3Type;
 }
-/**
- * @public
- */
-export declare const COMPONENT_ID = 1;
 /**
  * @public
  */
@@ -51,10 +46,6 @@ export type TransformType = {
     };
     parent?: Entity;
 };
-/** @public */
-export declare const TRANSFORM_LENGTH = 44;
-/** @public */
-export declare const TransformSchema: ISchema<TransformType>;
 /**
  * @public
  */

package/dist/components/manual/Transform.js

@@ -3,12 +3,12 @@
 // getters via __importStar in CJS), so by the time methods are called all exports are available.
 import * as treeHelpers from '../../runtime/helpers/tree';
 /**
- * @public
+ * @internal
  */
 export const COMPONENT_ID = 1;
-/** @public */
+/** @internal */
 export const TRANSFORM_LENGTH = 44;
-/** @public */
+/** @internal */
 export const TransformSchema = {
     serialize(value, builder) {
         const ptr = builder.incrementWriteOffset(TRANSFORM_LENGTH);

package/dist/components/types.d.ts

@@ -13,7 +13,6 @@ export type { TagsComponentDefinitionExtended, TagsType } from './manual/Tags';
 export type { ISyncComponents, ISyncComponentsType } from './manual/SyncComponents';
 export type { INetowrkEntity, INetowrkEntityType } from './manual/NetworkEntity';
 export type { INetowrkParent, INetowrkParentType } from './manual/NetworkParent';
-export type { ICreatedBy, ICreatedByType } from './manual/CreatedBy';
 export type { InputModifierHelper, InputModifierComponentDefinitionExtended } from './extended/InputModifier';
 export type { LightSourceHelper, LightSourceComponentDefinitionExtended } from './extended/LightSource';
 export type { TriggerAreaComponentDefinitionExtended } from './extended/TriggerArea';

package/dist/engine/component.d.ts

@@ -1,6 +1,6 @@
 import { ISchema } from '../schemas';
 import { ByteBuffer } from '../serialization/ByteBuffer';
-import { CrdtMessageBody, DeleteComponentMessageBody, ProcessMessageResultType, PutComponentMessageBody } from '../serialization/crdt';
+import { CrdtMessageBody, DeleteComponentMessageBody, PutComponentMessageBody } from '../serialization/crdt';
 import { Entity } from './entity';
 import { DeepReadonly, DeepReadonlySet } from './readonly';
 /**
@@ -70,58 +70,7 @@ export interface BaseComponent<T> {
      * If the value is undefined, the component was deleted.
      */
     onChange(entity: Entity, cb: (value: T | undefined) => void): void;
-    /**
-     * @public
-     *
-     */
-    validateBeforeChange(entity: Entity, cb: ValidateCallback<T>): void;
-    validateBeforeChange(cb: ValidateCallback<T>): void;
-    /**
-     * Get the CRDT state for an entity (serialized data and timestamp)
-     * @param entity - Entity to get the CRDT state for
-     * @returns Object with serialized data and timestamp, or null if entity doesn't have the component
-     * @public
-     */
-    getCrdtState(entity: Entity): {
-        data: Uint8Array;
-        timestamp: number;
-    } | null;
-}
-/**
- * Internal component interface that exposes all internal methods for SDK use
- * This is not exposed to users, only for internal SDK operations
- */
-export interface InternalBaseComponent<T> extends BaseComponent<T> {
-    /**
-     * @public
-     * Dry run update to check if a CRDT message would be accepted without actually applying it
-     */
-    __dry_run_updateFromCrdt(body: CrdtMessageBody): ProcessMessageResultType;
-    /**
-     * @public
-     * Get the iterator to every entity has the component
-     */
-    iterator(): Iterable<[Entity, any]>;
-    /**
-     * @public
-     */
-    dirtyIterator(): Iterable<Entity>;
-    /**
-     * @public
-     */
-    __onChangeCallbacks(entity: Entity, value: T): void;
-    /**
-     * @public
-     */
-    __run_validateBeforeChange(entity: Entity, newValue: T | undefined, senderAddress: string, createdBy: string): boolean;
 }
-export type ValidateCallback<T> = (value: {
-    entity: Entity;
-    currentValue: T | undefined;
-    newValue: T | undefined;
-    senderAddress: string;
-    createdBy: string;
-}) => boolean;
 /**
  * @public
  */