@dcl/protocol 1.0.0-10043247792.commit-428d1eb

package/out-ts/decentraland/sdk/components/tween_sequence.gen.ts

@@ -0,0 +1,134 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { PBTween } from "./tween.gen";
+
+export const protobufPackage = "decentraland.sdk.components";
+
+export enum TweenLoop {
+  TL_RESTART = 0,
+  TL_YOYO = 1,
+  UNRECOGNIZED = -1,
+}
+
+export function tweenLoopFromJSON(object: any): TweenLoop {
+  switch (object) {
+    case 0:
+    case "TL_RESTART":
+      return TweenLoop.TL_RESTART;
+    case 1:
+    case "TL_YOYO":
+      return TweenLoop.TL_YOYO;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return TweenLoop.UNRECOGNIZED;
+  }
+}
+
+export function tweenLoopToJSON(object: TweenLoop): string {
+  switch (object) {
+    case TweenLoop.TL_RESTART:
+      return "TL_RESTART";
+    case TweenLoop.TL_YOYO:
+      return "TL_YOYO";
+    case TweenLoop.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export interface PBTweenSequence {
+  sequence: PBTween[];
+  loop?: TweenLoop | undefined;
+}
+
+function createBasePBTweenSequence(): PBTweenSequence {
+  return { sequence: [], loop: undefined };
+}
+
+export namespace PBTweenSequence {
+  export function encode(message: PBTweenSequence, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.sequence) {
+      PBTween.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.loop !== undefined) {
+      writer.uint32(16).int32(message.loop);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PBTweenSequence {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBTweenSequence();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.sequence.push(PBTween.decode(reader, reader.uint32()));
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.loop = reader.int32() as any;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PBTweenSequence {
+    return {
+      sequence: Array.isArray(object?.sequence) ? object.sequence.map((e: any) => PBTween.fromJSON(e)) : [],
+      loop: isSet(object.loop) ? tweenLoopFromJSON(object.loop) : undefined,
+    };
+  }
+
+  export function toJSON(message: PBTweenSequence): unknown {
+    const obj: any = {};
+    if (message.sequence) {
+      obj.sequence = message.sequence.map((e) => e ? PBTween.toJSON(e) : undefined);
+    } else {
+      obj.sequence = [];
+    }
+    message.loop !== undefined && (obj.loop = message.loop !== undefined ? tweenLoopToJSON(message.loop) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PBTweenSequence>, I>>(base?: I): PBTweenSequence {
+    return PBTweenSequence.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBTweenSequence>, I>>(object: I): PBTweenSequence {
+    const message = createBasePBTweenSequence();
+    message.sequence = object.sequence?.map((e) => PBTween.fromPartial(e)) || [];
+    message.loop = object.loop ?? undefined;
+    return message;
+  }
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}

package/out-ts/decentraland/sdk/components/tween_state.gen.ts

@@ -0,0 +1,136 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "decentraland.sdk.components";
+
+export enum TweenStateStatus {
+  TS_ACTIVE = 0,
+  TS_COMPLETED = 1,
+  TS_PAUSED = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function tweenStateStatusFromJSON(object: any): TweenStateStatus {
+  switch (object) {
+    case 0:
+    case "TS_ACTIVE":
+      return TweenStateStatus.TS_ACTIVE;
+    case 1:
+    case "TS_COMPLETED":
+      return TweenStateStatus.TS_COMPLETED;
+    case 2:
+    case "TS_PAUSED":
+      return TweenStateStatus.TS_PAUSED;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return TweenStateStatus.UNRECOGNIZED;
+  }
+}
+
+export function tweenStateStatusToJSON(object: TweenStateStatus): string {
+  switch (object) {
+    case TweenStateStatus.TS_ACTIVE:
+      return "TS_ACTIVE";
+    case TweenStateStatus.TS_COMPLETED:
+      return "TS_COMPLETED";
+    case TweenStateStatus.TS_PAUSED:
+      return "TS_PAUSED";
+    case TweenStateStatus.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export interface PBTweenState {
+  state: TweenStateStatus;
+  /** between 0 and 1 */
+  currentTime: number;
+}
+
+function createBasePBTweenState(): PBTweenState {
+  return { state: 0, currentTime: 0 };
+}
+
+export namespace PBTweenState {
+  export function encode(message: PBTweenState, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.state !== 0) {
+      writer.uint32(8).int32(message.state);
+    }
+    if (message.currentTime !== 0) {
+      writer.uint32(21).float(message.currentTime);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PBTweenState {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBTweenState();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.state = reader.int32() as any;
+          continue;
+        case 2:
+          if (tag !== 21) {
+            break;
+          }
+
+          message.currentTime = reader.float();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PBTweenState {
+    return {
+      state: isSet(object.state) ? tweenStateStatusFromJSON(object.state) : 0,
+      currentTime: isSet(object.currentTime) ? Number(object.currentTime) : 0,
+    };
+  }
+
+  export function toJSON(message: PBTweenState): unknown {
+    const obj: any = {};
+    message.state !== undefined && (obj.state = tweenStateStatusToJSON(message.state));
+    message.currentTime !== undefined && (obj.currentTime = message.currentTime);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PBTweenState>, I>>(base?: I): PBTweenState {
+    return PBTweenState.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBTweenState>, I>>(object: I): PBTweenState {
+    const message = createBasePBTweenState();
+    message.state = object.state ?? 0;
+    message.currentTime = object.currentTime ?? 0;
+    return message;
+  }
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}

package/out-ts/decentraland/sdk/components/ui_background.gen.ts

@@ -0,0 +1,223 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { BorderRect } from "../../common/border_rect.gen";
+import { Color4 } from "../../common/colors.gen";
+import { TextureUnion } from "../../common/texture.gen";
+
+export const protobufPackage = "decentraland.sdk.components";
+
+export enum BackgroundTextureMode {
+  /**
+   * NINE_SLICES - https://docs.unity3d.com/Manual/UIE-USS-SupportedProperties.html (Slicing section)
+   * https://forum.unity.com/threads/how-does-slicing-in-ui-tookkit-works.1235863/
+   * https://docs.unity3d.com/Manual/9SliceSprites.html
+   * https://developer.mozilla.org/en-US/docs/Web/CSS/border-image-slice
+   */
+  NINE_SLICES = 0,
+  /**
+   * CENTER - CENTER enables the texture to be rendered centered in relation to the
+   * element. If the element is smaller than the texture then the background
+   * should use the element as stencil to cut off the out-of-bounds area
+   */
+  CENTER = 1,
+  /**
+   * STRETCH - STRETCH enables the texture to cover all the area of the container,
+   * adopting its aspect ratio.
+   */
+  STRETCH = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function backgroundTextureModeFromJSON(object: any): BackgroundTextureMode {
+  switch (object) {
+    case 0:
+    case "NINE_SLICES":
+      return BackgroundTextureMode.NINE_SLICES;
+    case 1:
+    case "CENTER":
+      return BackgroundTextureMode.CENTER;
+    case 2:
+    case "STRETCH":
+      return BackgroundTextureMode.STRETCH;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return BackgroundTextureMode.UNRECOGNIZED;
+  }
+}
+
+export function backgroundTextureModeToJSON(object: BackgroundTextureMode): string {
+  switch (object) {
+    case BackgroundTextureMode.NINE_SLICES:
+      return "NINE_SLICES";
+    case BackgroundTextureMode.CENTER:
+      return "CENTER";
+    case BackgroundTextureMode.STRETCH:
+      return "STRETCH";
+    case BackgroundTextureMode.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export interface PBUiBackground {
+  /** default=(1.0, 1.0, 1.0, 1.0), pixel = color * sample2D(texture, uv) */
+  color?: Color4 | undefined;
+  texture?: TextureUnion | undefined;
+  textureMode: BackgroundTextureMode;
+  /** default=(1/3, 1/3, 1/3, 1/3) */
+  textureSlices?:
+    | BorderRect
+    | undefined;
+  /** default=[0,0,0,1,1,0,1,0]: starting from bottom-left vertex clock-wise */
+  uvs: number[];
+}
+
+function createBasePBUiBackground(): PBUiBackground {
+  return { color: undefined, texture: undefined, textureMode: 0, textureSlices: undefined, uvs: [] };
+}
+
+export namespace PBUiBackground {
+  export function encode(message: PBUiBackground, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.color !== undefined) {
+      Color4.encode(message.color, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.texture !== undefined) {
+      TextureUnion.encode(message.texture, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.textureMode !== 0) {
+      writer.uint32(24).int32(message.textureMode);
+    }
+    if (message.textureSlices !== undefined) {
+      BorderRect.encode(message.textureSlices, writer.uint32(34).fork()).ldelim();
+    }
+    writer.uint32(42).fork();
+    for (const v of message.uvs) {
+      writer.float(v);
+    }
+    writer.ldelim();
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PBUiBackground {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBUiBackground();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.color = Color4.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.texture = TextureUnion.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.textureMode = reader.int32() as any;
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.textureSlices = BorderRect.decode(reader, reader.uint32());
+          continue;
+        case 5:
+          if (tag === 45) {
+            message.uvs.push(reader.float());
+
+            continue;
+          }
+
+          if (tag === 42) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.uvs.push(reader.float());
+            }
+
+            continue;
+          }
+
+          break;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PBUiBackground {
+    return {
+      color: isSet(object.color) ? Color4.fromJSON(object.color) : undefined,
+      texture: isSet(object.texture) ? TextureUnion.fromJSON(object.texture) : undefined,
+      textureMode: isSet(object.textureMode) ? backgroundTextureModeFromJSON(object.textureMode) : 0,
+      textureSlices: isSet(object.textureSlices) ? BorderRect.fromJSON(object.textureSlices) : undefined,
+      uvs: Array.isArray(object?.uvs) ? object.uvs.map((e: any) => Number(e)) : [],
+    };
+  }
+
+  export function toJSON(message: PBUiBackground): unknown {
+    const obj: any = {};
+    message.color !== undefined && (obj.color = message.color ? Color4.toJSON(message.color) : undefined);
+    message.texture !== undefined && (obj.texture = message.texture ? TextureUnion.toJSON(message.texture) : undefined);
+    message.textureMode !== undefined && (obj.textureMode = backgroundTextureModeToJSON(message.textureMode));
+    message.textureSlices !== undefined &&
+      (obj.textureSlices = message.textureSlices ? BorderRect.toJSON(message.textureSlices) : undefined);
+    if (message.uvs) {
+      obj.uvs = message.uvs.map((e) => e);
+    } else {
+      obj.uvs = [];
+    }
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PBUiBackground>, I>>(base?: I): PBUiBackground {
+    return PBUiBackground.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBUiBackground>, I>>(object: I): PBUiBackground {
+    const message = createBasePBUiBackground();
+    message.color = (object.color !== undefined && object.color !== null)
+      ? Color4.fromPartial(object.color)
+      : undefined;
+    message.texture = (object.texture !== undefined && object.texture !== null)
+      ? TextureUnion.fromPartial(object.texture)
+      : undefined;
+    message.textureMode = object.textureMode ?? 0;
+    message.textureSlices = (object.textureSlices !== undefined && object.textureSlices !== null)
+      ? BorderRect.fromPartial(object.textureSlices)
+      : undefined;
+    message.uvs = object.uvs?.map((e) => e) || [];
+    return message;
+  }
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}