@dcl/protocol 1.0.0-9079009942.commit-57ffac6 → 1.0.0-9115457439.commit-926ebd1

package/out-ts/decentraland/kernel/apis/testing.gen.ts

@@ -1,8 +1,95 @@
 /* eslint-disable */
 import _m0 from "protobufjs/minimal";
+import { Vector2, Vector3 } from "../../common/vectors.gen";
 
 export const protobufPackage = "decentraland.kernel.apis";
 
+/** @internal */
+export interface TakeAndCompareScreenshotRequest {
+  /**
+   * the source path in the scene where the screenshot is stored,
+   *  the snapshot taken is compared with the stored one
+   */
+  srcStoredSnapshot: string;
+  /** the camera position where is set before and while taking the screenshot, relative to base scene */
+  cameraPosition:
+    | Vector3
+    | undefined;
+  /** the camera position where is target to before and while taking the screenshot, relative to base scene */
+  cameraTarget:
+    | Vector3
+    | undefined;
+  /** width x height screenshot size */
+  screenshotSize: Vector2 | undefined;
+  comparisonMethod?: {
+    $case: "greyPixelDiff";
+    greyPixelDiff: TakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff;
+  } | undefined;
+  snapshotMode: TakeAndCompareScreenshotRequest_SnapshotMode;
+}
+
+export enum TakeAndCompareScreenshotRequest_SnapshotMode {
+  /** SM_3D_AND_UI - only visible 3d scene and ui scene */
+  SM_3D_AND_UI = 0,
+  /** SM_3D_ONLY - only visible 3d scene */
+  SM_3D_ONLY = 1,
+  /** SM_UI_ONLY - only visible ui scene */
+  SM_UI_ONLY = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function takeAndCompareScreenshotRequest_SnapshotModeFromJSON(
+  object: any,
+): TakeAndCompareScreenshotRequest_SnapshotMode {
+  switch (object) {
+    case 0:
+    case "SM_3D_AND_UI":
+      return TakeAndCompareScreenshotRequest_SnapshotMode.SM_3D_AND_UI;
+    case 1:
+    case "SM_3D_ONLY":
+      return TakeAndCompareScreenshotRequest_SnapshotMode.SM_3D_ONLY;
+    case 2:
+    case "SM_UI_ONLY":
+      return TakeAndCompareScreenshotRequest_SnapshotMode.SM_UI_ONLY;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return TakeAndCompareScreenshotRequest_SnapshotMode.UNRECOGNIZED;
+  }
+}
+
+export function takeAndCompareScreenshotRequest_SnapshotModeToJSON(
+  object: TakeAndCompareScreenshotRequest_SnapshotMode,
+): string {
+  switch (object) {
+    case TakeAndCompareScreenshotRequest_SnapshotMode.SM_3D_AND_UI:
+      return "SM_3D_AND_UI";
+    case TakeAndCompareScreenshotRequest_SnapshotMode.SM_3D_ONLY:
+      return "SM_3D_ONLY";
+    case TakeAndCompareScreenshotRequest_SnapshotMode.SM_UI_ONLY:
+      return "SM_UI_ONLY";
+    case TakeAndCompareScreenshotRequest_SnapshotMode.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export interface TakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff {
+}
+
+/** @internal */
+export interface TakeAndCompareScreenshotResponse {
+  storedSnapshotFound: boolean;
+  comparisonMethodResult?: {
+    $case: "greyPixelDiff";
+    greyPixelDiff: TakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult;
+  } | undefined;
+}
+
+export interface TakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult {
+  similarity: number;
+}
+
 export interface TestResult {
   name: string;
   ok: boolean;
@@ -51,6 +138,417 @@ export interface SetCameraTransformTestCommand_Quaternion {
 export interface SetCameraTransformTestCommandResponse {
 }
 
+function createBaseTakeAndCompareScreenshotRequest(): TakeAndCompareScreenshotRequest {
+  return {
+    srcStoredSnapshot: "",
+    cameraPosition: undefined,
+    cameraTarget: undefined,
+    screenshotSize: undefined,
+    comparisonMethod: undefined,
+    snapshotMode: 0,
+  };
+}
+
+export namespace TakeAndCompareScreenshotRequest {
+  export function encode(
+    message: TakeAndCompareScreenshotRequest,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.srcStoredSnapshot !== "") {
+      writer.uint32(10).string(message.srcStoredSnapshot);
+    }
+    if (message.cameraPosition !== undefined) {
+      Vector3.encode(message.cameraPosition, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.cameraTarget !== undefined) {
+      Vector3.encode(message.cameraTarget, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.screenshotSize !== undefined) {
+      Vector2.encode(message.screenshotSize, writer.uint32(34).fork()).ldelim();
+    }
+    switch (message.comparisonMethod?.$case) {
+      case "greyPixelDiff":
+        TakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff.encode(
+          message.comparisonMethod.greyPixelDiff,
+          writer.uint32(42).fork(),
+        ).ldelim();
+        break;
+    }
+    if (message.snapshotMode !== 0) {
+      writer.uint32(48).int32(message.snapshotMode);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): TakeAndCompareScreenshotRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTakeAndCompareScreenshotRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.srcStoredSnapshot = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.cameraPosition = Vector3.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.cameraTarget = Vector3.decode(reader, reader.uint32());
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.screenshotSize = Vector2.decode(reader, reader.uint32());
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.comparisonMethod = {
+            $case: "greyPixelDiff",
+            greyPixelDiff: TakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff.decode(
+              reader,
+              reader.uint32(),
+            ),
+          };
+          continue;
+        case 6:
+          if (tag !== 48) {
+            break;
+          }
+
+          message.snapshotMode = reader.int32() as any;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): TakeAndCompareScreenshotRequest {
+    return {
+      srcStoredSnapshot: isSet(object.srcStoredSnapshot) ? String(object.srcStoredSnapshot) : "",
+      cameraPosition: isSet(object.cameraPosition) ? Vector3.fromJSON(object.cameraPosition) : undefined,
+      cameraTarget: isSet(object.cameraTarget) ? Vector3.fromJSON(object.cameraTarget) : undefined,
+      screenshotSize: isSet(object.screenshotSize) ? Vector2.fromJSON(object.screenshotSize) : undefined,
+      comparisonMethod: isSet(object.greyPixelDiff)
+        ? {
+          $case: "greyPixelDiff",
+          greyPixelDiff: TakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff.fromJSON(object.greyPixelDiff),
+        }
+        : undefined,
+      snapshotMode: isSet(object.snapshotMode)
+        ? takeAndCompareScreenshotRequest_SnapshotModeFromJSON(object.snapshotMode)
+        : 0,
+    };
+  }
+
+  export function toJSON(message: TakeAndCompareScreenshotRequest): unknown {
+    const obj: any = {};
+    message.srcStoredSnapshot !== undefined && (obj.srcStoredSnapshot = message.srcStoredSnapshot);
+    message.cameraPosition !== undefined &&
+      (obj.cameraPosition = message.cameraPosition ? Vector3.toJSON(message.cameraPosition) : undefined);
+    message.cameraTarget !== undefined &&
+      (obj.cameraTarget = message.cameraTarget ? Vector3.toJSON(message.cameraTarget) : undefined);
+    message.screenshotSize !== undefined &&
+      (obj.screenshotSize = message.screenshotSize ? Vector2.toJSON(message.screenshotSize) : undefined);
+    message.comparisonMethod?.$case === "greyPixelDiff" &&
+      (obj.greyPixelDiff = message.comparisonMethod?.greyPixelDiff
+        ? TakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff.toJSON(message.comparisonMethod?.greyPixelDiff)
+        : undefined);
+    message.snapshotMode !== undefined &&
+      (obj.snapshotMode = takeAndCompareScreenshotRequest_SnapshotModeToJSON(message.snapshotMode));
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<TakeAndCompareScreenshotRequest>, I>>(
+    base?: I,
+  ): TakeAndCompareScreenshotRequest {
+    return TakeAndCompareScreenshotRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<TakeAndCompareScreenshotRequest>, I>>(
+    object: I,
+  ): TakeAndCompareScreenshotRequest {
+    const message = createBaseTakeAndCompareScreenshotRequest();
+    message.srcStoredSnapshot = object.srcStoredSnapshot ?? "";
+    message.cameraPosition = (object.cameraPosition !== undefined && object.cameraPosition !== null)
+      ? Vector3.fromPartial(object.cameraPosition)
+      : undefined;
+    message.cameraTarget = (object.cameraTarget !== undefined && object.cameraTarget !== null)
+      ? Vector3.fromPartial(object.cameraTarget)
+      : undefined;
+    message.screenshotSize = (object.screenshotSize !== undefined && object.screenshotSize !== null)
+      ? Vector2.fromPartial(object.screenshotSize)
+      : undefined;
+    if (
+      object.comparisonMethod?.$case === "greyPixelDiff" &&
+      object.comparisonMethod?.greyPixelDiff !== undefined &&
+      object.comparisonMethod?.greyPixelDiff !== null
+    ) {
+      message.comparisonMethod = {
+        $case: "greyPixelDiff",
+        greyPixelDiff: TakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff.fromPartial(
+          object.comparisonMethod.greyPixelDiff,
+        ),
+      };
+    }
+    message.snapshotMode = object.snapshotMode ?? 0;
+    return message;
+  }
+}
+
+function createBaseTakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff(): TakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff {
+  return {};
+}
+
+export namespace TakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff {
+  export function encode(
+    _: TakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    return writer;
+  }
+
+  export function decode(
+    input: _m0.Reader | Uint8Array,
+    length?: number,
+  ): TakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(_: any): TakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff {
+    return {};
+  }
+
+  export function toJSON(_: TakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff): unknown {
+    const obj: any = {};
+    return obj;
+  }
+
+  export function create<
+    I extends Exact<DeepPartial<TakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff>, I>,
+  >(base?: I): TakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff {
+    return TakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<
+    I extends Exact<DeepPartial<TakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff>, I>,
+  >(_: I): TakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff {
+    const message = createBaseTakeAndCompareScreenshotRequest_ComparisonMethodGreyPixelDiff();
+    return message;
+  }
+}
+
+function createBaseTakeAndCompareScreenshotResponse(): TakeAndCompareScreenshotResponse {
+  return { storedSnapshotFound: false, comparisonMethodResult: undefined };
+}
+
+export namespace TakeAndCompareScreenshotResponse {
+  export function encode(
+    message: TakeAndCompareScreenshotResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.storedSnapshotFound === true) {
+      writer.uint32(8).bool(message.storedSnapshotFound);
+    }
+    switch (message.comparisonMethodResult?.$case) {
+      case "greyPixelDiff":
+        TakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult.encode(
+          message.comparisonMethodResult.greyPixelDiff,
+          writer.uint32(18).fork(),
+        ).ldelim();
+        break;
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): TakeAndCompareScreenshotResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTakeAndCompareScreenshotResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.storedSnapshotFound = reader.bool();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.comparisonMethodResult = {
+            $case: "greyPixelDiff",
+            greyPixelDiff: TakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult.decode(
+              reader,
+              reader.uint32(),
+            ),
+          };
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): TakeAndCompareScreenshotResponse {
+    return {
+      storedSnapshotFound: isSet(object.storedSnapshotFound) ? Boolean(object.storedSnapshotFound) : false,
+      comparisonMethodResult: isSet(object.greyPixelDiff)
+        ? {
+          $case: "greyPixelDiff",
+          greyPixelDiff: TakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult.fromJSON(
+            object.greyPixelDiff,
+          ),
+        }
+        : undefined,
+    };
+  }
+
+  export function toJSON(message: TakeAndCompareScreenshotResponse): unknown {
+    const obj: any = {};
+    message.storedSnapshotFound !== undefined && (obj.storedSnapshotFound = message.storedSnapshotFound);
+    message.comparisonMethodResult?.$case === "greyPixelDiff" &&
+      (obj.greyPixelDiff = message.comparisonMethodResult?.greyPixelDiff
+        ? TakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult.toJSON(
+          message.comparisonMethodResult?.greyPixelDiff,
+        )
+        : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<TakeAndCompareScreenshotResponse>, I>>(
+    base?: I,
+  ): TakeAndCompareScreenshotResponse {
+    return TakeAndCompareScreenshotResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<TakeAndCompareScreenshotResponse>, I>>(
+    object: I,
+  ): TakeAndCompareScreenshotResponse {
+    const message = createBaseTakeAndCompareScreenshotResponse();
+    message.storedSnapshotFound = object.storedSnapshotFound ?? false;
+    if (
+      object.comparisonMethodResult?.$case === "greyPixelDiff" &&
+      object.comparisonMethodResult?.greyPixelDiff !== undefined &&
+      object.comparisonMethodResult?.greyPixelDiff !== null
+    ) {
+      message.comparisonMethodResult = {
+        $case: "greyPixelDiff",
+        greyPixelDiff: TakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult.fromPartial(
+          object.comparisonMethodResult.greyPixelDiff,
+        ),
+      };
+    }
+    return message;
+  }
+}
+
+function createBaseTakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult(): TakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult {
+  return { similarity: 0 };
+}
+
+export namespace TakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult {
+  export function encode(
+    message: TakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.similarity !== 0) {
+      writer.uint32(13).float(message.similarity);
+    }
+    return writer;
+  }
+
+  export function decode(
+    input: _m0.Reader | Uint8Array,
+    length?: number,
+  ): TakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 13) {
+            break;
+          }
+
+          message.similarity = reader.float();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): TakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult {
+    return { similarity: isSet(object.similarity) ? Number(object.similarity) : 0 };
+  }
+
+  export function toJSON(message: TakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult): unknown {
+    const obj: any = {};
+    message.similarity !== undefined && (obj.similarity = message.similarity);
+    return obj;
+  }
+
+  export function create<
+    I extends Exact<DeepPartial<TakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult>, I>,
+  >(base?: I): TakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult {
+    return TakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<
+    I extends Exact<DeepPartial<TakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult>, I>,
+  >(object: I): TakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult {
+    const message = createBaseTakeAndCompareScreenshotResponse_ComparisonMethodGreyPixelDiffResult();
+    message.similarity = object.similarity ?? 0;
+    return message;
+  }
+}
+
 function createBaseTestResult(): TestResult {
   return { name: "", ok: false, error: undefined, stack: undefined, totalFrames: 0, totalTime: 0 };
 }
@@ -741,6 +1239,19 @@ export const TestingServiceDefinition = {
       responseStream: false,
       options: {},
     },
+    /**
+     * @internal
+     * take a screenshot and compare it with a stored one
+     *  it hides the explorer hud and ui, primary player and players of avatar scenes
+     */
+    takeAndCompareScreenshot: {
+      name: "TakeAndCompareScreenshot",
+      requestType: TakeAndCompareScreenshotRequest,
+      requestStream: false,
+      responseType: TakeAndCompareScreenshotResponse,
+      responseStream: false,
+      options: {},
+    },
   },
 } as const;