@empty-sekai/sekai-custom-profile-sdk 0.3.0

package/dist/gpu/generalTextRenderPlacement.js

@@ -0,0 +1,131 @@
+const TEXT_SCALE = 2;
+/**
+ * Applies General's measured draw anchors after the Rust TMP layout has
+ * finished. The returned instances retain the exact layout metrics and glyph
+ * relationships; only final local/device draw coordinates are translated.
+ */
+export function placeGeneralTextInstances(instances, operations) {
+    const operationByCommand = new Map(operations
+        .filter((operation) => operation.command.payload.kind === "text")
+        .map((operation) => [operation.command.id, operation]));
+    const translationByCommand = new Map();
+    return instances.map((instance) => {
+        const operation = operationByCommand.get(instance.layerId);
+        if (!operation)
+            return cloneInstance(instance);
+        const placement = renderPlacement(operation.command.render_placement);
+        if (!placement)
+            return cloneInstance(instance);
+        let translation = translationByCommand.get(instance.layerId);
+        if (!translation) {
+            translation = placementTranslation(instance, operation, placement);
+            translationByCommand.set(instance.layerId, translation);
+        }
+        return translateInstance(instance, translation);
+    });
+}
+function placementTranslation(instance, operation, placement) {
+    const alignment = numericAlignment(operation.command.payload.alignment);
+    const autoAnchor = alignment === 2
+        ? 0
+        : alignment === 4
+            ? instance.layoutMetrics.boxW / 2
+            : -instance.layoutMetrics.boxW / 2;
+    const localX = placement.anchor_x - autoAnchor;
+    const localY = placement.baseline == null
+        ? 0
+        : placement.baseline - instance.layoutMetrics.anchorBase;
+    const commandMatrix = matrix(operation.command.matrix);
+    const combined = multiply(operation.baseMatrix, commandMatrix);
+    const scaledX = localX * TEXT_SCALE;
+    const scaledY = localY * TEXT_SCALE;
+    return {
+        localX,
+        localY,
+        deviceX: combined[0] * scaledX + combined[2] * scaledY,
+        deviceY: combined[1] * scaledX + combined[3] * scaledY,
+    };
+}
+function translateInstance(instance, value) {
+    const localDeviceX = value.localX * TEXT_SCALE;
+    const localDeviceY = value.localY * TEXT_SCALE;
+    const output = cloneInstance(instance);
+    output.charOp[1] += value.localX;
+    output.charOp[2] += value.localY;
+    output.charPosition[1] += localDeviceX;
+    output.charPosition[2] -= localDeviceY;
+    output.charQuad[1] = shiftPoints(output.charQuad[1], localDeviceX, -localDeviceY);
+    output.quad = output.quad.map(([x, y, u, v, spread]) => [
+        x + value.deviceX,
+        y + value.deviceY,
+        u,
+        v,
+        spread,
+    ]);
+    output.deviceCharPosition[1] += value.deviceX;
+    output.deviceCharPosition[2] += value.deviceY;
+    output.deviceCharQuad[1] = shiftPoints(output.deviceCharQuad[1], value.deviceX, value.deviceY);
+    output.deviceGlyphQuad[1] = shiftPoints(output.deviceGlyphQuad[1], value.deviceX, value.deviceY);
+    return output;
+}
+function cloneInstance(instance) {
+    return {
+        ...instance,
+        quad: instance.quad.map((value) => [...value]),
+        charPosition: [...instance.charPosition],
+        charOp: [...instance.charOp],
+        charQuad: [instance.charQuad[0], instance.charQuad[1].map((value) => [...value])],
+        deviceCharPosition: [...instance.deviceCharPosition],
+        deviceCharQuad: [
+            instance.deviceCharQuad[0],
+            instance.deviceCharQuad[1].map((value) => [...value]),
+        ],
+        deviceGlyphQuad: [
+            instance.deviceGlyphQuad[0],
+            instance.deviceGlyphQuad[1].map((value) => [...value]),
+        ],
+        layoutMetrics: {
+            ...instance.layoutMetrics,
+            lineWidths: [...instance.layoutMetrics.lineWidths],
+            rectWidths: [...instance.layoutMetrics.rectWidths],
+            lineOffsets: [...instance.layoutMetrics.lineOffsets],
+        },
+        fill: [...instance.fill],
+        outline: [...instance.outline],
+    };
+}
+function shiftPoints(points, dx, dy) {
+    return points.map(([x, y]) => [x + dx, y + dy]);
+}
+function renderPlacement(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    if (!Number.isFinite(record.anchor_x))
+        return null;
+    if (record.baseline != null && !Number.isFinite(record.baseline))
+        return null;
+    return {
+        anchor_x: Number(record.anchor_x),
+        baseline: record.baseline == null ? null : Number(record.baseline),
+    };
+}
+function numericAlignment(value) {
+    return Number.isInteger(value) ? Number(value) & 0x07 : 1;
+}
+function matrix(value) {
+    if (!Array.isArray(value) || value.length !== 6 || value.some((part) => !Number.isFinite(part))) {
+        return [1, 0, 0, 1, 0, 0];
+    }
+    return value.map(Number);
+}
+function multiply(parent, child) {
+    return [
+        parent[0] * child[0] + parent[2] * child[1],
+        parent[1] * child[0] + parent[3] * child[1],
+        parent[0] * child[2] + parent[2] * child[3],
+        parent[1] * child[2] + parent[3] * child[3],
+        parent[0] * child[4] + parent[2] * child[5] + parent[4],
+        parent[1] * child[4] + parent[3] * child[5] + parent[5],
+    ];
+}

