337 lines
16 KiB
TypeScript
337 lines
16 KiB
TypeScript
export interface DepsgraphMeshEvaluationIR {
|
|
objectId: string;
|
|
meshId: string;
|
|
sourceMeshId: string;
|
|
vertexCount: number;
|
|
triangleCount: number;
|
|
modifierCount: number;
|
|
modifiers: DepsgraphModifierEvaluationIR[];
|
|
worldMatrix: number[];
|
|
positions: number[];
|
|
indices: number[];
|
|
}
|
|
|
|
export interface DepsgraphModifierEvaluationIR {
|
|
uuid: string;
|
|
index: number;
|
|
persistentUid: number;
|
|
typeCode: number;
|
|
type: string;
|
|
name: string;
|
|
showViewport: boolean;
|
|
showRender: boolean;
|
|
showEditmode: boolean;
|
|
showOnCage: boolean;
|
|
status: "EVALUATED" | "DISABLED" | "BLOCKED";
|
|
reason?: string;
|
|
error?: string;
|
|
errorCode?: "UNSUPPORTED_MODIFIER_TYPE" | "MODIFIER_TARGET_MISSING" | "BLENDER_MODIFIER_ERROR";
|
|
suggestion?: string;
|
|
targetObjectIds?: string[];
|
|
dependsOn?: string[];
|
|
}
|
|
|
|
export interface DepsgraphObjectEvaluationIR {
|
|
objectId: string;
|
|
type: "MESH" | "CURVE" | "SURFACE" | "FONT" | "METABALL" | "CURVES" | "POINT_CLOUD" | "VOLUME" | "LATTICE" | "ARMATURE" | "GREASE_PENCIL" | "EMPTY" | "OTHER";
|
|
modifierCount: number;
|
|
modifiers: DepsgraphModifierEvaluationIR[];
|
|
}
|
|
|
|
export interface DepsgraphConstraintEvaluationIR {
|
|
name: string;
|
|
typeCode: number;
|
|
influence: number;
|
|
flag: number;
|
|
targetObjectId?: string;
|
|
}
|
|
|
|
export interface DepsgraphBoneEvaluationIR {
|
|
id: string;
|
|
name: string;
|
|
poseMatrix: number[];
|
|
constraints: DepsgraphConstraintEvaluationIR[];
|
|
}
|
|
|
|
export interface DepsgraphArmatureEvaluationIR {
|
|
id: string;
|
|
objectId: string;
|
|
bones: DepsgraphBoneEvaluationIR[];
|
|
}
|
|
|
|
export interface DepsgraphNonMeshGeometryIR {
|
|
objectId: string;
|
|
sourceDataId: string;
|
|
sourceType: "CURVE" | "SURFACE" | "FONT" | "METABALL";
|
|
meshId: string;
|
|
status: "EVALUATED" | "BLOCKED";
|
|
errorCode?: "NON_MESH_DATA_BUDGET_EXCEEDED";
|
|
vertexCount: number;
|
|
edgeCount: number;
|
|
triangleCount: number;
|
|
worldMatrix: number[];
|
|
positions?: number[];
|
|
normals?: number[];
|
|
edgeVertexIndices?: number[];
|
|
indices?: number[];
|
|
uvs?: number[];
|
|
triangleMaterialIndices?: number[];
|
|
sourceElementIndices?: number[];
|
|
materialSlotIds: string[];
|
|
sourceMappingStatus: "EVALUATED_FACE" | "EVALUATED_EDGE";
|
|
}
|
|
|
|
export interface DepsgraphEvaluationIR {
|
|
engine: "BlenderDepsgraph";
|
|
status: "EVALUATED";
|
|
scene: string;
|
|
viewLayer: string;
|
|
frame: number;
|
|
objectCount: number;
|
|
meshObjectCount: number;
|
|
objects: DepsgraphObjectEvaluationIR[];
|
|
meshes: DepsgraphMeshEvaluationIR[];
|
|
nonMeshGeometries?: DepsgraphNonMeshGeometryIR[];
|
|
armatures?: DepsgraphArmatureEvaluationIR[];
|
|
}
|
|
|
|
function isRecord(value: unknown): value is Record<string, unknown> {
|
|
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
}
|
|
|
|
function numberField(record: Record<string, unknown>, field: string): number {
|
|
const value = record[field];
|
|
if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`Depsgraph field ${field} is invalid`);
|
|
return value;
|
|
}
|
|
|
|
function stringField(record: Record<string, unknown>, field: string): string {
|
|
const value = record[field];
|
|
if (typeof value !== "string") throw new Error(`Depsgraph field ${field} is invalid`);
|
|
return value;
|
|
}
|
|
|
|
function numberArray(record: Record<string, unknown>, field: string): number[] {
|
|
const value = record[field];
|
|
if (!Array.isArray(value) || value.some((item) => typeof item !== "number" || !Number.isFinite(item))) {
|
|
throw new Error(`Depsgraph field ${field} is invalid`);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function countField(record: Record<string, unknown>, field: string): number {
|
|
const value = numberField(record, field);
|
|
if (!Number.isSafeInteger(value) || value < 0) throw new Error(`Depsgraph field ${field} is not a non-negative count`);
|
|
return value;
|
|
}
|
|
|
|
function booleanField(record: Record<string, unknown>, field: string): boolean {
|
|
const value = record[field];
|
|
if (typeof value !== "boolean") throw new Error(`Depsgraph field ${field} is invalid`);
|
|
return value;
|
|
}
|
|
|
|
function constraintReports(record: Record<string, unknown>): DepsgraphConstraintEvaluationIR[] {
|
|
const value = record.constraints;
|
|
if (!Array.isArray(value)) throw new Error("Depsgraph bone constraints are invalid");
|
|
return value.map((candidate) => {
|
|
if (!isRecord(candidate)) throw new Error("Depsgraph constraint entry is invalid");
|
|
const targetObjectId = candidate.targetObjectId;
|
|
if (targetObjectId !== undefined && typeof targetObjectId !== "string") {
|
|
throw new Error("Depsgraph constraint targetObjectId is invalid");
|
|
}
|
|
return {
|
|
name: stringField(candidate, "name"),
|
|
typeCode: countField(candidate, "typeCode"),
|
|
influence: numberField(candidate, "influence"),
|
|
flag: countField(candidate, "flag"),
|
|
...(targetObjectId === undefined ? {} : { targetObjectId }),
|
|
};
|
|
});
|
|
}
|
|
|
|
function armatureReports(value: unknown): DepsgraphArmatureEvaluationIR[] {
|
|
if (!Array.isArray(value)) throw new Error("Depsgraph armatures are invalid");
|
|
return value.map((candidate) => {
|
|
if (!isRecord(candidate)) throw new Error("Depsgraph armature entry is invalid");
|
|
const bonesValue = candidate.bones;
|
|
if (!Array.isArray(bonesValue)) throw new Error("Depsgraph armature bones are invalid");
|
|
const bones = bonesValue.map((boneValue) => {
|
|
if (!isRecord(boneValue)) throw new Error("Depsgraph bone entry is invalid");
|
|
const poseMatrix = numberArray(boneValue, "poseMatrix");
|
|
if (poseMatrix.length !== 16) throw new Error("Depsgraph bone poseMatrix must contain 16 numbers");
|
|
return {
|
|
id: stringField(boneValue, "id"),
|
|
name: stringField(boneValue, "name"),
|
|
poseMatrix,
|
|
constraints: constraintReports(boneValue),
|
|
};
|
|
});
|
|
return { id: stringField(candidate, "id"), objectId: stringField(candidate, "objectId"), bones };
|
|
});
|
|
}
|
|
|
|
function modifierReports(record: Record<string, unknown>): DepsgraphModifierEvaluationIR[] {
|
|
const value = record.modifiers;
|
|
if (!Array.isArray(value)) throw new Error(`Depsgraph field modifiers is invalid`);
|
|
return value.map((candidate) => {
|
|
if (!isRecord(candidate)) throw new Error("Depsgraph modifier entry is invalid");
|
|
const status = stringField(candidate, "status");
|
|
if (status !== "EVALUATED" && status !== "DISABLED" && status !== "BLOCKED") {
|
|
throw new Error(`Depsgraph modifier status is invalid: ${status}`);
|
|
}
|
|
const dependsOn = candidate.dependsOn;
|
|
if (dependsOn !== undefined && (!Array.isArray(dependsOn) || dependsOn.some((item) => typeof item !== "string"))) {
|
|
throw new Error("Depsgraph modifier dependsOn is invalid");
|
|
}
|
|
const targetObjectIds = candidate.targetObjectIds;
|
|
if (targetObjectIds !== undefined && (!Array.isArray(targetObjectIds) || targetObjectIds.some((item) => typeof item !== "string"))) {
|
|
throw new Error("Depsgraph modifier targetObjectIds is invalid");
|
|
}
|
|
const reason = candidate.reason;
|
|
const error = candidate.error;
|
|
const errorCode = candidate.errorCode;
|
|
const suggestion = candidate.suggestion;
|
|
if (reason !== undefined && typeof reason !== "string") throw new Error("Depsgraph modifier reason is invalid");
|
|
if (error !== undefined && typeof error !== "string") throw new Error("Depsgraph modifier error is invalid");
|
|
if (errorCode !== undefined && !["UNSUPPORTED_MODIFIER_TYPE", "MODIFIER_TARGET_MISSING", "BLENDER_MODIFIER_ERROR"].includes(errorCode as string)) {
|
|
throw new Error("Depsgraph modifier errorCode is invalid");
|
|
}
|
|
if (suggestion !== undefined && typeof suggestion !== "string") throw new Error("Depsgraph modifier suggestion is invalid");
|
|
return {
|
|
uuid: stringField(candidate, "uuid"),
|
|
index: countField(candidate, "index"),
|
|
persistentUid: countField(candidate, "persistentUid"),
|
|
typeCode: countField(candidate, "typeCode"),
|
|
type: stringField(candidate, "type"),
|
|
name: stringField(candidate, "name"),
|
|
showViewport: booleanField(candidate, "showViewport"),
|
|
showRender: booleanField(candidate, "showRender"),
|
|
showEditmode: booleanField(candidate, "showEditmode"),
|
|
showOnCage: booleanField(candidate, "showOnCage"),
|
|
status,
|
|
...(dependsOn === undefined ? {} : { dependsOn: dependsOn as string[] }),
|
|
...(targetObjectIds === undefined ? {} : { targetObjectIds: targetObjectIds as string[] }),
|
|
...(reason === undefined ? {} : { reason }),
|
|
...(error === undefined ? {} : { error }),
|
|
...(errorCode === undefined ? {} : { errorCode: errorCode as DepsgraphModifierEvaluationIR["errorCode"] }),
|
|
...(suggestion === undefined ? {} : { suggestion }),
|
|
};
|
|
});
|
|
}
|
|
|
|
export function parseDepsgraphEvaluation(value: unknown): DepsgraphEvaluationIR {
|
|
if (!isRecord(value) || value.engine !== "BlenderDepsgraph" || value.status !== "EVALUATED") {
|
|
throw new Error("Blender Depsgraph report has an invalid status");
|
|
}
|
|
if (!Array.isArray(value.meshes)) throw new Error("Blender Depsgraph report has no mesh evaluations");
|
|
if (!Array.isArray(value.objects)) throw new Error("Blender Depsgraph report has no object evaluations");
|
|
const objects = value.objects.map((candidate) => {
|
|
if (!isRecord(candidate)) throw new Error("Blender Depsgraph object entry is invalid");
|
|
const type = stringField(candidate, "type");
|
|
if (!["MESH", "CURVE", "SURFACE", "FONT", "METABALL", "CURVES", "POINT_CLOUD", "VOLUME", "LATTICE", "ARMATURE", "GREASE_PENCIL", "EMPTY", "OTHER"].includes(type)) {
|
|
throw new Error(`Blender Depsgraph object type is invalid: ${type}`);
|
|
}
|
|
const modifiers = modifierReports(candidate);
|
|
const modifierCount = countField(candidate, "modifierCount");
|
|
if (modifiers.length !== modifierCount) throw new Error("Blender Depsgraph object modifier count is inconsistent");
|
|
return {
|
|
objectId: stringField(candidate, "objectId"),
|
|
type: type as DepsgraphObjectEvaluationIR["type"],
|
|
modifierCount,
|
|
modifiers,
|
|
};
|
|
});
|
|
const meshes = value.meshes.map((candidate) => {
|
|
if (!isRecord(candidate)) throw new Error("Blender Depsgraph mesh entry is invalid");
|
|
const vertexCount = countField(candidate, "vertexCount");
|
|
const triangleCount = countField(candidate, "triangleCount");
|
|
const modifiers = modifierReports(candidate);
|
|
const modifierCount = countField(candidate, "modifierCount");
|
|
if (modifiers.length !== modifierCount) throw new Error("Blender Depsgraph mesh modifier count is inconsistent");
|
|
const worldMatrix = numberArray(candidate, "worldMatrix");
|
|
const positions = numberArray(candidate, "positions");
|
|
const indices = numberArray(candidate, "indices");
|
|
if (worldMatrix.length !== 16 || positions.length !== vertexCount * 3 || indices.length !== triangleCount * 3) {
|
|
throw new Error(`Depsgraph mesh ${stringField(candidate, "sourceMeshId")} buffer lengths are inconsistent`);
|
|
}
|
|
if (indices.some((index) => !Number.isSafeInteger(index) || index < 0 || index >= vertexCount)) {
|
|
throw new Error(`Depsgraph mesh ${stringField(candidate, "sourceMeshId")} has an invalid index`);
|
|
}
|
|
return {
|
|
objectId: stringField(candidate, "objectId"),
|
|
meshId: stringField(candidate, "meshId"),
|
|
sourceMeshId: stringField(candidate, "sourceMeshId"),
|
|
vertexCount,
|
|
triangleCount,
|
|
modifierCount,
|
|
modifiers,
|
|
worldMatrix,
|
|
positions,
|
|
indices,
|
|
};
|
|
});
|
|
const objectCount = countField(value, "objectCount");
|
|
const meshObjectCount = countField(value, "meshObjectCount");
|
|
if (objects.length !== objectCount) throw new Error("Blender Depsgraph object count is inconsistent");
|
|
if (meshes.length !== meshObjectCount) throw new Error("Blender Depsgraph mesh object count is inconsistent");
|
|
const armatures = value.armatures === undefined ? undefined : armatureReports(value.armatures);
|
|
const nonMeshGeometries = value.nonMeshGeometries === undefined ? undefined : (() => {
|
|
if (!Array.isArray(value.nonMeshGeometries)) throw new Error("Depsgraph non-mesh geometries are invalid");
|
|
return value.nonMeshGeometries.map((candidate): DepsgraphNonMeshGeometryIR => {
|
|
if (!isRecord(candidate)) throw new Error("Depsgraph non-mesh geometry entry is invalid");
|
|
const sourceType = stringField(candidate, "sourceType");
|
|
const status = stringField(candidate, "status");
|
|
if (!["CURVE", "SURFACE", "FONT", "METABALL"].includes(sourceType) || (status !== "EVALUATED" && status !== "BLOCKED")) throw new Error("Depsgraph non-mesh geometry type or status is invalid");
|
|
const vertexCount = countField(candidate, "vertexCount");
|
|
const edgeCount = countField(candidate, "edgeCount");
|
|
const triangleCount = countField(candidate, "triangleCount");
|
|
const worldMatrix = numberArray(candidate, "worldMatrix");
|
|
if (worldMatrix.length !== 16) throw new Error("Depsgraph non-mesh world matrix is invalid");
|
|
const materialSlotIds = candidate.materialSlotIds;
|
|
if (!Array.isArray(materialSlotIds) || materialSlotIds.some((item) => typeof item !== "string")) throw new Error("Depsgraph non-mesh material slots are invalid");
|
|
const common = {
|
|
objectId: stringField(candidate, "objectId"),
|
|
sourceDataId: stringField(candidate, "sourceDataId"),
|
|
sourceType: sourceType as DepsgraphNonMeshGeometryIR["sourceType"],
|
|
meshId: stringField(candidate, "meshId"),
|
|
status: status as DepsgraphNonMeshGeometryIR["status"],
|
|
vertexCount,
|
|
edgeCount,
|
|
triangleCount,
|
|
worldMatrix,
|
|
materialSlotIds: materialSlotIds as string[],
|
|
sourceMappingStatus: stringField(candidate, "sourceMappingStatus") as DepsgraphNonMeshGeometryIR["sourceMappingStatus"],
|
|
};
|
|
if (common.sourceMappingStatus !== "EVALUATED_FACE" && common.sourceMappingStatus !== "EVALUATED_EDGE") throw new Error("Depsgraph non-mesh source mapping status is invalid");
|
|
if (status === "BLOCKED") {
|
|
if (candidate.errorCode !== "NON_MESH_DATA_BUDGET_EXCEEDED") throw new Error("Depsgraph blocked non-mesh geometry has no budget error");
|
|
return { ...common, errorCode: candidate.errorCode };
|
|
}
|
|
const positions = numberArray(candidate, "positions");
|
|
const normals = numberArray(candidate, "normals");
|
|
const edgeVertexIndices = numberArray(candidate, "edgeVertexIndices");
|
|
const indices = numberArray(candidate, "indices");
|
|
const uvs = numberArray(candidate, "uvs");
|
|
const triangleMaterialIndices = numberArray(candidate, "triangleMaterialIndices");
|
|
const sourceElementIndices = numberArray(candidate, "sourceElementIndices");
|
|
if (positions.length !== vertexCount * 3 || normals.length !== vertexCount * 3 || edgeVertexIndices.length !== edgeCount * 2 || indices.length !== triangleCount * 3 || (uvs.length !== 0 && uvs.length !== triangleCount * 3 * 2) || triangleMaterialIndices.length !== triangleCount || sourceElementIndices.length !== triangleCount) throw new Error(`Depsgraph non-mesh ${common.sourceDataId} buffer lengths are inconsistent`);
|
|
if (edgeVertexIndices.some((item) => !Number.isSafeInteger(item) || item < 0 || item >= vertexCount) || indices.some((item) => !Number.isSafeInteger(item) || item < 0 || item >= vertexCount) || triangleMaterialIndices.some((item) => !Number.isSafeInteger(item) || item < 0) || sourceElementIndices.some((item) => !Number.isSafeInteger(item) || item < 0)) throw new Error(`Depsgraph non-mesh ${common.sourceDataId} indices are invalid`);
|
|
return { ...common, positions, normals, edgeVertexIndices, indices, uvs, triangleMaterialIndices, sourceElementIndices };
|
|
});
|
|
})();
|
|
return {
|
|
engine: "BlenderDepsgraph",
|
|
status: "EVALUATED",
|
|
scene: stringField(value, "scene"),
|
|
viewLayer: stringField(value, "viewLayer"),
|
|
frame: numberField(value, "frame"),
|
|
objectCount,
|
|
meshObjectCount,
|
|
objects,
|
|
meshes,
|
|
...(nonMeshGeometries === undefined ? {} : { nonMeshGeometries }),
|
|
...(armatures === undefined ? {} : { armatures }),
|
|
};
|
|
}
|