@dcl/protocol 1.0.0-3583035976.commit-35d616d → 1.0.0-3603890942.commit-44633cf

package/out-ts/decentraland/renderer/kernel_services/analytics.gen.ts

@@ -0,0 +1,974 @@
+/* eslint-disable */
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "decentraland.renderer.kernel_services";
+
+export interface PerformanceReportRequest {
+  samples: string;
+  fpsIsCapped: boolean;
+  hiccupsInThousandFrames: number;
+  hiccupsTime: number;
+  totalTime: number;
+  gltfInProgress: number;
+  gltfFailed: number;
+  gltfCancelled: number;
+  gltfLoaded: number;
+  abInProgress: number;
+  abFailed: number;
+  abCancelled: number;
+  abLoaded: number;
+  gltfTexturesLoaded: number;
+  abTexturesLoaded: number;
+  promiseTexturesLoaded: number;
+  enqueuedMessages: number;
+  processedMessages: number;
+  playerCount: number;
+  loadRadius: number;
+  /** int32 * */
+  drawCalls: number;
+  /** long, in total bytes * */
+  memoryReserved: number;
+  /** long, in total bytes * */
+  memoryUsage: number;
+  /** long, in total bytes, its the sum of all GCAllocs per frame over 1000 frames * */
+  totalGcAlloc: number;
+  sceneScores: { [key: number]: number };
+}
+
+export interface PerformanceReportRequest_SceneScoresEntry {
+  key: number;
+  value: number;
+}
+
+export interface PerformanceReportResponse {
+}
+
+export interface SystemInfoReportRequest {
+  graphicsDeviceName: string;
+  graphicsDeviceVersion: string;
+  graphicsMemorySize: number;
+  processorType: string;
+  processorCount: number;
+  systemMemorySize: number;
+  /** TODO: remove useBinaryTransform after ECS7 is fully in prod */
+  useBinaryTransform: boolean;
+}
+
+export interface SystemInfoReportResponse {
+}
+
+export interface AnalyticProperty {
+  key: string;
+  value: string;
+}
+
+export interface AnalyticsEventRequest {
+  eventName: string;
+  properties: AnalyticProperty[];
+}
+
+export interface AnalyticsEventResponse {
+}
+
+export interface DelightedSurveyRequest {
+  enabled: boolean;
+}
+
+export interface DelightedSurveyResponse {
+}
+
+function createBasePerformanceReportRequest(): PerformanceReportRequest {
+  return {
+    samples: "",
+    fpsIsCapped: false,
+    hiccupsInThousandFrames: 0,
+    hiccupsTime: 0,
+    totalTime: 0,
+    gltfInProgress: 0,
+    gltfFailed: 0,
+    gltfCancelled: 0,
+    gltfLoaded: 0,
+    abInProgress: 0,
+    abFailed: 0,
+    abCancelled: 0,
+    abLoaded: 0,
+    gltfTexturesLoaded: 0,
+    abTexturesLoaded: 0,
+    promiseTexturesLoaded: 0,
+    enqueuedMessages: 0,
+    processedMessages: 0,
+    playerCount: 0,
+    loadRadius: 0,
+    drawCalls: 0,
+    memoryReserved: 0,
+    memoryUsage: 0,
+    totalGcAlloc: 0,
+    sceneScores: {},
+  };
+}
+
+export const PerformanceReportRequest = {
+  encode(message: PerformanceReportRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.samples !== "") {
+      writer.uint32(10).string(message.samples);
+    }
+    if (message.fpsIsCapped === true) {
+      writer.uint32(16).bool(message.fpsIsCapped);
+    }
+    if (message.hiccupsInThousandFrames !== 0) {
+      writer.uint32(29).sfixed32(message.hiccupsInThousandFrames);
+    }
+    if (message.hiccupsTime !== 0) {
+      writer.uint32(37).float(message.hiccupsTime);
+    }
+    if (message.totalTime !== 0) {
+      writer.uint32(45).float(message.totalTime);
+    }
+    if (message.gltfInProgress !== 0) {
+      writer.uint32(53).sfixed32(message.gltfInProgress);
+    }
+    if (message.gltfFailed !== 0) {
+      writer.uint32(61).sfixed32(message.gltfFailed);
+    }
+    if (message.gltfCancelled !== 0) {
+      writer.uint32(69).sfixed32(message.gltfCancelled);
+    }
+    if (message.gltfLoaded !== 0) {
+      writer.uint32(77).sfixed32(message.gltfLoaded);
+    }
+    if (message.abInProgress !== 0) {
+      writer.uint32(85).sfixed32(message.abInProgress);
+    }
+    if (message.abFailed !== 0) {
+      writer.uint32(93).sfixed32(message.abFailed);
+    }
+    if (message.abCancelled !== 0) {
+      writer.uint32(101).sfixed32(message.abCancelled);
+    }
+    if (message.abLoaded !== 0) {
+      writer.uint32(109).sfixed32(message.abLoaded);
+    }
+    if (message.gltfTexturesLoaded !== 0) {
+      writer.uint32(117).sfixed32(message.gltfTexturesLoaded);
+    }
+    if (message.abTexturesLoaded !== 0) {
+      writer.uint32(125).sfixed32(message.abTexturesLoaded);
+    }
+    if (message.promiseTexturesLoaded !== 0) {
+      writer.uint32(133).sfixed32(message.promiseTexturesLoaded);
+    }
+    if (message.enqueuedMessages !== 0) {
+      writer.uint32(141).sfixed32(message.enqueuedMessages);
+    }
+    if (message.processedMessages !== 0) {
+      writer.uint32(149).sfixed32(message.processedMessages);
+    }
+    if (message.playerCount !== 0) {
+      writer.uint32(157).sfixed32(message.playerCount);
+    }
+    if (message.loadRadius !== 0) {
+      writer.uint32(165).sfixed32(message.loadRadius);
+    }
+    if (message.drawCalls !== 0) {
+      writer.uint32(173).sfixed32(message.drawCalls);
+    }
+    if (message.memoryReserved !== 0) {
+      writer.uint32(177).sfixed64(message.memoryReserved);
+    }
+    if (message.memoryUsage !== 0) {
+      writer.uint32(185).sfixed64(message.memoryUsage);
+    }
+    if (message.totalGcAlloc !== 0) {
+      writer.uint32(193).sfixed64(message.totalGcAlloc);
+    }
+    Object.entries(message.sceneScores).forEach(([key, value]) => {
+      PerformanceReportRequest_SceneScoresEntry.encode({ key: key as any, value }, writer.uint32(202).fork()).ldelim();
+    });
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PerformanceReportRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePerformanceReportRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.samples = reader.string();
+          break;
+        case 2:
+          message.fpsIsCapped = reader.bool();
+          break;
+        case 3:
+          message.hiccupsInThousandFrames = reader.sfixed32();
+          break;
+        case 4:
+          message.hiccupsTime = reader.float();
+          break;
+        case 5:
+          message.totalTime = reader.float();
+          break;
+        case 6:
+          message.gltfInProgress = reader.sfixed32();
+          break;
+        case 7:
+          message.gltfFailed = reader.sfixed32();
+          break;
+        case 8:
+          message.gltfCancelled = reader.sfixed32();
+          break;
+        case 9:
+          message.gltfLoaded = reader.sfixed32();
+          break;
+        case 10:
+          message.abInProgress = reader.sfixed32();
+          break;
+        case 11:
+          message.abFailed = reader.sfixed32();
+          break;
+        case 12:
+          message.abCancelled = reader.sfixed32();
+          break;
+        case 13:
+          message.abLoaded = reader.sfixed32();
+          break;
+        case 14:
+          message.gltfTexturesLoaded = reader.sfixed32();
+          break;
+        case 15:
+          message.abTexturesLoaded = reader.sfixed32();
+          break;
+        case 16:
+          message.promiseTexturesLoaded = reader.sfixed32();
+          break;
+        case 17:
+          message.enqueuedMessages = reader.sfixed32();
+          break;
+        case 18:
+          message.processedMessages = reader.sfixed32();
+          break;
+        case 19:
+          message.playerCount = reader.sfixed32();
+          break;
+        case 20:
+          message.loadRadius = reader.sfixed32();
+          break;
+        case 21:
+          message.drawCalls = reader.sfixed32();
+          break;
+        case 22:
+          message.memoryReserved = longToNumber(reader.sfixed64() as Long);
+          break;
+        case 23:
+          message.memoryUsage = longToNumber(reader.sfixed64() as Long);
+          break;
+        case 24:
+          message.totalGcAlloc = longToNumber(reader.sfixed64() as Long);
+          break;
+        case 25:
+          const entry25 = PerformanceReportRequest_SceneScoresEntry.decode(reader, reader.uint32());
+          if (entry25.value !== undefined) {
+            message.sceneScores[entry25.key] = entry25.value;
+          }
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PerformanceReportRequest {
+    return {
+      samples: isSet(object.samples) ? String(object.samples) : "",
+      fpsIsCapped: isSet(object.fpsIsCapped) ? Boolean(object.fpsIsCapped) : false,
+      hiccupsInThousandFrames: isSet(object.hiccupsInThousandFrames) ? Number(object.hiccupsInThousandFrames) : 0,
+      hiccupsTime: isSet(object.hiccupsTime) ? Number(object.hiccupsTime) : 0,
+      totalTime: isSet(object.totalTime) ? Number(object.totalTime) : 0,
+      gltfInProgress: isSet(object.gltfInProgress) ? Number(object.gltfInProgress) : 0,
+      gltfFailed: isSet(object.gltfFailed) ? Number(object.gltfFailed) : 0,
+      gltfCancelled: isSet(object.gltfCancelled) ? Number(object.gltfCancelled) : 0,
+      gltfLoaded: isSet(object.gltfLoaded) ? Number(object.gltfLoaded) : 0,
+      abInProgress: isSet(object.abInProgress) ? Number(object.abInProgress) : 0,
+      abFailed: isSet(object.abFailed) ? Number(object.abFailed) : 0,
+      abCancelled: isSet(object.abCancelled) ? Number(object.abCancelled) : 0,
+      abLoaded: isSet(object.abLoaded) ? Number(object.abLoaded) : 0,
+      gltfTexturesLoaded: isSet(object.gltfTexturesLoaded) ? Number(object.gltfTexturesLoaded) : 0,
+      abTexturesLoaded: isSet(object.abTexturesLoaded) ? Number(object.abTexturesLoaded) : 0,
+      promiseTexturesLoaded: isSet(object.promiseTexturesLoaded) ? Number(object.promiseTexturesLoaded) : 0,
+      enqueuedMessages: isSet(object.enqueuedMessages) ? Number(object.enqueuedMessages) : 0,
+      processedMessages: isSet(object.processedMessages) ? Number(object.processedMessages) : 0,
+      playerCount: isSet(object.playerCount) ? Number(object.playerCount) : 0,
+      loadRadius: isSet(object.loadRadius) ? Number(object.loadRadius) : 0,
+      drawCalls: isSet(object.drawCalls) ? Number(object.drawCalls) : 0,
+      memoryReserved: isSet(object.memoryReserved) ? Number(object.memoryReserved) : 0,
+      memoryUsage: isSet(object.memoryUsage) ? Number(object.memoryUsage) : 0,
+      totalGcAlloc: isSet(object.totalGcAlloc) ? Number(object.totalGcAlloc) : 0,
+      sceneScores: isObject(object.sceneScores)
+        ? Object.entries(object.sceneScores).reduce<{ [key: number]: number }>((acc, [key, value]) => {
+          acc[Number(key)] = Number(value);
+          return acc;
+        }, {})
+        : {},
+    };
+  },
+
+  toJSON(message: PerformanceReportRequest): unknown {
+    const obj: any = {};
+    message.samples !== undefined && (obj.samples = message.samples);
+    message.fpsIsCapped !== undefined && (obj.fpsIsCapped = message.fpsIsCapped);
+    message.hiccupsInThousandFrames !== undefined &&
+      (obj.hiccupsInThousandFrames = Math.round(message.hiccupsInThousandFrames));
+    message.hiccupsTime !== undefined && (obj.hiccupsTime = message.hiccupsTime);
+    message.totalTime !== undefined && (obj.totalTime = message.totalTime);
+    message.gltfInProgress !== undefined && (obj.gltfInProgress = Math.round(message.gltfInProgress));
+    message.gltfFailed !== undefined && (obj.gltfFailed = Math.round(message.gltfFailed));
+    message.gltfCancelled !== undefined && (obj.gltfCancelled = Math.round(message.gltfCancelled));
+    message.gltfLoaded !== undefined && (obj.gltfLoaded = Math.round(message.gltfLoaded));
+    message.abInProgress !== undefined && (obj.abInProgress = Math.round(message.abInProgress));
+    message.abFailed !== undefined && (obj.abFailed = Math.round(message.abFailed));
+    message.abCancelled !== undefined && (obj.abCancelled = Math.round(message.abCancelled));
+    message.abLoaded !== undefined && (obj.abLoaded = Math.round(message.abLoaded));
+    message.gltfTexturesLoaded !== undefined && (obj.gltfTexturesLoaded = Math.round(message.gltfTexturesLoaded));
+    message.abTexturesLoaded !== undefined && (obj.abTexturesLoaded = Math.round(message.abTexturesLoaded));
+    message.promiseTexturesLoaded !== undefined &&
+      (obj.promiseTexturesLoaded = Math.round(message.promiseTexturesLoaded));
+    message.enqueuedMessages !== undefined && (obj.enqueuedMessages = Math.round(message.enqueuedMessages));
+    message.processedMessages !== undefined && (obj.processedMessages = Math.round(message.processedMessages));
+    message.playerCount !== undefined && (obj.playerCount = Math.round(message.playerCount));
+    message.loadRadius !== undefined && (obj.loadRadius = Math.round(message.loadRadius));
+    message.drawCalls !== undefined && (obj.drawCalls = Math.round(message.drawCalls));
+    message.memoryReserved !== undefined && (obj.memoryReserved = Math.round(message.memoryReserved));
+    message.memoryUsage !== undefined && (obj.memoryUsage = Math.round(message.memoryUsage));
+    message.totalGcAlloc !== undefined && (obj.totalGcAlloc = Math.round(message.totalGcAlloc));
+    obj.sceneScores = {};
+    if (message.sceneScores) {
+      Object.entries(message.sceneScores).forEach(([k, v]) => {
+        obj.sceneScores[k] = Math.round(v);
+      });
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PerformanceReportRequest>, I>>(object: I): PerformanceReportRequest {
+    const message = createBasePerformanceReportRequest();
+    message.samples = object.samples ?? "";
+    message.fpsIsCapped = object.fpsIsCapped ?? false;
+    message.hiccupsInThousandFrames = object.hiccupsInThousandFrames ?? 0;
+    message.hiccupsTime = object.hiccupsTime ?? 0;
+    message.totalTime = object.totalTime ?? 0;
+    message.gltfInProgress = object.gltfInProgress ?? 0;
+    message.gltfFailed = object.gltfFailed ?? 0;
+    message.gltfCancelled = object.gltfCancelled ?? 0;
+    message.gltfLoaded = object.gltfLoaded ?? 0;
+    message.abInProgress = object.abInProgress ?? 0;
+    message.abFailed = object.abFailed ?? 0;
+    message.abCancelled = object.abCancelled ?? 0;
+    message.abLoaded = object.abLoaded ?? 0;
+    message.gltfTexturesLoaded = object.gltfTexturesLoaded ?? 0;
+    message.abTexturesLoaded = object.abTexturesLoaded ?? 0;
+    message.promiseTexturesLoaded = object.promiseTexturesLoaded ?? 0;
+    message.enqueuedMessages = object.enqueuedMessages ?? 0;
+    message.processedMessages = object.processedMessages ?? 0;
+    message.playerCount = object.playerCount ?? 0;
+    message.loadRadius = object.loadRadius ?? 0;
+    message.drawCalls = object.drawCalls ?? 0;
+    message.memoryReserved = object.memoryReserved ?? 0;
+    message.memoryUsage = object.memoryUsage ?? 0;
+    message.totalGcAlloc = object.totalGcAlloc ?? 0;
+    message.sceneScores = Object.entries(object.sceneScores ?? {}).reduce<{ [key: number]: number }>(
+      (acc, [key, value]) => {
+        if (value !== undefined) {
+          acc[Number(key)] = Number(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    return message;
+  },
+};
+
+function createBasePerformanceReportRequest_SceneScoresEntry(): PerformanceReportRequest_SceneScoresEntry {
+  return { key: 0, value: 0 };
+}
+
+export const PerformanceReportRequest_SceneScoresEntry = {
+  encode(message: PerformanceReportRequest_SceneScoresEntry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.key !== 0) {
+      writer.uint32(9).sfixed64(message.key);
+    }
+    if (message.value !== 0) {
+      writer.uint32(17).sfixed64(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PerformanceReportRequest_SceneScoresEntry {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePerformanceReportRequest_SceneScoresEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.key = longToNumber(reader.sfixed64() as Long);
+          break;
+        case 2:
+          message.value = longToNumber(reader.sfixed64() as Long);
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PerformanceReportRequest_SceneScoresEntry {
+    return { key: isSet(object.key) ? Number(object.key) : 0, value: isSet(object.value) ? Number(object.value) : 0 };
+  },
+
+  toJSON(message: PerformanceReportRequest_SceneScoresEntry): unknown {
+    const obj: any = {};
+    message.key !== undefined && (obj.key = Math.round(message.key));
+    message.value !== undefined && (obj.value = Math.round(message.value));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PerformanceReportRequest_SceneScoresEntry>, I>>(
+    object: I,
+  ): PerformanceReportRequest_SceneScoresEntry {
+    const message = createBasePerformanceReportRequest_SceneScoresEntry();
+    message.key = object.key ?? 0;
+    message.value = object.value ?? 0;
+    return message;
+  },
+};
+
+function createBasePerformanceReportResponse(): PerformanceReportResponse {
+  return {};
+}
+
+export const PerformanceReportResponse = {
+  encode(_: PerformanceReportResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PerformanceReportResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePerformanceReportResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(_: any): PerformanceReportResponse {
+    return {};
+  },
+
+  toJSON(_: PerformanceReportResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PerformanceReportResponse>, I>>(_: I): PerformanceReportResponse {
+    const message = createBasePerformanceReportResponse();
+    return message;
+  },
+};
+
+function createBaseSystemInfoReportRequest(): SystemInfoReportRequest {
+  return {
+    graphicsDeviceName: "",
+    graphicsDeviceVersion: "",
+    graphicsMemorySize: 0,
+    processorType: "",
+    processorCount: 0,
+    systemMemorySize: 0,
+    useBinaryTransform: false,
+  };
+}
+
+export const SystemInfoReportRequest = {
+  encode(message: SystemInfoReportRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.graphicsDeviceName !== "") {
+      writer.uint32(10).string(message.graphicsDeviceName);
+    }
+    if (message.graphicsDeviceVersion !== "") {
+      writer.uint32(18).string(message.graphicsDeviceVersion);
+    }
+    if (message.graphicsMemorySize !== 0) {
+      writer.uint32(29).fixed32(message.graphicsMemorySize);
+    }
+    if (message.processorType !== "") {
+      writer.uint32(34).string(message.processorType);
+    }
+    if (message.processorCount !== 0) {
+      writer.uint32(45).fixed32(message.processorCount);
+    }
+    if (message.systemMemorySize !== 0) {
+      writer.uint32(53).fixed32(message.systemMemorySize);
+    }
+    if (message.useBinaryTransform === true) {
+      writer.uint32(56).bool(message.useBinaryTransform);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SystemInfoReportRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSystemInfoReportRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.graphicsDeviceName = reader.string();
+          break;
+        case 2:
+          message.graphicsDeviceVersion = reader.string();
+          break;
+        case 3:
+          message.graphicsMemorySize = reader.fixed32();
+          break;
+        case 4:
+          message.processorType = reader.string();
+          break;
+        case 5:
+          message.processorCount = reader.fixed32();
+          break;
+        case 6:
+          message.systemMemorySize = reader.fixed32();
+          break;
+        case 7:
+          message.useBinaryTransform = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SystemInfoReportRequest {
+    return {
+      graphicsDeviceName: isSet(object.graphicsDeviceName) ? String(object.graphicsDeviceName) : "",
+      graphicsDeviceVersion: isSet(object.graphicsDeviceVersion) ? String(object.graphicsDeviceVersion) : "",
+      graphicsMemorySize: isSet(object.graphicsMemorySize) ? Number(object.graphicsMemorySize) : 0,
+      processorType: isSet(object.processorType) ? String(object.processorType) : "",
+      processorCount: isSet(object.processorCount) ? Number(object.processorCount) : 0,
+      systemMemorySize: isSet(object.systemMemorySize) ? Number(object.systemMemorySize) : 0,
+      useBinaryTransform: isSet(object.useBinaryTransform) ? Boolean(object.useBinaryTransform) : false,
+    };
+  },
+
+  toJSON(message: SystemInfoReportRequest): unknown {
+    const obj: any = {};
+    message.graphicsDeviceName !== undefined && (obj.graphicsDeviceName = message.graphicsDeviceName);
+    message.graphicsDeviceVersion !== undefined && (obj.graphicsDeviceVersion = message.graphicsDeviceVersion);
+    message.graphicsMemorySize !== undefined && (obj.graphicsMemorySize = Math.round(message.graphicsMemorySize));
+    message.processorType !== undefined && (obj.processorType = message.processorType);
+    message.processorCount !== undefined && (obj.processorCount = Math.round(message.processorCount));
+    message.systemMemorySize !== undefined && (obj.systemMemorySize = Math.round(message.systemMemorySize));
+    message.useBinaryTransform !== undefined && (obj.useBinaryTransform = message.useBinaryTransform);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<SystemInfoReportRequest>, I>>(object: I): SystemInfoReportRequest {
+    const message = createBaseSystemInfoReportRequest();
+    message.graphicsDeviceName = object.graphicsDeviceName ?? "";
+    message.graphicsDeviceVersion = object.graphicsDeviceVersion ?? "";
+    message.graphicsMemorySize = object.graphicsMemorySize ?? 0;
+    message.processorType = object.processorType ?? "";
+    message.processorCount = object.processorCount ?? 0;
+    message.systemMemorySize = object.systemMemorySize ?? 0;
+    message.useBinaryTransform = object.useBinaryTransform ?? false;
+    return message;
+  },
+};
+
+function createBaseSystemInfoReportResponse(): SystemInfoReportResponse {
+  return {};
+}
+
+export const SystemInfoReportResponse = {
+  encode(_: SystemInfoReportResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): SystemInfoReportResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSystemInfoReportResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(_: any): SystemInfoReportResponse {
+    return {};
+  },
+
+  toJSON(_: SystemInfoReportResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<SystemInfoReportResponse>, I>>(_: I): SystemInfoReportResponse {
+    const message = createBaseSystemInfoReportResponse();
+    return message;
+  },
+};
+
+function createBaseAnalyticProperty(): AnalyticProperty {
+  return { key: "", value: "" };
+}
+
+export const AnalyticProperty = {
+  encode(message: AnalyticProperty, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): AnalyticProperty {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAnalyticProperty();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.key = reader.string();
+          break;
+        case 2:
+          message.value = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): AnalyticProperty {
+    return { key: isSet(object.key) ? String(object.key) : "", value: isSet(object.value) ? String(object.value) : "" };
+  },
+
+  toJSON(message: AnalyticProperty): unknown {
+    const obj: any = {};
+    message.key !== undefined && (obj.key = message.key);
+    message.value !== undefined && (obj.value = message.value);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<AnalyticProperty>, I>>(object: I): AnalyticProperty {
+    const message = createBaseAnalyticProperty();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  },
+};
+
+function createBaseAnalyticsEventRequest(): AnalyticsEventRequest {
+  return { eventName: "", properties: [] };
+}
+
+export const AnalyticsEventRequest = {
+  encode(message: AnalyticsEventRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.eventName !== "") {
+      writer.uint32(10).string(message.eventName);
+    }
+    for (const v of message.properties) {
+      AnalyticProperty.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): AnalyticsEventRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAnalyticsEventRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.eventName = reader.string();
+          break;
+        case 2:
+          message.properties.push(AnalyticProperty.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): AnalyticsEventRequest {
+    return {
+      eventName: isSet(object.eventName) ? String(object.eventName) : "",
+      properties: Array.isArray(object?.properties)
+        ? object.properties.map((e: any) => AnalyticProperty.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: AnalyticsEventRequest): unknown {
+    const obj: any = {};
+    message.eventName !== undefined && (obj.eventName = message.eventName);
+    if (message.properties) {
+      obj.properties = message.properties.map((e) => e ? AnalyticProperty.toJSON(e) : undefined);
+    } else {
+      obj.properties = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<AnalyticsEventRequest>, I>>(object: I): AnalyticsEventRequest {
+    const message = createBaseAnalyticsEventRequest();
+    message.eventName = object.eventName ?? "";
+    message.properties = object.properties?.map((e) => AnalyticProperty.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseAnalyticsEventResponse(): AnalyticsEventResponse {
+  return {};
+}
+
+export const AnalyticsEventResponse = {
+  encode(_: AnalyticsEventResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): AnalyticsEventResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseAnalyticsEventResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(_: any): AnalyticsEventResponse {
+    return {};
+  },
+
+  toJSON(_: AnalyticsEventResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<AnalyticsEventResponse>, I>>(_: I): AnalyticsEventResponse {
+    const message = createBaseAnalyticsEventResponse();
+    return message;
+  },
+};
+
+function createBaseDelightedSurveyRequest(): DelightedSurveyRequest {
+  return { enabled: false };
+}
+
+export const DelightedSurveyRequest = {
+  encode(message: DelightedSurveyRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.enabled === true) {
+      writer.uint32(8).bool(message.enabled);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): DelightedSurveyRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDelightedSurveyRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.enabled = reader.bool();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DelightedSurveyRequest {
+    return { enabled: isSet(object.enabled) ? Boolean(object.enabled) : false };
+  },
+
+  toJSON(message: DelightedSurveyRequest): unknown {
+    const obj: any = {};
+    message.enabled !== undefined && (obj.enabled = message.enabled);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<DelightedSurveyRequest>, I>>(object: I): DelightedSurveyRequest {
+    const message = createBaseDelightedSurveyRequest();
+    message.enabled = object.enabled ?? false;
+    return message;
+  },
+};
+
+function createBaseDelightedSurveyResponse(): DelightedSurveyResponse {
+  return {};
+}
+
+export const DelightedSurveyResponse = {
+  encode(_: DelightedSurveyResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): DelightedSurveyResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDelightedSurveyResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(_: any): DelightedSurveyResponse {
+    return {};
+  },
+
+  toJSON(_: DelightedSurveyResponse): unknown {
+    const obj: any = {};
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<DelightedSurveyResponse>, I>>(_: I): DelightedSurveyResponse {
+    const message = createBaseDelightedSurveyResponse();
+    return message;
+  },
+};
+
+export type AnalyticsKernelServiceDefinition = typeof AnalyticsKernelServiceDefinition;
+export const AnalyticsKernelServiceDefinition = {
+  name: "AnalyticsKernelService",
+  fullName: "decentraland.renderer.kernel_services.AnalyticsKernelService",
+  methods: {
+    performanceReport: {
+      name: "PerformanceReport",
+      requestType: PerformanceReportRequest,
+      requestStream: false,
+      responseType: PerformanceReportResponse,
+      responseStream: false,
+      options: {},
+    },
+    systemInfoReport: {
+      name: "SystemInfoReport",
+      requestType: SystemInfoReportRequest,
+      requestStream: false,
+      responseType: SystemInfoReportResponse,
+      responseStream: false,
+      options: {},
+    },
+    analyticsEvent: {
+      name: "AnalyticsEvent",
+      requestType: AnalyticsEventRequest,
+      requestStream: false,
+      responseType: AnalyticsEventResponse,
+      responseStream: false,
+      options: {},
+    },
+    setDelightedSurveyEnabled: {
+      name: "SetDelightedSurveyEnabled",
+      requestType: DelightedSurveyRequest,
+      requestStream: false,
+      responseType: DelightedSurveyResponse,
+      responseStream: false,
+      options: {},
+    },
+  },
+} as const;
+
+declare var self: any | undefined;
+declare var window: any | undefined;
+declare var global: any | undefined;
+var globalThis: any = (() => {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw "Unable to locate global object";
+})();
+
+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 longToNumber(long: Long): number {
+  if (long.gt(Number.MAX_SAFE_INTEGER)) {
+    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  return long.toNumber();
+}
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}
+
+function isObject(value: any): boolean {
+  return typeof value === "object" && value !== null;
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl/protocol",
-  "version": "1.0.0-3583035976.commit-35d616d",
+  "version": "1.0.0-3603890942.commit-44633cf",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -25,5 +25,5 @@
     "out-ts",
     "public"
   ],
-  "commit": "35d616d3fa8419ddd059e439c9e2137cd7441c88"
+  "commit": "44633cf6e6a93350eb8b272cbfe7956696b995b4"
 }

package/proto/decentraland/renderer/kernel_services/analytics.proto

@@ -0,0 +1,72 @@
+syntax = "proto3";
+
+package decentraland.renderer.kernel_services;
+
+message PerformanceReportRequest {
+    string samples = 1;
+    bool fps_is_capped = 2;
+    sfixed32 hiccups_in_thousand_frames = 3;
+    float hiccups_time = 4;
+    float total_time = 5;
+    sfixed32 gltf_in_progress = 6;
+    sfixed32 gltf_failed = 7;
+    sfixed32 gltf_cancelled = 8;
+    sfixed32 gltf_loaded = 9;
+    sfixed32 ab_in_progress = 10;
+    sfixed32 ab_failed = 11;
+    sfixed32 ab_cancelled = 12;
+    sfixed32 ab_loaded = 13;
+    sfixed32 gltf_textures_loaded = 14;
+    sfixed32 ab_textures_loaded = 15;
+    sfixed32 promise_textures_loaded = 16;
+    sfixed32 enqueued_messages = 17;
+    sfixed32 processed_messages = 18;
+    sfixed32 player_count = 19;
+    sfixed32 load_radius = 20;
+    sfixed32 draw_calls = 21; //int32 *
+    sfixed64 memory_reserved = 22; //long, in total bytes *
+    sfixed64 memory_usage = 23; //long, in total bytes *
+    sfixed64 total_gc_alloc = 24; //long, in total bytes, its the sum of all GCAllocs per frame over 1000 frames *
+    map<sfixed64, sfixed64> scene_scores = 25;
+}
+
+message PerformanceReportResponse {}
+
+message SystemInfoReportRequest {
+    string graphics_device_name = 1;
+    string graphics_device_version = 2;
+    fixed32 graphics_memory_size = 3;
+    string processor_type = 4;
+    fixed32 processor_count = 5;
+    fixed32 system_memory_size = 6;
+
+    // TODO: remove useBinaryTransform after ECS7 is fully in prod
+    bool use_binary_transform = 7;
+}
+
+message SystemInfoReportResponse {}
+
+message AnalyticProperty {
+    string key = 1;
+    string value = 2;
+}
+
+message AnalyticsEventRequest {
+    string event_name = 1;
+    repeated AnalyticProperty properties = 2;
+}
+
+message AnalyticsEventResponse {}
+
+message DelightedSurveyRequest {
+    bool enabled = 1;
+}
+
+message DelightedSurveyResponse {}
+
+service AnalyticsKernelService {
+    rpc PerformanceReport(PerformanceReportRequest) returns (PerformanceReportResponse) {}
+    rpc SystemInfoReport(SystemInfoReportRequest) returns (SystemInfoReportResponse) {}
+    rpc AnalyticsEvent(AnalyticsEventRequest) returns (AnalyticsEventResponse) {}
+    rpc SetDelightedSurveyEnabled(DelightedSurveyRequest) returns (DelightedSurveyResponse) {}
+}

package/proto/decentraland/sdk/components/common/texts.proto

@@ -15,6 +15,5 @@ enum TextAlignMode {
 }
 
 enum Font {
-  F_LIBERATION_SANS = 0;
-  F_SANS_SERIF = 1;
+  F_SANS_SERIF = 0;
 }

package/public/renderer-interface.proto

@@ -4,4 +4,5 @@ import public "decentraland/renderer/engine_interface.proto";
 import public "decentraland/renderer/renderer_services/crdt.proto";
 import public "decentraland/renderer/renderer_services/transport.proto";
 import public "decentraland/renderer/renderer_services/emotes_renderer.proto";
-import public "decentraland/renderer/kernel_services/emotes_kernel.proto";
+import public "decentraland/renderer/kernel_services/emotes_kernel.proto";
+import public "decentraland/renderer/kernel_services/analytics.proto";