package/dist/gpu/previewTransformTextureLayout.d.ts

@@ -0,0 +1 @@
+export declare function packPreviewTransformsForTexture(transforms: Float32Array, width: number): Float32Array;

package/dist/gpu/previewTransformTextureLayout.js

@@ -0,0 +1,12 @@
+export function packPreviewTransformsForTexture(transforms, width) {
+    if (!Number.isInteger(width) || width < 1 || transforms.length !== width * 8) {
+        throw new Error(`invalid preview transform buffer ${transforms.length} for width ${width}`);
+    }
+    const packed = new Float32Array(transforms.length);
+    for (let slot = 0; slot < width; slot += 1) {
+        const source = slot * 8;
+        packed.set(transforms.subarray(source, source + 4), slot * 4);
+        packed.set(transforms.subarray(source + 4, source + 8), (width + slot) * 4);
+    }
+    return packed;
+}

package/dist/gpu/semanticCommandGeometry.d.ts

@@ -0,0 +1,21 @@
+import type { SemanticDrawOperation, SemanticResourceKey } from "./semanticCommandPlanner.js";
+export type SemanticDrawBatchKind = "shape" | "image" | "mask" | "text" | "composite";
+export type SemanticBlendMode = "src_over" | "src_in" | "dst_in" | "multiply" | "screen" | "add";
+export type SemanticCompositeOperation = "marker" | "begin_isolation" | "end_isolation";
+export type SemanticDrawBatch = {
+    kind: SemanticDrawBatchKind;
+    commandIds: string[];
+    operations: SemanticDrawOperation[];
+    vertices: Float32Array;
+    layerSlots: Uint32Array;
+    commandSlots: Uint32Array;
+    resource: SemanticResourceKey | null;
+    maskResource: SemanticResourceKey | null;
+    blendMode: SemanticBlendMode;
+    compositeOperation: SemanticCompositeOperation | null;
+};
+export declare const SEMANTIC_FLOATS_PER_VERTEX = 28;
+export declare function semanticTextBatchKey(commandIds: readonly string[]): string;
+/** Compile immutable geometry only. Render mask and dynamic translation remain
+ * in the dense layer-state textures, so toggles/ticks never rebuild vertices. */
+export declare function compileSemanticDrawBatches(operations: SemanticDrawOperation[]): SemanticDrawBatch[];

