Add Chromium-only Blender WebEngine parity work

web/protocol/paint.ts

@@ -0,0 +1,148 @@
+export const PAINT_BUDGET = {
+  maxSamples: 100_000,
+  maxWeightEntries: 1_000_000,
+  maxTextureTileBytes: 256 * 1024 * 1024,
+  maxStrokeBytes: 64 * 1024 * 1024,
+} as const;
+
+export type PaintMode = "VERTEX_COLOR" | "WEIGHT" | "TEXTURE";
+
+export interface PaintHitIR {
+  position: [number, number, number];
+  normal?: [number, number, number];
+  faceIndex?: number;
+  barycentric?: [number, number, number];
+  uv?: [number, number];
+  pressure?: number;
+}
+
+export interface PaintStrokeIR {
+  schemaVersion: 1;
+  mode: PaintMode;
+  objectId: string;
+  revision: number;
+  radius: number;
+  strength: number;
+  samples: PaintHitIR[];
+  color?: [number, number, number, number];
+  vertexGroup?: string;
+  textureAssetId?: string;
+  textureTile?: number;
+  spacing?: number;
+}
+
+export interface WeightPatchIR {
+  schemaVersion: 1;
+  objectId: string;
+  revision: number;
+  vertexGroup: string;
+  indices: number[];
+  values: number[];
+  normalize?: boolean;
+  mirror?: boolean;
+}
+
+function fail(path: string, message: string, budget = false): never {
+  throw new Error(`${budget ? "PAINT_BUDGET_EXCEEDED" : "PAINT_SCHEMA_INVALID"}: ${path} ${message}`);
+}
+
+function record(value: unknown, path: string): Record<string, unknown> {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) fail(path, "must be an object");
+  return value as Record<string, unknown>;
+}
+
+function finite(value: unknown, path: string): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) fail(path, "must be finite");
+  return value;
+}
+
+function integer(value: unknown, path: string): number {
+  const result = finite(value, path);
+  if (!Number.isSafeInteger(result) || result < 0) fail(path, "must be a non-negative safe integer");
+  return result;
+}
+
+function tuple(value: unknown, length: number, path: string): number[] {
+  if (!Array.isArray(value) || value.length !== length) fail(path, `must contain ${length} numbers`);
+  if (value.some((item) => typeof item !== "number" || !Number.isFinite(item))) fail(path, "must contain finite numbers");
+  return value as number[];
+}
+
+function string(value: unknown, path: string, allowEmpty = false): string {
+  if (typeof value !== "string" || (!allowEmpty && value.length === 0) || value.length > 255) fail(path, "is outside the bounded string range");
+  return value;
+}
+
+function parseHit(value: unknown, path: string): PaintHitIR {
+  const hit = record(value, path);
+  const position = tuple(hit.position, 3, `${path}.position`) as [number, number, number];
+  const result: PaintHitIR = { position };
+  if (hit.normal !== undefined) result.normal = tuple(hit.normal, 3, `${path}.normal`) as [number, number, number];
+  if (hit.faceIndex !== undefined) result.faceIndex = integer(hit.faceIndex, `${path}.faceIndex`);
+  if (hit.barycentric !== undefined) {
+    result.barycentric = tuple(hit.barycentric, 3, `${path}.barycentric`) as [number, number, number];
+    if (result.barycentric.some((item) => item < 0 || item > 1) || Math.abs(result.barycentric.reduce((sum, item) => sum + item, 0) - 1) > 1e-4) fail(`${path}.barycentric`, "must be non-negative and sum to one");
+  }
+  if (hit.uv !== undefined) result.uv = tuple(hit.uv, 2, `${path}.uv`) as [number, number];
+  if (hit.pressure !== undefined) {
+    const pressure = finite(hit.pressure, `${path}.pressure`);
+    if (pressure < 0 || pressure > 1) fail(`${path}.pressure`, "must be in [0,1]");
+    result.pressure = pressure;
+  }
+  return result;
+}
+
+export function parsePaintStroke(value: unknown): PaintStrokeIR {
+  const stroke = record(value, "paintStroke");
+  if (stroke.schemaVersion !== 1) fail("paintStroke.schemaVersion", "is unsupported");
+  const mode = stroke.mode;
+  if (mode !== "VERTEX_COLOR" && mode !== "WEIGHT" && mode !== "TEXTURE") fail("paintStroke.mode", "is invalid");
+  const samples = Array.isArray(stroke.samples) ? stroke.samples : fail("paintStroke.samples", "must be an array");
+  if (samples.length === 0 || samples.length > PAINT_BUDGET.maxSamples) fail("paintStroke.samples", "exceeds the sample budget", samples.length > PAINT_BUDGET.maxSamples);
+  const radius = finite(stroke.radius, "paintStroke.radius");
+  const strength = finite(stroke.strength, "paintStroke.strength");
+  if (radius <= 0 || radius > 100_000) fail("paintStroke.radius", "is outside the bounded range");
+  if (strength < -1 || strength > 1) fail("paintStroke.strength", "must be in [-1,1]");
+  const revision = integer(stroke.revision, "paintStroke.revision");
+  const result: PaintStrokeIR = { schemaVersion: 1, mode, objectId: string(stroke.objectId, "paintStroke.objectId"), revision, radius, strength, samples: samples.map((sample, index) => parseHit(sample, `paintStroke.samples[${index}]`)) };
+  if (stroke.color !== undefined) {
+    result.color = tuple(stroke.color, 4, "paintStroke.color") as [number, number, number, number];
+    if (result.color.some((item) => item < 0 || item > 1)) fail("paintStroke.color", "must be in [0,1]");
+  }
+  if (stroke.vertexGroup !== undefined) result.vertexGroup = string(stroke.vertexGroup, "paintStroke.vertexGroup");
+  if (stroke.textureAssetId !== undefined) result.textureAssetId = string(stroke.textureAssetId, "paintStroke.textureAssetId");
+  if (stroke.textureTile !== undefined) result.textureTile = integer(stroke.textureTile, "paintStroke.textureTile");
+  if (stroke.spacing !== undefined) {
+    result.spacing = finite(stroke.spacing, "paintStroke.spacing");
+    if (result.spacing < 0 || result.spacing > 100_000) fail("paintStroke.spacing", "is outside the bounded range");
+  }
+  if (mode === "WEIGHT" && !result.vertexGroup) fail("paintStroke.vertexGroup", "is required for weight paint");
+  if (mode === "TEXTURE" && !result.textureAssetId) fail("paintStroke.textureAssetId", "is required for texture paint");
+  const estimatedBytes = samples.length * 64;
+  if (estimatedBytes > PAINT_BUDGET.maxStrokeBytes) fail("paintStroke", "exceeds the byte budget", true);
+  return result;
+}
+
+export function parseWeightPatch(value: unknown): WeightPatchIR {
+  const patch = record(value, "weightPatch");
+  if (patch.schemaVersion !== 1) fail("weightPatch.schemaVersion", "is unsupported");
+  if (!Array.isArray(patch.indices) || !Array.isArray(patch.values) || patch.indices.length !== patch.values.length) fail("weightPatch", "indices and values must have equal lengths");
+  if (patch.indices.length > PAINT_BUDGET.maxWeightEntries) fail("weightPatch", "exceeds the weight entry budget", true);
+  const indices = patch.indices.map((item, index) => integer(item, `weightPatch.indices[${index}]`));
+  const values = patch.values.map((item, index) => {
+    const result = finite(item, `weightPatch.values[${index}]`);
+    if (result < 0 || result > 1) fail(`weightPatch.values[${index}]`, "must be in [0,1]");
+    return result;
+  });
+  const result: WeightPatchIR = { schemaVersion: 1, objectId: string(patch.objectId, "weightPatch.objectId"), revision: integer(patch.revision, "weightPatch.revision"), vertexGroup: string(patch.vertexGroup, "weightPatch.vertexGroup"), indices, values };
+  if (patch.normalize !== undefined) {
+    if (typeof patch.normalize !== "boolean") fail("weightPatch.normalize", "must be boolean");
+    result.normalize = patch.normalize;
+  }
+  if (patch.mirror !== undefined) {
+    if (typeof patch.mirror !== "boolean") fail("weightPatch.mirror", "must be boolean");
+    result.mirror = patch.mirror;
+  }
+  return result;
+}
+