@dcl/protocol 1.0.0-8879141840.commit-9fe6ed4 → 1.0.0-9085309459.commit-26cae18

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;
 

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

@@ -9,6 +9,13 @@ export enum AvatarAnchorPointType {
   AAPT_NAME_TAG = 1,
   AAPT_LEFT_HAND = 2,
   AAPT_RIGHT_HAND = 3,
+  AAPT_HEAD = 4,
+  AAPT_BACK = 5,
+  AAPT_LEFT_FOOT = 6,
+  AAPT_RIGHT_FOOT = 7,
+  AAPT_LEFT_SHOULDER = 8,
+  AAPT_RIGHT_SHOULDER = 9,
+  AAPT_HIP = 10,
   UNRECOGNIZED = -1,
 }
 
@@ -26,6 +33,27 @@ export function avatarAnchorPointTypeFromJSON(object: any): AvatarAnchorPointTyp
     case 3:
     case "AAPT_RIGHT_HAND":
       return AvatarAnchorPointType.AAPT_RIGHT_HAND;
+    case 4:
+    case "AAPT_HEAD":
+      return AvatarAnchorPointType.AAPT_HEAD;
+    case 5:
+    case "AAPT_BACK":
+      return AvatarAnchorPointType.AAPT_BACK;
+    case 6:
+    case "AAPT_LEFT_FOOT":
+      return AvatarAnchorPointType.AAPT_LEFT_FOOT;
+    case 7:
+    case "AAPT_RIGHT_FOOT":
+      return AvatarAnchorPointType.AAPT_RIGHT_FOOT;
+    case 8:
+    case "AAPT_LEFT_SHOULDER":
+      return AvatarAnchorPointType.AAPT_LEFT_SHOULDER;
+    case 9:
+    case "AAPT_RIGHT_SHOULDER":
+      return AvatarAnchorPointType.AAPT_RIGHT_SHOULDER;
+    case 10:
+    case "AAPT_HIP":
+      return AvatarAnchorPointType.AAPT_HIP;
     case -1:
     case "UNRECOGNIZED":
     default:
@@ -43,6 +71,20 @@ export function avatarAnchorPointTypeToJSON(object: AvatarAnchorPointType): stri
       return "AAPT_LEFT_HAND";
     case AvatarAnchorPointType.AAPT_RIGHT_HAND:
       return "AAPT_RIGHT_HAND";
+    case AvatarAnchorPointType.AAPT_HEAD:
+      return "AAPT_HEAD";
+    case AvatarAnchorPointType.AAPT_BACK:
+      return "AAPT_BACK";
+    case AvatarAnchorPointType.AAPT_LEFT_FOOT:
+      return "AAPT_LEFT_FOOT";
+    case AvatarAnchorPointType.AAPT_RIGHT_FOOT:
+      return "AAPT_RIGHT_FOOT";
+    case AvatarAnchorPointType.AAPT_LEFT_SHOULDER:
+      return "AAPT_LEFT_SHOULDER";
+    case AvatarAnchorPointType.AAPT_RIGHT_SHOULDER:
+      return "AAPT_RIGHT_SHOULDER";
+    case AvatarAnchorPointType.AAPT_HIP:
+      return "AAPT_HIP";
     case AvatarAnchorPointType.UNRECOGNIZED:
     default:
       return "UNRECOGNIZED";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl/protocol",
-  "version": "1.0.0-8879141840.commit-9fe6ed4",
+  "version": "1.0.0-9085309459.commit-26cae18",
   "description": "",
   "repository": "decentraland/protocol.git",
   "homepage": "https://github.com/decentraland/protocol#readme",
@@ -29,5 +29,5 @@
     "out-js",
     "public"
   ],
-  "commit": "9fe6ed46e27d16a2b1056160fb53fc86b3301a07"
+  "commit": "26cae184e51f903626d8aaffbc0ff793f583a64b"
 }

package/proto/decentraland/kernel/apis/testing.proto

@@ -1,6 +1,8 @@
 syntax = "proto3";
 package decentraland.kernel.apis;
 
+import "decentraland/common/vectors.proto";
+
 service TestingService {
   // sends a test result to the test runner
   rpc LogTestResult(TestResult) returns (TestResultResponse) {}
@@ -8,9 +10,54 @@ service TestingService {
   rpc Plan(TestPlan) returns (TestPlanResponse) {}
   // sets the camera position and rotation in the engine
   rpc SetCameraTransform (SetCameraTransformTestCommand) returns (SetCameraTransformTestCommandResponse) {}
+  // @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
+  rpc TakeAndCompareScreenshot (TakeAndCompareScreenshotRequest) returns (TakeAndCompareScreenshotResponse) {}
+}
+
+// @internal
+message TakeAndCompareScreenshotRequest {
+  // the source path in the scene where the screenshot is stored, 
+  //  the snapshot taken is compared with the stored one
+  string src_stored_snapshot = 1;
+  // the camera position where is set before and while taking the screenshot, relative to base scene
+  decentraland.common.Vector3 camera_position = 2;
+  // the camera position where is target to before and while taking the screenshot, relative to base scene
+  decentraland.common.Vector3 camera_target = 3;
+  // width x height screenshot size
+  decentraland.common.Vector2 screenshot_size = 4;
+  // comparison method choice and parameters values
+  oneof comparison_method {
+    ComparisonMethodGreyPixelDiff grey_pixel_diff = 5;
+  }
+
+  message ComparisonMethodGreyPixelDiff {}
+  
+  enum SnapshotMode {
+    // only visible 3d scene and ui scene
+    SM_3D_AND_UI = 0;
+    // only visible 3d scene
+    SM_3D_ONLY = 1;
+    // only visible ui scene
+    SM_UI_ONLY = 2;
+  };
+  SnapshotMode snapshot_mode = 6;
 }
 
 
+// @internal
+message TakeAndCompareScreenshotResponse {
+  bool stored_snapshot_found = 1;
+  oneof comparison_method_result {
+    ComparisonMethodGreyPixelDiffResult grey_pixel_diff = 2;
+  }
+
+  message ComparisonMethodGreyPixelDiffResult {
+    float similarity = 1;
+  }
+}
+
 message TestResult {
     string name = 1;
     bool ok = 2;

package/proto/decentraland/sdk/components/avatar_attach.proto

@@ -25,4 +25,11 @@ enum AvatarAnchorPointType {
   AAPT_NAME_TAG = 1;
   AAPT_LEFT_HAND = 2;
   AAPT_RIGHT_HAND = 3;
+  AAPT_HEAD = 4;
+  AAPT_BACK = 5;
+  AAPT_LEFT_FOOT = 6;
+  AAPT_RIGHT_FOOT = 7;
+  AAPT_LEFT_SHOULDER = 8;
+  AAPT_RIGHT_SHOULDER = 9;
+  AAPT_HIP = 10;
 }