package/dist/gpu/semanticCommandGeometry.js

@@ -0,0 +1,226 @@
+export const SEMANTIC_FLOATS_PER_VERTEX = 28;
+export function semanticTextBatchKey(commandIds) {
+    return `semantic-text-batch\0${commandIds.join("\0")}`;
+}
+const UNIT_TRIANGLES = [
+    [0, 0], [1, 0], [1, 1],
+    [0, 0], [1, 1], [0, 1],
+];
+/** Compile immutable geometry only. Render mask and dynamic translation remain
+ * in the dense layer-state textures, so toggles/ticks never rebuild vertices. */
+export function compileSemanticDrawBatches(operations) {
+    const groups = [];
+    for (const operation of operations) {
+        const descriptor = batchDescriptor(operation);
+        const previous = groups.at(-1);
+        if (previous?.key === descriptor.key)
+            previous.operations.push(operation);
+        else
+            groups.push({ ...descriptor, operations: [operation] });
+    }
+    return groups.map((group) => compileGroup(group.kind, group.resource, group.maskResource, group.blendMode, group.compositeOperation, group.operations));
+}
+function batchDescriptor(operation) {
+    const payload = operation.command.payload;
+    const blendMode = commandBlendMode(operation.command.blend_mode);
+    if (payload.kind === "image") {
+        const resource = requireResource(payload.resource, operation.command.id);
+        const maskResource = optionalResource(payload.alpha_mask);
+        const maskKey = maskResource ? `\0${maskResource.namespace}\0${maskResource.key}` : "";
+        return { key: `image\0${blendMode}\0${resource.namespace}\0${resource.key}${maskKey}`, kind: "image", resource, maskResource, blendMode, compositeOperation: null };
+    }
+    if (payload.kind === "shape") {
+        const maskResource = assetMaskResource(payload.primitive);
+        if (maskResource)
+            return { key: `mask\0${blendMode}\0${maskResource.namespace}\0${maskResource.key}`, kind: "mask", resource: maskResource, maskResource: null, blendMode, compositeOperation: null };
+        return { key: `shape\0${blendMode}`, kind: "shape", resource: null, maskResource: null, blendMode, compositeOperation: null };
+    }
+    if (payload.kind === "text")
+        return { key: `text\0${blendMode}`, kind: "text", resource: null, maskResource: null, blendMode, compositeOperation: null };
+    if (payload.kind === "composite") {
+        const compositeOperation = requireCompositeOperation(payload.operation, operation.command.id);
+        return { key: `composite\0${operation.command.id}`, kind: "composite", resource: null, maskResource: null, blendMode, compositeOperation };
+    }
+    throw new Error(`unsupported semantic command payload ${payload.kind}`);
+}
+function compileGroup(kind, resource, maskResource, blendMode, compositeOperation, operations) {
+    if (kind === "text" || kind === "composite") {
+        return { kind, resource, maskResource, blendMode, compositeOperation, operations: [...operations], commandIds: operations.map((op) => op.command.id), vertices: new Float32Array(), layerSlots: new Uint32Array(), commandSlots: new Uint32Array() };
+    }
+    const vertices = new Float32Array(operations.length * 6 * SEMANTIC_FLOATS_PER_VERTEX);
+    const layerSlots = new Uint32Array(operations.length * 6);
+    const commandSlots = new Uint32Array(operations.length * 6);
+    let vertexOffset = 0;
+    for (const operation of operations) {
+        const bounds = requireRect(operation.command.bounds, operation.command.id);
+        const commandMatrix = requireMatrix(operation.command.matrix, operation.command.id);
+        const clip = commandClip(operation.command.clip, operation.baseMatrix, operation.command.id);
+        const payload = operation.command.payload;
+        const uv = payload.kind === "image" ? optionalRect(payload.uv) : { x: 0, y: 0, width: 1, height: 1 };
+        const fill = payload.kind === "image" ? optionalColor(payload.tint, [1, 1, 1, 1]) : optionalColor(payload.fill, [1, 1, 1, 1]);
+        const stroke = payload.kind === "shape" ? optionalColor(payload.stroke, [0, 0, 0, 0]) : [0, 0, 0, 0];
+        const [primitive, radiusX, radiusY] = payload.kind === "shape"
+            ? shapeParams(payload.primitive, bounds)
+            : payload.kind === "image" ? imageClipParams(payload.clip, bounds) : [0, 0, 0];
+        const strokeWidth = payload.kind === "shape" && typeof payload.stroke_width === "number"
+            ? payload.stroke_width
+            : 0;
+        for (const [unitX, unitY] of UNIT_TRIANGLES) {
+            const vertexFill = payload.kind === "shape" ? gradientColor(payload.gradient, unitX, unitY, fill) : fill;
+            const localX = bounds.x + bounds.width * unitX;
+            const localY = bounds.y + bounds.height * unitY;
+            const commandPoint = transformPoint(commandMatrix, localX, localY);
+            const [x, y] = transformPoint(operation.baseMatrix, commandPoint[0], commandPoint[1]);
+            const base = vertexOffset * SEMANTIC_FLOATS_PER_VERTEX;
+            vertices.set([
+                x, y,
+                uv.x + uv.width * unitX, uv.y + uv.height * unitY,
+                unitX, unitY,
+                ...vertexFill,
+                ...stroke,
+                primitive, radiusX, radiusY, strokeWidth,
+                ...clip[0], ...clip[1], ...clip[2], ...clip[3],
+                bounds.width, bounds.height,
+            ], base);
+            layerSlots[vertexOffset] = operation.layerSlot;
+            commandSlots[vertexOffset] = operation.commandSlot;
+            vertexOffset += 1;
+        }
+    }
+    return {
+        kind,
+        resource,
+        maskResource,
+        blendMode,
+        compositeOperation,
+        operations: [...operations],
+        commandIds: operations.map((operation) => operation.command.id),
+        vertices,
+        layerSlots,
+        commandSlots,
+    };
+}
+function commandBlendMode(value) {
+    if (value == null)
+        return "src_over";
+    if (value === "src_over" || value === "src_in" || value === "dst_in" || value === "multiply" || value === "screen" || value === "add")
+        return value;
+    throw new Error(`unsupported semantic blend mode ${String(value)}`);
+}
+function requireCompositeOperation(value, commandId) {
+    if (value == null || value === "marker")
+        return "marker";
+    if (value === "begin_isolation" || value === "end_isolation")
+        return value;
+    throw new Error(`unsupported composite operation ${commandId}: ${String(value)}`);
+}
+function commandClip(value, baseMatrix, commandId) {
+    if (value == null)
+        return [[-1e9, -1e9], [1e9, -1e9], [1e9, 1e9], [-1e9, 1e9]];
+    if (!Array.isArray(value) || value.length !== 4 || value.some((point) => !Array.isArray(point) || point.length !== 2 || point.some((entry) => typeof entry !== "number" || !Number.isFinite(entry)))) {
+        throw new Error(`invalid command clip ${commandId}`);
+    }
+    return value.map((point) => transformPoint(baseMatrix, point[0], point[1]));
+}
+function gradientColor(value, x, y, fallback) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return fallback;
+    const gradient = value;
+    const start = optionalPoint(gradient.start, [0, 0.5]);
+    const end = optionalPoint(gradient.end, [1, 0.5]);
+    const startColor = optionalColor(gradient.start_color, fallback);
+    const endColor = optionalColor(gradient.end_color, fallback);
+    const dx = end[0] - start[0];
+    const dy = end[1] - start[1];
+    const lengthSq = dx * dx + dy * dy;
+    const t = lengthSq > 1e-9 ? Math.max(0, Math.min(1, ((x - start[0]) * dx + (y - start[1]) * dy) / lengthSq)) : 0;
+    return startColor.map((component, index) => component + (endColor[index] - component) * t);
+}
+function optionalPoint(value, fallback) {
+    return Array.isArray(value) && value.length === 2 && value.every((entry) => typeof entry === "number" && Number.isFinite(entry))
+        ? [value[0], value[1]]
+        : fallback;
+}
+function transformPoint(matrix, x, y) {
+    return [matrix[0] * x + matrix[2] * y + matrix[4], matrix[1] * x + matrix[3] * y + matrix[5]];
+}
+function requireMatrix(value, commandId) {
+    if (!Array.isArray(value) || value.length !== 6 || value.some((entry) => typeof entry !== "number" || !Number.isFinite(entry))) {
+        throw new Error(`invalid command matrix ${commandId}`);
+    }
+    return value;
+}
+function requireRect(value, commandId) {
+    const rect = optionalRect(value);
+    if (![rect.x, rect.y, rect.width, rect.height].every(Number.isFinite) || rect.width < 0 || rect.height < 0) {
+        throw new Error(`invalid command bounds ${commandId}`);
+    }
+    return rect;
+}
+function optionalRect(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return { x: 0, y: 0, width: 1, height: 1 };
+    const rect = value;
+    return {
+        x: Number(rect.x ?? 0),
+        y: Number(rect.y ?? 0),
+        width: Number(rect.width ?? 1),
+        height: Number(rect.height ?? 1),
+    };
+}
+function optionalColor(value, fallback) {
+    return Array.isArray(value) && value.length === 4 && value.every((entry) => typeof entry === "number" && Number.isFinite(entry))
+        ? value
+        : fallback;
+}
+function shapeParams(value, _bounds) {
+    if (value === "ellipse")
+        return [2, 0, 0];
+    if (value === "rect")
+        return [0, 0, 0];
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return [0, 0, 0];
+    const rounded = value.rounded_rect;
+    if (rounded && typeof rounded === "object" && !Array.isArray(rounded)) {
+        const radius = rounded.radius;
+        if (Array.isArray(radius) && radius.length === 2) {
+            return [1, Number(radius[0]), Number(radius[1])];
+        }
+    }
+    return [0, 0, 0];
+}
+function imageClipParams(value, _bounds) {
+    if (value === "ellipse")
+        return [2, 0, 0];
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return [0, 0, 0];
+    const rounded = value.rounded_rect;
+    if (rounded && typeof rounded === "object" && !Array.isArray(rounded)) {
+        const radius = rounded.radius;
+        if (Array.isArray(radius) && radius.length === 2) {
+            return [1, Number(radius[0]), Number(radius[1])];
+        }
+    }
+    return [0, 0, 0];
+}
+function assetMaskResource(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const mask = value.asset_mask;
+    if (!mask || typeof mask !== "object" || Array.isArray(mask))
+        return null;
+    return requireResource(mask.resource, "asset-mask");
+}
+function requireResource(value, commandId) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error(`missing command resource ${commandId}`);
+    const resource = value;
+    if (typeof resource.namespace !== "string" || typeof resource.key !== "string")
+        throw new Error(`invalid command resource ${commandId}`);
+    return { namespace: resource.namespace, key: resource.key };
+}
+function optionalResource(value) {
+    if (value == null)
+        return null;
+    return requireResource(value, "image-alpha-mask");
+}

package/dist/gpu/semanticCommandPlanner.d.ts

@@ -0,0 +1,131 @@
+export type SemanticResourceKey = {
+    namespace: string;
+    key: string;
+};
+export type SemanticCommand = {
+    id: string;
+    layer_id: string;
+    role: string;
+    payload: Record<string, unknown> & {
+        kind: string;
+    };
+    [key: string]: unknown;
+};
+export type SemanticLayerPatch = {
+    layer_id: string;
+    render_mask: boolean | null;
+    transform: {
+        dx: number;
+        dy: number;
+    } | null;
+};
+export type SemanticCommandStatePatch = {
+    slot: number;
+    render_mask: boolean | null;
+    transform: {
+        dx: number;
+        dy: number;
+    } | null;
+};
+export type SemanticCommandPlanInput = {
+    layerTableRevision: number;
+    layerTable: Array<{
+        layer_id: string;
+        parent_id: string | null;
+        slot: number;
+        subtree_start: number;
+        subtree_end: number;
+    }>;
+    layerSources: Array<{
+        layer_id: string;
+        matrix: [number, number, number, number, number, number];
+    }>;
+    layerCommands: Array<{
+        layer_id: string;
+        render_mask: boolean;
+        transform: {
+            dx: number;
+            dy: number;
+        };
+        command_start: number;
+        command_count: number;
+    }>;
+    semanticCommands: SemanticCommand[];
+    commandStates?: Array<{
+        command_id: string;
+        slot: number;
+        render_mask: boolean;
+        transform: {
+            dx: number;
+            dy: number;
+        };
+    }>;
+};
+export type SemanticDrawOperation = {
+    command: SemanticCommand;
+    layerId: string;
+    layerSlot: number;
+    baseMatrix: [number, number, number, number, number, number];
+    visible: boolean;
+    transform: {
+        dx: number;
+        dy: number;
+    };
+    commandSlot: number;
+    commandVisible: boolean;
+    commandTransform: {
+        dx: number;
+        dy: number;
+    };
+};
+/**
+ * Immutable authored-layer command ownership plus mutable render state.
+ * Visibility and dynamic deltas update only the dense state table; command
+ * order and resource identity remain stable for the plan lifetime.
+ */
+export declare class SemanticCommandPlan {
+    readonly layerTableRevision: number;
+    readonly commandRevision = 1;
+    readonly resourceRevision = 1;
+    private readonly commands;
+    private readonly operationLayers;
+    private readonly stateByLayer;
+    private readonly resources;
+    private readonly commandVisible;
+    private readonly commandTransforms;
+    constructor(input: SemanticCommandPlanInput);
+    operations(): SemanticDrawOperation[];
+    resourceRequests(): SemanticResourceKey[];
+    applyLayerPatches(patches: SemanticLayerPatch[]): void;
+    applyCommandPatches(patches: SemanticCommandStatePatch[]): void;
+}
+export declare function semanticCommandPlanFromCoreSnapshot(snapshot: {
+    revisions: {
+        layer_table: number;
+    } & Record<string, number>;
+    layer_table: SemanticCommandPlanInput["layerTable"];
+    layer_sources: Array<{
+        id: string;
+        matrix: [number, number, number, number, number, number];
+    }>;
+    commands: SemanticCommandPlanInput["layerCommands"];
+    semantic_commands: SemanticCommand[];
+    command_states: NonNullable<SemanticCommandPlanInput["commandStates"]>;
+}): SemanticCommandPlan;
+export type CoreSceneDumpInput = {
+    revisions: {
+        layer_table: number;
+    } & Record<string, number>;
+    layer_table: SemanticCommandPlanInput["layerTable"];
+    layers: Array<{
+        layer_id: string;
+        matrix: [number, number, number, number, number, number];
+        render_mask: boolean;
+        commands: SemanticCommand[];
+    }>;
+    command_states: NonNullable<SemanticCommandPlanInput["commandStates"]>;
+};
+/** Adapts the native/server debug dump to the exact same immutable browser
+ * command plan used by a live WASM Scene. This is intentionally strict so a
+ * dump cannot silently reorder authored layers or command ownership. */
+export declare function semanticCommandPlanFromCoreDump(dump: CoreSceneDumpInput): SemanticCommandPlan;