rig-review 1.5.4 → 1.6.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/docs/PARTS_VIEW.md +66 -1
- package/package.json +4 -2
- package/src/cli.ts +3 -3
- package/src/parts-server.ts +20 -3
- package/src/parts-view.ts +139 -13
- package/web/catalog-en.ts +6 -0
- package/web/catalog-ko.ts +6 -0
- package/web/parts-render.ts +38 -0
- package/web/parts.css +7 -0
- package/web/parts.ts +41 -7
package/docs/PARTS_VIEW.md
CHANGED
|
@@ -10,7 +10,7 @@ npx rig-review parts <out>/rig # the same package, named directly
|
|
|
10
10
|
npx rig-review parts <out>/check # a built rig's atlas (any review package with a compiled model)
|
|
11
11
|
```
|
|
12
12
|
|
|
13
|
-
Options: `--mesh-report <file>`, `--check <file>` (producer flags; see below), `--verdict <file>` (where the sign-off
|
|
13
|
+
Options: `--rig <file>` (mesh geometry), `--mesh-report <file>`, `--check <file>` (producer flags; see below), `--verdict <file>` (where the sign-off
|
|
14
14
|
is written), `--port <n>`. Like `review`, it serves in the foreground and exits 3 s after its last tab closes.
|
|
15
15
|
|
|
16
16
|
## Inputs
|
|
@@ -73,6 +73,14 @@ Refusals, by name: `PARTS_VERDICT_MISSING_PART`, `PARTS_VERDICT_UNKNOWN_PART`, `
|
|
|
73
73
|
`PARTS_VERDICT_NOT_CLEAN`, `PARTS_VERDICT_NOTHING_FLAGGED`, `PARTS_VERDICT_INVALID`, and `PARTS_VIEW_SOURCE_CHANGED`
|
|
74
74
|
when a file changed after the view opened.
|
|
75
75
|
|
|
76
|
+
A verdict destination matching a protected part, producer report, rig/package input, model or atlas image is
|
|
77
|
+
refused as `PARTS_VERDICT_INPUT_COLLISION`, including normalized paths, symbolic links and filesystem aliases.
|
|
78
|
+
Choose a separate verdict file; saving an existing verdict again remains supported.
|
|
79
|
+
|
|
80
|
+
Sign-off JSON requests are limited to 4 MiB (4,194,304 bytes) of UTF-8 while streaming. An over-limit body is
|
|
81
|
+
cancelled before its remainder is read; a valid request exactly at the byte limit is accepted. Same-origin and
|
|
82
|
+
write-capability requirements remain unchanged.
|
|
83
|
+
|
|
76
84
|
On reopen, a saved sign-off is offered only when both `source.sha256` and `source.flags` match the files on disk. When
|
|
77
85
|
only the producer flags differ, the page says the saved sign-off is for different producer flags and starts fresh.
|
|
78
86
|
Consumers that gate on the sign-off (rig-c/create) check `source.sha256`.
|
|
@@ -83,3 +91,60 @@ as `PARTS_IMAGE_OUTSIDE` / `PARTS_FILE_OUTSIDE`, and a discovered `mesh_report.j
|
|
|
83
91
|
(`--mesh-report`, `--check`) is read where it is.
|
|
84
92
|
|
|
85
93
|
Editing parts is out of scope: repairs go through the producer's source ladder, never the browser.
|
|
94
|
+
|
|
95
|
+
## Mesh geometry
|
|
96
|
+
|
|
97
|
+
In parts mode, a `rig.json` beside `parts.json` supplies optional mesh geometry;
|
|
98
|
+
`--rig <file>` selects an explicit input instead. The per-part **mesh from
|
|
99
|
+
rig.json UVs** toggle starts off. It draws edges and vertices over the sentinel
|
|
100
|
+
background, and tints nontransparent art pixels pink when their centres lie
|
|
101
|
+
outside every nondegenerate triangle (triangle boundaries count as covered).
|
|
102
|
+
The mesh outcome has its own Pending / Clean / Flagged states and note; Flagged
|
|
103
|
+
requires a note. Approval requires both part and mesh outcomes to be Clean.
|
|
104
|
+
A part without a mesh has no mesh controls or outcome.
|
|
105
|
+
|
|
106
|
+
Image-space positions are `(u × width, v × height)` from each attachment's own
|
|
107
|
+
UVs and dimensions, never reconstructed through bones or weights. The mesh's raster
|
|
108
|
+
is the rig image; the parts PNG is located inside it by pixel equality. The
|
|
109
|
+
attachment's literal `image` under the rig spec's literal `images` directory must
|
|
110
|
+
be a local PNG of exactly the declared dimensions. Its centred window must match
|
|
111
|
+
the parts PNG RGBA exactly, and every pixel outside must have alpha zero. The
|
|
112
|
+
window offset `((W-w)/2,(H-h)/2)` is subtracted from mesh positions. Fractional
|
|
113
|
+
or negative offsets refuse; no padding constant is assumed. Border vertices
|
|
114
|
+
are allowed and drawn clipped. The rig raster is hashed in `source.files`. The producer
|
|
115
|
+
rounds UVs to six decimals: the coordinate error is at most `0.5e-6 × dimension`
|
|
116
|
+
pixels on each axis (for a 598×465 image, at most 0.000299 and 0.0002325 px).
|
|
117
|
+
The overlay cannot show this subpixel error, and coverage tint works at whole
|
|
118
|
+
pixels, so it cannot move a tinted pixel unless a triangle edge lies within that
|
|
119
|
+
rounding distance of a pixel centre. Coverage describes these derived triangles,
|
|
120
|
+
not an exact recovery of the producer's original unrounded positions.
|
|
121
|
+
|
|
122
|
+
Mode, vertex count, triangle count, `art_coverage` and `stray_cleared` are copied
|
|
123
|
+
from the part's `mesh_report.json` row without recomputing them. Absent fields
|
|
124
|
+
say **not reported**; faint islands remain in Producer flags. A report count may
|
|
125
|
+
differ from the loaded geometry; it is the producer's reading. The verdict's
|
|
126
|
+
`parts[name].mesh` contains `{outcome,note}` only for a mesh-bearing part.
|
|
127
|
+
`rig.json` and the loaded mesh report enter `source.files`, and the mesh report
|
|
128
|
+
also remains in `source.flags`. Changes invalidate the saved sign-off. No rig
|
|
129
|
+
means the existing parts view and verdict format remain unchanged.
|
|
130
|
+
|
|
131
|
+
| Refusal | Found / required |
|
|
132
|
+
| --- | --- |
|
|
133
|
+
| `PARTS_MESH_UNKNOWN_PART` | An attachment name not in parts.json / a known part |
|
|
134
|
+
| `PARTS_MESH_UV` | Invalid coordinate pairs or UV outside [0,1] / finite UV pairs in [0,1] |
|
|
135
|
+
| `PARTS_MESH_TRIANGLE` | Invalid triples or index / integer indices within the vertex array |
|
|
136
|
+
| `PARTS_MESH_SIZE` | Invalid declared dimensions / positive integer dimensions and image |
|
|
137
|
+
| `PARTS_MESH_IMAGE_SIZE` | Raster size / attachment dimensions |
|
|
138
|
+
| `PARTS_MESH_IMAGE_MISMATCH` | First differing RGBA pixel, nontransparent border or incompatible crop / exact centred window and transparent border |
|
|
139
|
+
| `PARTS_MESH_IMAGE_PATH` | Unsafe or missing rig raster / literal inside path |
|
|
140
|
+
| `PARTS_MESH_IMAGE_FORMAT` | Undecodable raster / PNG |
|
|
141
|
+
| `PARTS_MESH_AMBIGUOUS` | Multiple mesh attachments for one name / one mesh |
|
|
142
|
+
| `PARTS_MESH_REPORT_AMBIGUOUS` | Multiple report rows for a mesh part / at most one |
|
|
143
|
+
| `PARTS_MESH_MALFORMED` | Missing skins object / a rig spec with skins |
|
|
144
|
+
| `PARTS_MESH_OUTSIDE` | A discovered rig symlink escaping the package / an inside file |
|
|
145
|
+
| `PARTS_MESH_OUTCOME` | Missing or invalid mesh outcome or oversized note / a valid outcome and bounded note |
|
|
146
|
+
| `PARTS_MESH_OUTCOME_UNAVAILABLE` | Mesh outcome on a part without a mesh / no mesh outcome |
|
|
147
|
+
|
|
148
|
+
Explicit CLI file paths are the user's designation, as with `--mesh-report`;
|
|
149
|
+
discovered paths cannot escape the package. This view never writes geometry,
|
|
150
|
+
bones, weights or source images. Repairs remain producer config changes.
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "rig-review",
|
|
3
|
-
"version": "1.
|
|
3
|
+
"version": "1.6.0",
|
|
4
4
|
"type": "module",
|
|
5
5
|
"description": "Local human rig inspection and structured feedback export",
|
|
6
6
|
"license": "MIT",
|
|
@@ -19,10 +19,12 @@
|
|
|
19
19
|
},
|
|
20
20
|
"dependencies": {
|
|
21
21
|
"@napi-rs/canvas": "1.0.11",
|
|
22
|
-
"@rig-c/play": "1.23.0"
|
|
22
|
+
"@rig-c/play": "1.23.0",
|
|
23
|
+
"pngjs": "7.0.0"
|
|
23
24
|
},
|
|
24
25
|
"devDependencies": {
|
|
25
26
|
"@types/bun": "^1.3.0",
|
|
27
|
+
"@types/pngjs": "6.0.5",
|
|
26
28
|
"typescript": "^5.9.3"
|
|
27
29
|
},
|
|
28
30
|
"engines": {
|
package/src/cli.ts
CHANGED
|
@@ -22,7 +22,7 @@ import { readCompareSession } from './compare-session.ts';
|
|
|
22
22
|
import { exportReviewStrip, exportCompareStrip, stripJson, writeStripOutput, validateStripOutput } from './strip-export.ts';
|
|
23
23
|
import type { StripInterval, StripRequest } from './strip.ts';
|
|
24
24
|
const handoffUsage='[--config <path> [--parts <dir>] [--source <png> --full <dir> [--head <dir>]] [--keypoints <file>]]';
|
|
25
|
-
const usage='Usage: rig-review open <dir> [--reference <video>] [--compare <dir>] [--animation <name>] [--control] [--direct] [--view-only] '+handoffUsage+'\n --config declares the producer handoff (wins over the review.json "producer" block and discovery of config.json, rig/config.json, ../config.json beside an opened out/); feedback and control take the same flags; --view-only opens without a producer handoff.\n open is managed by default: one loopback front at 127.0.0.1:4318 (RIG_REVIEW_FRONT_PORT overrides) serves /instances/<key>/; --direct serves the worker on its own port.\n rig-review control <dir> [--reference <video>] [--compare <dir>] [--animation <name>] '+handoffUsage+' [--page <id> --expected-revision <n> --command <JSON> --wait-ms <n>]\n rig-review feedback <dir> [--reference <video>] [--compare <dir>] [--animation <name>] '+handoffUsage+' [--format json|issue]\n Usage: bun run review -- <review.json|output-directory> [--port 4317] [--checkpoint ID] [--view-only]\n bun run check -- <review.json|output-directory>\n bun run feedback -- <review.json|output-directory>\n bun run review -- compare <a> <b> --reference <video> --animation <name> [--port 4317]\n bun run check -- compare <a> <b> --reference <video> --animation <name>\n bun run feedback -- compare <a> <b> --reference <video> --animation <name>\n rig-review parts <build root | parts dir | review package> [--mesh-report <file>] [--check <file>] [--verdict <file>] [--port <n>]\n rig-review --version';
|
|
25
|
+
const usage='Usage: rig-review open <dir> [--reference <video>] [--compare <dir>] [--animation <name>] [--control] [--direct] [--view-only] '+handoffUsage+'\n --config declares the producer handoff (wins over the review.json "producer" block and discovery of config.json, rig/config.json, ../config.json beside an opened out/); feedback and control take the same flags; --view-only opens without a producer handoff.\n open is managed by default: one loopback front at 127.0.0.1:4318 (RIG_REVIEW_FRONT_PORT overrides) serves /instances/<key>/; --direct serves the worker on its own port.\n rig-review control <dir> [--reference <video>] [--compare <dir>] [--animation <name>] '+handoffUsage+' [--page <id> --expected-revision <n> --command <JSON> --wait-ms <n>]\n rig-review feedback <dir> [--reference <video>] [--compare <dir>] [--animation <name>] '+handoffUsage+' [--format json|issue]\n Usage: bun run review -- <review.json|output-directory> [--port 4317] [--checkpoint ID] [--view-only]\n bun run check -- <review.json|output-directory>\n bun run feedback -- <review.json|output-directory>\n bun run review -- compare <a> <b> --reference <video> --animation <name> [--port 4317]\n bun run check -- compare <a> <b> --reference <video> --animation <name>\n bun run feedback -- compare <a> <b> --reference <video> --animation <name>\n rig-review parts <build root | parts dir | review package> [--rig <file>] [--mesh-report <file>] [--check <file>] [--verdict <file>] [--port <n>]\n rig-review --version';
|
|
26
26
|
async function stripCommand(args:string[],options:{stateDir?:string}){
|
|
27
27
|
const compare=args[0]==='compare';if(compare)args.shift();const a=args.shift(),b=compare?args.shift():undefined;if(!a||compare&&!b)throw new Error('strip: expected package input(s)');
|
|
28
28
|
let reference:string|undefined,referenceVideo:string|undefined,animation:string|undefined,basis:'a'|'b'|undefined,range:string|undefined,output:string|undefined,jsonOnly=false,all=false;
|
|
@@ -95,13 +95,13 @@ function commandHelpRequested(args:readonly string[],command:'open'|'review'|'ch
|
|
|
95
95
|
}
|
|
96
96
|
return false;
|
|
97
97
|
}
|
|
98
|
-
const partsUsage='Usage: rig-review parts <build root | parts dir | review package> [--mesh-report <file>] [--check <file>] [--verdict <file>] [--port <n>]\n A directory holding parts.json (or a build root whose rig/ holds it) opens in parts mode, before rigging; a review package or check/ folder opens its atlas.\n The sign-off is written to parts-review.json beside parts.json (or the model), or to --verdict.';
|
|
98
|
+
const partsUsage='Usage: rig-review parts <build root | parts dir | review package> [--rig <file>] [--mesh-report <file>] [--check <file>] [--verdict <file>] [--port <n>]\n A directory holding parts.json (or a build root whose rig/ holds it) opens in parts mode, before rigging; a review package or check/ folder opens its atlas.\n The sign-off is written to parts-review.json beside parts.json (or the model), or to --verdict.';
|
|
99
99
|
/** `rig-review parts` (#348): the parts and atlas view, served in the foreground; exits when its last tab closes. */
|
|
100
100
|
async function partsCommand(args:string[]){
|
|
101
101
|
const input=args.shift();if(!input||input==='--help'||input==='-h'){console.log(partsUsage);return;}
|
|
102
102
|
const options:PartsViewOptions={};let port=4317;const seen=new Set<string>();
|
|
103
103
|
while(args.length){const flag=args.shift()!;if(flag==='--help'||flag==='-h'){console.log(partsUsage);return;}if(seen.has(flag))throw new Error(`parts: duplicate option ${flag}`);seen.add(flag);const value=args.shift();if(!value)throw new Error(`Missing value for ${flag}`);
|
|
104
|
-
if(flag==='--mesh-report')options.meshReport=value;else if(flag==='--check')options.check=value;else if(flag==='--verdict')options.verdict=value;
|
|
104
|
+
if(flag==='--rig')options.rig=value;else if(flag==='--mesh-report')options.meshReport=value;else if(flag==='--check')options.check=value;else if(flag==='--verdict')options.verdict=value;
|
|
105
105
|
else if(flag==='--port'){port=Number(value);if(!Number.isInteger(port)||port<0||port>65535)throw new Error('--port: expected integer 0..65535');}
|
|
106
106
|
else throw new Error(`Unknown option ${flag}\n${partsUsage}`);}
|
|
107
107
|
const pkg=await loadPartsView(input,options);
|
package/src/parts-server.ts
CHANGED
|
@@ -11,9 +11,26 @@ const BODY_LIMIT = 4 * 1024 * 1024;
|
|
|
11
11
|
|
|
12
12
|
async function bodyJson(req: Request): Promise<unknown> {
|
|
13
13
|
if (!/^application\/json(?:\s*;|$)/i.test(req.headers.get('content-type') ?? '')) throw new Error('Expected application/json');
|
|
14
|
-
const
|
|
15
|
-
if (
|
|
16
|
-
|
|
14
|
+
const reader = req.body?.getReader();
|
|
15
|
+
if (!reader) return JSON.parse('');
|
|
16
|
+
const chunks: Uint8Array[] = [];
|
|
17
|
+
let bytes = 0;
|
|
18
|
+
try {
|
|
19
|
+
for (;;) {
|
|
20
|
+
const { value, done } = await reader.read();
|
|
21
|
+
if (done) break;
|
|
22
|
+
bytes += value.byteLength;
|
|
23
|
+
if (bytes > BODY_LIMIT) {
|
|
24
|
+
await reader.cancel().catch(() => {});
|
|
25
|
+
throw new Error('Verdict payload exceeds 4 MiB');
|
|
26
|
+
}
|
|
27
|
+
chunks.push(value);
|
|
28
|
+
}
|
|
29
|
+
} finally { reader.releaseLock(); }
|
|
30
|
+
const body = new Uint8Array(bytes);
|
|
31
|
+
let offset = 0;
|
|
32
|
+
for (const chunk of chunks) { body.set(chunk, offset); offset += chunk.byteLength; }
|
|
33
|
+
return JSON.parse(new TextDecoder().decode(body));
|
|
17
34
|
}
|
|
18
35
|
|
|
19
36
|
export interface PartsServerOptions { port?: number; capability?: string; exitOnClose?: boolean; graceMs?: number; unopenedTimeoutMs?: number; onClose?: (info: LiveExitInfo) => void | Promise<void>; log?: (line: string) => void }
|
package/src/parts-view.ts
CHANGED
|
@@ -16,9 +16,10 @@
|
|
|
16
16
|
*/
|
|
17
17
|
import { createHash } from 'node:crypto';
|
|
18
18
|
import { existsSync } from 'node:fs';
|
|
19
|
-
import { mkdir, readFile, realpath, rename, stat, writeFile } from 'node:fs/promises';
|
|
19
|
+
import { mkdir, readFile, realpath, rename, rm, stat, writeFile } from 'node:fs/promises';
|
|
20
20
|
import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from 'node:path';
|
|
21
|
-
import {
|
|
21
|
+
import { PNG } from 'pngjs';
|
|
22
|
+
import { loadReview, safeFile, packagePath } from './manifest.ts';
|
|
22
23
|
|
|
23
24
|
export const PARTS_VERDICT_SCHEMA = 'rig-review-parts-verdict/1';
|
|
24
25
|
export const PARTS_VERDICT_FILE = 'parts-review.json';
|
|
@@ -32,7 +33,9 @@ export interface HashedFile { path: string; bytes: number; sha256: string }
|
|
|
32
33
|
interface LocalFile { abs: string; bytes: number; sha256: string }
|
|
33
34
|
|
|
34
35
|
/** A part (parts mode) or a named region (atlas mode). Boxes are rig px (parts) or page px (atlas). */
|
|
36
|
+
export interface PartMesh { vertices: number[]; triangles: number[]; figures: Record<string, unknown>; width: number; height: number; image: string }
|
|
35
37
|
export interface ViewItem {
|
|
38
|
+
mesh?: PartMesh;
|
|
36
39
|
name: string;
|
|
37
40
|
/** Draw order, back first (parts mode); the region's place in the atlas file (atlas mode). */
|
|
38
41
|
index: number;
|
|
@@ -65,13 +68,15 @@ export interface PartsViewPackage {
|
|
|
65
68
|
flagFiles: LocalFile[];
|
|
66
69
|
/** Where flags were looked for and not found, said in words. */
|
|
67
70
|
flagNotes: string[];
|
|
71
|
+
/** Additional package/producer inputs protected from verdict writes, without changing verdict identity. */
|
|
72
|
+
protectedPaths?: string[];
|
|
68
73
|
verdictPath: string;
|
|
69
74
|
/** Absolute paths, served by index. */
|
|
70
75
|
imagePaths: string[];
|
|
71
76
|
pagePaths: string[];
|
|
72
77
|
}
|
|
73
78
|
|
|
74
|
-
export interface PartsViewOptions { meshReport?: string; check?: string; verdict?: string }
|
|
79
|
+
export interface PartsViewOptions { rig?: string; meshReport?: string; check?: string; verdict?: string }
|
|
75
80
|
|
|
76
81
|
const record = (v: unknown): Record<string, unknown> | null => v && typeof v === 'object' && !Array.isArray(v) ? v as Record<string, unknown> : null;
|
|
77
82
|
const finite = (v: unknown, min: number): v is number => typeof v === 'number' && Number.isFinite(v) && v >= min;
|
|
@@ -196,6 +201,70 @@ async function producerFlags(rigDir: string | null, buildRoot: string | null, na
|
|
|
196
201
|
return { flags, files, notes };
|
|
197
202
|
}
|
|
198
203
|
|
|
204
|
+
/** Exact attachment identity and UV-derived geometry; never reconstruct through weights. */
|
|
205
|
+
export function readPartMeshes(raw: unknown, items: ViewItem[], reports: unknown): void {
|
|
206
|
+
const skins = record(record(raw)?.skins);
|
|
207
|
+
if (!skins) refuse('PARTS_MESH_MALFORMED', 'rig.json requires skins object');
|
|
208
|
+
const byName = new Map(items.map(i => [i.name, i]));
|
|
209
|
+
for (const slots of Object.values(skins!)) for (const attachments of Object.values(record(slots) ?? {})) {
|
|
210
|
+
for (const [name, value] of Object.entries(record(attachments) ?? {})) {
|
|
211
|
+
const a = record(value);
|
|
212
|
+
if (a?.type !== 'mesh') continue;
|
|
213
|
+
const item = byName.get(name);
|
|
214
|
+
if (!item) refuse('PARTS_MESH_UNKNOWN_PART', `${name}: found mesh; required a part in parts.json`);
|
|
215
|
+
if (item!.mesh) refuse('PARTS_MESH_AMBIGUOUS', `${name}: found multiple meshes; required one attachment`);
|
|
216
|
+
if (!finite(a.width, 1) || !Number.isInteger(a.width) || !finite(a.height, 1) || !Number.isInteger(a.height) || typeof a.image !== 'string') refuse('PARTS_MESH_SIZE', `${name}: found invalid raster declaration; required image and positive integer dimensions`);
|
|
217
|
+
const uv = a.uvs, triangles = a.triangles;
|
|
218
|
+
if (!Array.isArray(uv) || !uv.length || uv.length % 2) refuse('PARTS_MESH_UV', `${name}: found invalid uvs; required nonempty coordinate pairs in [0,1]`);
|
|
219
|
+
for (const v of uv as unknown[]) if (!finite(v, 0) || v > 1) refuse('PARTS_MESH_UV', `${name}: found ${String(v)}; required UV in [0,1]`);
|
|
220
|
+
const count = (uv as number[]).length / 2;
|
|
221
|
+
if (!Array.isArray(triangles) || !triangles.length || triangles.length % 3) refuse('PARTS_MESH_TRIANGLE', `${name}: found invalid triangles; required nonempty index triples`);
|
|
222
|
+
for (const v of triangles as unknown[]) if (typeof v !== 'number' || !Number.isInteger(v) || v < 0 || v >= count) refuse('PARTS_MESH_TRIANGLE', `${name}: found ${String(v)}; required integer index in [0,${count - 1}]`);
|
|
223
|
+
const rows = Array.isArray(reports) ? reports.filter(r => record(r)?.part === name) : [];
|
|
224
|
+
if (rows.length > 1) refuse('PARTS_MESH_REPORT_AMBIGUOUS', `${name}: found ${rows.length} report rows; required at most one`);
|
|
225
|
+
const row = record(rows[0]) ?? {}, figures: Record<string, unknown> = {};
|
|
226
|
+
for (const field of ['mode', 'vertices', 'triangles', 'art_coverage', 'stray_cleared']) if (Object.hasOwn(row, field)) figures[field] = row[field];
|
|
227
|
+
item!.mesh = { vertices: (uv as number[]).map((v, i) => v * (i % 2 ? a.height as number : a.width as number)), triangles: triangles as number[], figures, width: a.width as number, height: a.height as number, image: a.image as string };
|
|
228
|
+
}
|
|
229
|
+
}
|
|
230
|
+
}
|
|
231
|
+
|
|
232
|
+
/** Prove the crop window in the mesh raster byte-for-byte; accept no inferred producer padding. */
|
|
233
|
+
async function locateMeshRasters(rig: unknown, root: string, items: ViewItem[], images: string[], files: LocalFile[]): Promise<void> {
|
|
234
|
+
const directory = record(rig)?.images;
|
|
235
|
+
for (const item of items) {
|
|
236
|
+
const mesh = item.mesh; if (!mesh) continue;
|
|
237
|
+
let path: string;
|
|
238
|
+
try {
|
|
239
|
+
// Validate both literal components before joining: normalization must not hide traversal.
|
|
240
|
+
path = await safeFile(root, `${packagePath(directory, 'rig.images')}/${packagePath(mesh.image, 'mesh.image')}`);
|
|
241
|
+
} catch { return refuse('PARTS_MESH_IMAGE_PATH', `${item.name}: found unavailable or unsafe rig image; required a literal local raster inside the rig directory`); }
|
|
242
|
+
const bytes = await readFile(path);
|
|
243
|
+
let image: ReturnType<typeof PNG.sync.read>, part: ReturnType<typeof PNG.sync.read>;
|
|
244
|
+
try {
|
|
245
|
+
const partBytes = await readFile(images[item.index]!);
|
|
246
|
+
image = PNG.sync.read(bytes); part = PNG.sync.read(partBytes);
|
|
247
|
+
// Retain all sixteen bits where present; 8-bit downsampling would hide a differing sample.
|
|
248
|
+
if (image.depth === 16) image = PNG.sync.read(bytes, { skipRescale: true });
|
|
249
|
+
if (part.depth === 16) part = PNG.sync.read(partBytes, { skipRescale: true });
|
|
250
|
+
}
|
|
251
|
+
catch { return refuse('PARTS_MESH_IMAGE_FORMAT', `${item.name}: found undecodable PNG; required PNG raster`); }
|
|
252
|
+
if (image.width !== mesh.width || image.height !== mesh.height) refuse('PARTS_MESH_IMAGE_SIZE', `${item.name}: found ${image.width}×${image.height}; required ${mesh.width}×${mesh.height}`);
|
|
253
|
+
const ox = (mesh.width - part.width) / 2, oy = (mesh.height - part.height) / 2;
|
|
254
|
+
if (part.width !== item.w || part.height !== item.h || ox < 0 || oy < 0 || !Number.isInteger(ox) || !Number.isInteger(oy)) refuse('PARTS_MESH_IMAGE_MISMATCH', `${item.name}: found incompatible raster window ${ox},${oy}; required a centred integer window of ${item.w}×${item.h}`);
|
|
255
|
+
const raster = image.data, original = part.data;
|
|
256
|
+
const rasterScale = image.depth === 16 ? 1 : 257, partScale = part.depth === 16 ? 1 : 257;
|
|
257
|
+
for (let y = 0; y < image.height; y++) for (let x = 0; x < image.width; x++) {
|
|
258
|
+
const i = (y * image.width + x) * 4;
|
|
259
|
+
const inside = x >= ox && x < ox + part.width && y >= oy && y < oy + part.height;
|
|
260
|
+
const j = ((y - oy) * part.width + x - ox) * 4;
|
|
261
|
+
if (inside ? [0, 1, 2, 3].some(c => raster[i + c]! * rasterScale !== original[j + c]! * partScale) : raster[i + 3] !== 0) refuse('PARTS_MESH_IMAGE_MISMATCH', `${item.name}: first differing rig pixel (${x},${y}) found RGBA [${[...raster.slice(i, i + 4)]}]; required ${inside ? `RGBA [${[...original.slice(j, j + 4)]}]` : 'border alpha 0'}`);
|
|
262
|
+
}
|
|
263
|
+
mesh.vertices = mesh.vertices.map((v, i) => v - (i % 2 ? oy : ox));
|
|
264
|
+
files.push({ abs: path, bytes: bytes.length, sha256: createHash('sha256').update(bytes).digest('hex') });
|
|
265
|
+
}
|
|
266
|
+
}
|
|
267
|
+
|
|
199
268
|
async function loadPartsMode(root: string, options: PartsViewOptions): Promise<PartsViewPackage> {
|
|
200
269
|
const partsJson = await insideRoot(root, join(root, 'parts.json'), 'PARTS_FILE_OUTSIDE', 'parts.json');
|
|
201
270
|
const doc = record(await readJson(partsJson, 'parts.json'));
|
|
@@ -220,7 +289,25 @@ async function loadPartsMode(root: string, options: PartsViewOptions): Promise<P
|
|
|
220
289
|
items.push({ name: part.name, index, x: part.x, y: part.y, w: part.w, h: part.h, image: true });
|
|
221
290
|
}
|
|
222
291
|
const { flags, files: flagFiles, notes } = await producerFlags(root, null, seen, options);
|
|
223
|
-
|
|
292
|
+
const protectedPaths = [join(root, 'rig.json'), join(root, 'config.json'), join(root, 'review.json'), join(root, 'report.json')];
|
|
293
|
+
if (basename(root) === 'rig') protectedPaths.push(...['parts.json', 'config.json', 'review.json', 'report.json'].map(name => join(dirname(root), name)));
|
|
294
|
+
if (options.rig !== undefined) protectedPaths.push(resolve(options.rig));
|
|
295
|
+
const verdictPath = options.verdict ? resolve(options.verdict) : join(root, PARTS_VERDICT_FILE);
|
|
296
|
+
await assertVerdictDestination({ files, flagFiles, protectedPaths, verdictPath });
|
|
297
|
+
const rigPath = options.rig !== undefined ? resolve(options.rig) : existsSync(join(root, 'rig.json')) ? await insideRoot(root, join(root, 'rig.json'), 'PARTS_MESH_OUTSIDE', 'rig.json') : null;
|
|
298
|
+
if (rigPath) {
|
|
299
|
+
const report = notes.includes('mesh_report.json') ? undefined : flagFiles[0];
|
|
300
|
+
const rigBytes = await readFile(rigPath);
|
|
301
|
+
let rig: unknown;
|
|
302
|
+
try { rig = JSON.parse(rigBytes.toString('utf8')); }
|
|
303
|
+
catch (e) { return refuse('PARTS_MESH_MALFORMED', `rig.json: ${e instanceof Error ? e.message : String(e)}`); }
|
|
304
|
+
readPartMeshes(rig, items, report ? await readJson(report.abs, 'mesh_report.json') : null);
|
|
305
|
+
await locateMeshRasters(rig, dirname(rigPath), items, imagePaths, files);
|
|
306
|
+
// Bind exactly the bytes parsed above, even if the path is replaced during raster checks.
|
|
307
|
+
files.push({ abs: rigPath, bytes: rigBytes.length, sha256: createHash('sha256').update(rigBytes).digest('hex') });
|
|
308
|
+
if (report) files.push(report);
|
|
309
|
+
}
|
|
310
|
+
return { mode: 'parts', root, title: basename(root) === 'rig' ? basename(dirname(root)) : basename(root), rigSize, items, pages: [], flags, files, flagFiles, flagNotes: notes, protectedPaths, verdictPath, imagePaths, pagePaths: [] };
|
|
224
311
|
}
|
|
225
312
|
|
|
226
313
|
async function loadAtlasMode(input: string, options: PartsViewOptions): Promise<PartsViewPackage> {
|
|
@@ -251,7 +338,11 @@ async function loadAtlasMode(input: string, options: PartsViewOptions): Promise<
|
|
|
251
338
|
// A build root opens as its check package (#149); its own rig/ and check/ hold the flags.
|
|
252
339
|
const buildRoot = p.buildRoot ?? null;
|
|
253
340
|
const { flags, files: flagFiles, notes } = await producerFlags(null, buildRoot, names, options);
|
|
254
|
-
|
|
341
|
+
const protectedPaths = [...p.files].map(path => resolve(p.root, path));
|
|
342
|
+
protectedPaths.push(...['rig.json', 'config.json', 'report.json', 'review.json'].map(name => join(p.root, name)));
|
|
343
|
+
if (p.handoff) protectedPaths.push(...p.handoff.record.files.map(file => resolve(p.root, file.path)));
|
|
344
|
+
if (buildRoot) protectedPaths.push(...['parts.json', 'config.json', 'rig/rig.json', 'rig/parts.json'].map(name => join(buildRoot, name)));
|
|
345
|
+
return { mode: 'atlas', root: p.root, title: p.manifest.title, rigSize: null, items, pages, flags, files, flagFiles, flagNotes: notes, protectedPaths, verdictPath: options.verdict ? resolve(options.verdict) : join(dirname(modelAbs), PARTS_VERDICT_FILE), imagePaths: [], pagePaths };
|
|
255
346
|
}
|
|
256
347
|
|
|
257
348
|
/**
|
|
@@ -261,10 +352,30 @@ async function loadAtlasMode(input: string, options: PartsViewOptions): Promise<
|
|
|
261
352
|
export async function loadPartsView(input: string, options: PartsViewOptions = {}): Promise<PartsViewPackage> {
|
|
262
353
|
const abs = await realpath(resolve(input)).catch(() => refuse('PARTS_VIEW_INPUT_MISSING', `${input} does not exist`));
|
|
263
354
|
if ((await stat(abs)).isDirectory()) {
|
|
264
|
-
if (existsSync(join(abs, 'parts.json'))) return loadPartsMode(abs, options);
|
|
265
|
-
if (existsSync(join(abs, 'rig', 'parts.json')) && !existsSync(join(abs, 'review.json'))) return loadPartsMode(join(abs, 'rig'), options);
|
|
355
|
+
if (existsSync(join(abs, 'parts.json'))) return checkedVerdict(await loadPartsMode(abs, options));
|
|
356
|
+
if (existsSync(join(abs, 'rig', 'parts.json')) && !existsSync(join(abs, 'review.json'))) return checkedVerdict(await loadPartsMode(join(abs, 'rig'), options));
|
|
357
|
+
}
|
|
358
|
+
return checkedVerdict(await loadAtlasMode(input, options));
|
|
359
|
+
}
|
|
360
|
+
|
|
361
|
+
/** Compare names, real paths (including parent links), and filesystem identities before creating output. */
|
|
362
|
+
async function assertVerdictDestination(pkg: Pick<PartsViewPackage, 'files' | 'flagFiles' | 'protectedPaths' | 'verdictPath'>): Promise<void> {
|
|
363
|
+
const target = resolve(pkg.verdictPath);
|
|
364
|
+
const targetReal = await realpath(target).catch((e: NodeJS.ErrnoException) => { if (e.code !== 'ENOENT') throw e; return null; });
|
|
365
|
+
const targetStat = await stat(target, { bigint: true }).catch((e: NodeJS.ErrnoException) => { if (e.code !== 'ENOENT') throw e; return null; });
|
|
366
|
+
const parent = await realpath(dirname(target)).catch((e: NodeJS.ErrnoException) => { if (e.code !== 'ENOENT') throw e; return null; });
|
|
367
|
+
for (const path of [...pkg.files, ...pkg.flagFiles].map(file => file.abs).concat(pkg.protectedPaths ?? [])) {
|
|
368
|
+
const input = resolve(path);
|
|
369
|
+
const real = await realpath(input).catch((e: NodeJS.ErrnoException) => { if (e.code !== 'ENOENT') throw e; return null; });
|
|
370
|
+
const sameName = target === input || (real !== null && (targetReal === real || (parent !== null && join(parent, basename(target)) === real)));
|
|
371
|
+
const identity = targetStat && real ? await stat(real, { bigint: true }) : null;
|
|
372
|
+
if (sameName || (targetStat && identity && targetStat.dev === identity.dev && targetStat.ino === identity.ino)) refuse('PARTS_VERDICT_INPUT_COLLISION', `${basename(target)} is a protected input; choose a separate verdict file`);
|
|
266
373
|
}
|
|
267
|
-
|
|
374
|
+
}
|
|
375
|
+
|
|
376
|
+
async function checkedVerdict(pkg: PartsViewPackage): Promise<PartsViewPackage> {
|
|
377
|
+
await assertVerdictDestination(pkg);
|
|
378
|
+
return pkg;
|
|
268
379
|
}
|
|
269
380
|
|
|
270
381
|
/** The hashed files as the verdict records them: relative to the verdict file's directory. */
|
|
@@ -280,7 +391,7 @@ export interface PartsVerdict {
|
|
|
280
391
|
tool: { name: '@rig-c/review'; version: string };
|
|
281
392
|
source: ReturnType<typeof verdictSource>;
|
|
282
393
|
status: VerdictStatus;
|
|
283
|
-
parts: Record<string, { outcome: PartOutcome; note: string; flags: string[] }>;
|
|
394
|
+
parts: Record<string, { outcome: PartOutcome; note: string; flags: string[]; mesh?: { outcome: PartOutcome; note: string } }>;
|
|
284
395
|
updatedAt: string;
|
|
285
396
|
}
|
|
286
397
|
|
|
@@ -309,9 +420,20 @@ export function buildVerdict(pkg: Pick<PartsViewPackage, 'mode' | 'items' | 'fla
|
|
|
309
420
|
const note = entry.note === undefined ? '' : entry.note;
|
|
310
421
|
if (typeof note !== 'string' || note.length > PARTS_NOTE_LIMIT) return refuse('PARTS_VERDICT_INVALID', `${name}.note is a string of at most ${PARTS_NOTE_LIMIT} characters`);
|
|
311
422
|
if (outcome === 'flagged' && !note.trim()) return refuse('PARTS_VERDICT_NOTE_REQUIRED', `${name} is flagged and has no note saying what is wrong`);
|
|
312
|
-
|
|
423
|
+
const meshInput = record(entry.mesh);
|
|
424
|
+
const hasMesh = pkg.items.some(i => i.name === name && i.mesh);
|
|
425
|
+
if (!hasMesh && entry.mesh !== undefined) refuse('PARTS_MESH_OUTCOME_UNAVAILABLE', `${name}: no mesh; required no mesh outcome`);
|
|
426
|
+
let mesh: { outcome: PartOutcome; note: string } | undefined;
|
|
427
|
+
if (hasMesh) {
|
|
428
|
+
if (!meshInput || !['pending', 'clean', 'flagged'].includes(String(meshInput.outcome))) refuse('PARTS_MESH_OUTCOME', `${name}: required mesh outcome pending, clean or flagged`);
|
|
429
|
+
const meshNote = meshInput!.note ?? '';
|
|
430
|
+
if (typeof meshNote !== 'string' || meshNote.length > PARTS_NOTE_LIMIT) refuse('PARTS_MESH_OUTCOME', `${name}: required mesh note up to ${PARTS_NOTE_LIMIT} characters`);
|
|
431
|
+
if (meshInput!.outcome === 'flagged' && !(meshNote as string).trim()) refuse('PARTS_VERDICT_NOTE_REQUIRED', `${name}.mesh is flagged and has no note`);
|
|
432
|
+
mesh = { outcome: meshInput!.outcome as PartOutcome, note: meshNote as string };
|
|
433
|
+
}
|
|
434
|
+
parts[name] = { ...(mesh ? { mesh } : {}), outcome, note, flags: [...new Set(pkg.flags.filter(f => f.item === name).map(f => f.id))] };
|
|
313
435
|
}
|
|
314
|
-
const outcomes = Object.values(parts).
|
|
436
|
+
const outcomes = Object.values(parts).flatMap(p => p.mesh ? [p.outcome, p.mesh.outcome] : [p.outcome]);
|
|
315
437
|
if (status === 'approved' && outcomes.some(o => o !== 'clean')) refuse('PARTS_VERDICT_NOT_CLEAN', `approved needs every part clean; ${outcomes.filter(o => o !== 'clean').length} are not`);
|
|
316
438
|
if (status === 'changes-requested' && !outcomes.includes('flagged')) refuse('PARTS_VERDICT_NOTHING_FLAGGED', 'changes-requested needs at least one flagged part');
|
|
317
439
|
return { schema: PARTS_VERDICT_SCHEMA, mode: pkg.mode, tool: { name: '@rig-c/review', version }, source: verdictSource(pkg), status, parts, updatedAt: now.toISOString() };
|
|
@@ -331,12 +453,16 @@ async function packageVersion(): Promise<string> {
|
|
|
331
453
|
|
|
332
454
|
/** Writes the verdict atomically beside its sources. */
|
|
333
455
|
export async function saveVerdict(pkg: PartsViewPackage, input: unknown): Promise<PartsVerdict> {
|
|
456
|
+
await assertVerdictDestination(pkg);
|
|
334
457
|
await assertPartsUnchanged(pkg);
|
|
335
458
|
const verdict = buildVerdict(pkg, input, await packageVersion());
|
|
336
459
|
await mkdir(dirname(pkg.verdictPath), { recursive: true });
|
|
337
460
|
const tmp = `${pkg.verdictPath}.${crypto.randomUUID()}.tmp`;
|
|
338
|
-
|
|
339
|
-
|
|
461
|
+
try {
|
|
462
|
+
await writeFile(tmp, JSON.stringify(verdict, null, 2) + '\n', { flag: 'wx' });
|
|
463
|
+
await assertVerdictDestination(pkg);
|
|
464
|
+
await rename(tmp, pkg.verdictPath);
|
|
465
|
+
} finally { await rm(tmp, { force: true }); }
|
|
340
466
|
return verdict;
|
|
341
467
|
}
|
|
342
468
|
|
package/web/catalog-en.ts
CHANGED
|
@@ -3085,4 +3085,10 @@ export const enCatalog: Readonly<Record<string, string>> = {
|
|
|
3085
3085
|
"Page {name}: {width}×{height} px, 1 region. The background shows through padding; a region box is the packer's, and pixels outside it are bleed.": "Page {name}: {width}×{height} px, 1 region. The background shows through padding; a region box is the packer's, and pixels outside it are bleed.",
|
|
3086
3086
|
"Tinted: the footprint of the part drawn in front ({names}).": "Tinted: the footprint of the part drawn in front ({names}).",
|
|
3087
3087
|
"The saved sign-off is for different producer flags; this review starts fresh.": "The saved sign-off is for different producer flags; this review starts fresh.",
|
|
3088
|
+
"mesh from rig.json UVs": "mesh from rig.json UVs",
|
|
3089
|
+
"Mesh geometry": "Mesh geometry",
|
|
3090
|
+
"not reported": "not reported",
|
|
3091
|
+
"Pink: art pixels outside every triangle.": "Pink: art pixels outside every triangle.",
|
|
3092
|
+
"Mesh outcome": "Mesh outcome",
|
|
3093
|
+
"Mesh note": "Mesh note",
|
|
3088
3094
|
};
|
package/web/catalog-ko.ts
CHANGED
|
@@ -3085,4 +3085,10 @@ export const koCatalog: Readonly<Record<string, string>> = {
|
|
|
3085
3085
|
"Page {name}: {width}×{height} px, 1 region. The background shows through padding; a region box is the packer's, and pixels outside it are bleed.": "페이지 {name}: {width}×{height} px, 영역 1개. 패딩에는 배경이 비쳐 보이고, 영역 상자는 패커가 정한 것이며 상자 밖의 픽셀은 블리드입니다.",
|
|
3086
3086
|
"Tinted: the footprint of the part drawn in front ({names}).": "색칠된 부분: 앞에 그려지는 파츠의 풋프린트({names}).",
|
|
3087
3087
|
"The saved sign-off is for different producer flags; this review starts fresh.": "저장된 승인은 다른 프로듀서 플래그에 대해 내려진 것이라, 이번 검수는 처음부터 시작합니다.",
|
|
3088
|
+
"mesh from rig.json UVs": "rig.json UV로 계산한 메시",
|
|
3089
|
+
"Mesh geometry": "메시 형상",
|
|
3090
|
+
"not reported": "보고되지 않음",
|
|
3091
|
+
"Pink: art pixels outside every triangle.": "분홍색: 모든 삼각형 밖의 원화 픽셀.",
|
|
3092
|
+
"Mesh outcome": "메시 판정",
|
|
3093
|
+
"Mesh note": "메시 메모",
|
|
3088
3094
|
};
|
package/web/parts-render.ts
CHANGED
|
@@ -55,3 +55,41 @@ export function paintPart(ctx: Ctx, item: Box, image: Source, options: { bg: str
|
|
|
55
55
|
ctx.drawImage(mask, 0, 0);
|
|
56
56
|
ctx.globalAlpha = 1;
|
|
57
57
|
}
|
|
58
|
+
|
|
59
|
+
export interface MeshGeometry { vertices: readonly number[]; triangles: readonly number[] }
|
|
60
|
+
/** Closed triangle union at pixel centres. Degenerate triangles cover no area. */
|
|
61
|
+
export function meshCoverage(w: number, h: number, mesh: MeshGeometry): Uint8Array {
|
|
62
|
+
const mask = new Uint8Array(w * h), v = mesh.vertices;
|
|
63
|
+
const cross = (ax: number, ay: number, bx: number, by: number, x: number, y: number) => (bx - ax) * (y - ay) - (by - ay) * (x - ax);
|
|
64
|
+
for (let i = 0; i < mesh.triangles.length; i += 3) {
|
|
65
|
+
const a = mesh.triangles[i]! * 2, b = mesh.triangles[i + 1]! * 2, c = mesh.triangles[i + 2]! * 2;
|
|
66
|
+
const ax = v[a]!, ay = v[a + 1]!, bx = v[b]!, by = v[b + 1]!, cx = v[c]!, cy = v[c + 1]!;
|
|
67
|
+
if (cross(ax, ay, bx, by, cx, cy) === 0) continue;
|
|
68
|
+
for (let y = Math.max(0, Math.ceil(Math.min(ay, by, cy) - .5)); y <= Math.min(h - 1, Math.floor(Math.max(ay, by, cy) - .5)); y++) {
|
|
69
|
+
for (let x = Math.max(0, Math.ceil(Math.min(ax, bx, cx) - .5)); x <= Math.min(w - 1, Math.floor(Math.max(ax, bx, cx) - .5)); x++) {
|
|
70
|
+
const p = cross(ax, ay, bx, by, x + .5, y + .5), q = cross(bx, by, cx, cy, x + .5, y + .5), r = cross(cx, cy, ax, ay, x + .5, y + .5);
|
|
71
|
+
if ((p >= 0 && q >= 0 && r >= 0) || (p <= 0 && q <= 0 && r <= 0)) mask[y * w + x] = 1;
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
}
|
|
75
|
+
return mask;
|
|
76
|
+
}
|
|
77
|
+
/** Tint only nontransparent source-art pixels outside the triangle union, before drawing diagnostic edges. */
|
|
78
|
+
export function paintMesh(ctx: Ctx, source: Source, w: number, h: number, mesh: MeshGeometry, makeCanvas: (w: number, h: number) => HTMLCanvasElement): void {
|
|
79
|
+
const scratch = makeCanvas(w, h), s = scratch.getContext('2d')!;
|
|
80
|
+
s.drawImage(source, 0, 0);
|
|
81
|
+
const art = s.getImageData(0, 0, w, h), tint = s.createImageData(w, h), mask = meshCoverage(w, h, mesh);
|
|
82
|
+
for (let i = 0; i < mask.length; i++) if (!mask[i] && art.data[i * 4 + 3]) {
|
|
83
|
+
tint.data[i * 4] = 255; tint.data[i * 4 + 2] = 80; tint.data[i * 4 + 3] = 160;
|
|
84
|
+
}
|
|
85
|
+
s.putImageData(tint, 0, 0); ctx.drawImage(scratch, 0, 0);
|
|
86
|
+
ctx.strokeStyle = '#00bfff'; ctx.fillStyle = '#ffffff'; ctx.lineWidth = .5;
|
|
87
|
+
ctx.beginPath();
|
|
88
|
+
const v = mesh.vertices;
|
|
89
|
+
for (let i = 0; i < mesh.triangles.length; i += 3) {
|
|
90
|
+
for (let j = 0; j < 3; j++) { const a = mesh.triangles[i + j]! * 2; if (!j) ctx.moveTo(v[a]!, v[a + 1]!); else ctx.lineTo(v[a]!, v[a + 1]!); }
|
|
91
|
+
ctx.closePath();
|
|
92
|
+
}
|
|
93
|
+
ctx.stroke();
|
|
94
|
+
for (let i = 0; i < v.length; i += 2) { ctx.beginPath(); ctx.arc(v[i]!, v[i + 1]!, .8, 0, Math.PI * 2); ctx.fill(); }
|
|
95
|
+
}
|
package/web/parts.css
CHANGED
|
@@ -49,3 +49,10 @@ h2{font-size:11px;letter-spacing:.06em;color:var(--muted);margin:4px 0 8px}
|
|
|
49
49
|
textarea,select{font:inherit;color:inherit;background:var(--bg);border:1px solid var(--line);border-radius:5px;padding:4px}
|
|
50
50
|
.pv-primary{background:var(--accent);color:#fff;border:0;border-radius:6px;padding:6px 10px;cursor:pointer;font:inherit}
|
|
51
51
|
@media (max-width:900px){.pv-layout{grid-template-columns:1fr}.pv-list,.pv-side{max-height:30vh}}
|
|
52
|
+
|
|
53
|
+
#pv-mesh-panel{margin-top:16px;display:flex;flex-direction:column;gap:6px}
|
|
54
|
+
#pv-mesh-panel dl{display:grid;grid-template-columns:1fr 1fr;gap:3px 8px;margin:0}
|
|
55
|
+
#pv-mesh-panel dd{margin:0;overflow-wrap:anywhere}
|
|
56
|
+
#pv-mesh-panel p{margin:4px 0}
|
|
57
|
+
#pv-mesh-panel label{display:flex;flex-direction:column;gap:4px}
|
|
58
|
+
#pv-mesh-panel textarea{height:48px;resize:vertical}
|
package/web/parts.ts
CHANGED
|
@@ -11,10 +11,12 @@ import { bindDomI18n, onLanguageChange, t } from './i18n.ts';
|
|
|
11
11
|
import { pageInstanceAccess } from './instance-access.ts';
|
|
12
12
|
import { connectLiveWindow } from './live-connection.ts';
|
|
13
13
|
import { flagLabel } from './parts-flags.ts';
|
|
14
|
-
import { frontParts, paintAlphaOnly, paintBackground, paintPart } from './parts-render.ts';
|
|
14
|
+
import { frontParts, paintAlphaOnly, paintBackground, paintPart, paintMesh } from './parts-render.ts';
|
|
15
15
|
|
|
16
16
|
type Outcome = 'pending' | 'clean' | 'flagged';
|
|
17
|
-
interface
|
|
17
|
+
interface Mesh { vertices: number[]; triangles: number[]; figures: Record<string, unknown> }
|
|
18
|
+
interface Entry { outcome: Outcome; note: string; mesh?: { outcome: Outcome; note: string } }
|
|
19
|
+
interface Item { mesh?: Mesh; name: string; index: number; x: number; y: number; w: number; h: number; page?: string; degrees?: number; image?: boolean }
|
|
18
20
|
interface Page { name: string; width: number; height: number; index: number }
|
|
19
21
|
type Flag =
|
|
20
22
|
| { id: string; item: string; source: 'mesh_report'; kind: 'faint'; art: number; maxAlpha: number; box: [number, number, number, number] }
|
|
@@ -22,7 +24,7 @@ type Flag =
|
|
|
22
24
|
interface ViewData {
|
|
23
25
|
mode: 'parts' | 'atlas'; title: string; rigSize: [number, number] | null; items: Item[]; pages: Page[]; flags: Flag[];
|
|
24
26
|
flagSources: string[]; flagMissing: string[]; verdictFile: string;
|
|
25
|
-
verdict: { status: string; parts: Record<string,
|
|
27
|
+
verdict: { status: string; parts: Record<string, Entry> } | null; verdictStale: 'files' | 'flags' | null;
|
|
26
28
|
}
|
|
27
29
|
|
|
28
30
|
/** Page pixels shown around a region in its own view, so the packer's bleed and padding are visible. */
|
|
@@ -30,7 +32,7 @@ export const REGION_MARGIN = 4;
|
|
|
30
32
|
|
|
31
33
|
const $ = <T extends HTMLElement>(id: string) => document.getElementById(id) as T;
|
|
32
34
|
const access = pageInstanceAccess();
|
|
33
|
-
const state = { data: null as ViewData | null, selected: 0, zoom: 1, bg: 'green', alpha: false, footprints: false, view: 'item' as 'item' | 'page', page: 0,
|
|
35
|
+
const state = { data: null as ViewData | null, selected: 0, zoom: 1, bg: 'green', alpha: false, footprints: false, view: 'item' as 'item' | 'page', page: 0, meshShown: new Set<string>(), verdict: new Map<string, Entry>() };
|
|
34
36
|
const images = new Map<string, HTMLImageElement>();
|
|
35
37
|
|
|
36
38
|
function load(src: string): Promise<HTMLImageElement> {
|
|
@@ -108,6 +110,7 @@ async function paint(): Promise<void> {
|
|
|
108
110
|
if (token !== paintToken) return;
|
|
109
111
|
const ctx = setCanvas(canvas, item.w, item.h);
|
|
110
112
|
paintPart(ctx, item, img, { bg: state.bg, alpha: state.alpha, fronts: fronts.map(f => ({ box: f.o, image: f.img })), makeCanvas: (w, h) => Object.assign(document.createElement('canvas'), { width: w, height: h }) });
|
|
113
|
+
if (item.mesh && state.meshShown.has(item.name)) paintMesh(ctx, img, item.w, item.h, item.mesh, (w, h) => Object.assign(document.createElement('canvas'), { width: w, height: h }));
|
|
111
114
|
overlay.replaceChildren(...data.flags.filter((f): f is Extract<Flag, { kind: 'faint' }> => f.item === item.name && f.kind === 'faint').map(f => {
|
|
112
115
|
const box = overlayBox(f.box[0], f.box[1], f.box[2], f.box[3]);
|
|
113
116
|
box.dataset.flag = f.id;
|
|
@@ -169,12 +172,43 @@ function renderVerdict(): void {
|
|
|
169
172
|
$<HTMLTextAreaElement>('pv-note').value = entry.note;
|
|
170
173
|
}
|
|
171
174
|
|
|
175
|
+
function renderMesh(): void {
|
|
176
|
+
document.getElementById('pv-mesh-panel')?.remove();
|
|
177
|
+
document.getElementById('pv-mesh-control')?.remove();
|
|
178
|
+
const item = state.data!.items[state.selected]!;
|
|
179
|
+
if (!item.mesh) return;
|
|
180
|
+
const control = document.createElement('label'); control.id = 'pv-mesh-control'; control.className = 'pv-field';
|
|
181
|
+
const toggle = document.createElement('input'); toggle.type = 'checkbox'; toggle.checked = state.meshShown.has(item.name);
|
|
182
|
+
toggle.onchange = () => { if (toggle.checked) state.meshShown.add(item.name); else state.meshShown.delete(item.name); void paint(); };
|
|
183
|
+
control.append(toggle, t('mesh from rig.json UVs')); document.querySelector('.pv-toolbar')!.append(control);
|
|
184
|
+
const panel = document.createElement('section'); panel.id = 'pv-mesh-panel';
|
|
185
|
+
const heading = document.createElement('h2'); heading.textContent = t('Mesh geometry'); panel.append(heading);
|
|
186
|
+
const figures = document.createElement('dl');
|
|
187
|
+
for (const key of ['mode', 'vertices', 'triangles', 'art_coverage', 'stray_cleared']) {
|
|
188
|
+
const dt = document.createElement('dt'), dd = document.createElement('dd'); dt.textContent = key;
|
|
189
|
+
dd.textContent = Object.hasOwn(item.mesh.figures, key) ? JSON.stringify(item.mesh.figures[key]) : t('not reported');
|
|
190
|
+
dd.dataset.meshFigure = key; figures.append(dt, dd);
|
|
191
|
+
}
|
|
192
|
+
panel.append(figures);
|
|
193
|
+
const help = document.createElement('p'); help.textContent = t('Pink: art pixels outside every triangle.'); panel.append(help);
|
|
194
|
+
const entry = state.verdict.get(item.name)!;
|
|
195
|
+
const select = document.createElement('select'); select.setAttribute('aria-label', t('Mesh outcome'));
|
|
196
|
+
for (const [value, label] of [['pending', 'Pending'], ['clean', 'Clean'], ['flagged', 'Flagged']]) { const option = document.createElement('option'); option.value = value!; option.textContent = t(label!); select.append(option); }
|
|
197
|
+
select.value = entry.mesh!.outcome;
|
|
198
|
+
const note = document.createElement('textarea'); note.maxLength = 10000; note.value = entry.mesh!.note; note.setAttribute('aria-label', t('Mesh note'));
|
|
199
|
+
select.onchange = () => { entry.mesh!.outcome = select.value as Outcome; };
|
|
200
|
+
note.oninput = () => { entry.mesh!.note = note.value; };
|
|
201
|
+
const outcomeLabel = document.createElement('label'), noteLabel = document.createElement('label');
|
|
202
|
+
outcomeLabel.append(t('Mesh outcome'), select); noteLabel.append(t('Mesh note'), note);
|
|
203
|
+
panel.append(outcomeLabel, noteLabel); document.querySelector('.pv-verdict')!.before(panel);
|
|
204
|
+
}
|
|
205
|
+
|
|
172
206
|
function select(index: number): void {
|
|
173
207
|
const data = state.data!;
|
|
174
208
|
state.selected = index;
|
|
175
209
|
const item = data.items[index]!;
|
|
176
210
|
if (item.page !== undefined) state.page = data.pages.findIndex(p => p.name === item.page);
|
|
177
|
-
renderList(); renderFlags(); renderVerdict(); void paint();
|
|
211
|
+
renderList(); renderFlags(); renderVerdict(); renderMesh(); void paint();
|
|
178
212
|
}
|
|
179
213
|
|
|
180
214
|
function setView(view: 'item' | 'page'): void {
|
|
@@ -206,8 +240,8 @@ async function boot(): Promise<void> {
|
|
|
206
240
|
const data = await res.json() as ViewData & { error?: string };
|
|
207
241
|
if (!res.ok) { $('pv-load').textContent = data.error ?? t('Load failed.'); return; }
|
|
208
242
|
state.data = data;
|
|
209
|
-
for (const item of data.items) state.verdict.set(item.name, { outcome: 'pending', note: '' });
|
|
210
|
-
if (data.verdict) { for (const [name, v] of Object.entries(data.verdict.parts)) if (state.verdict.has(name)) state.verdict.set(name, { outcome: v.outcome, note: v.note ?? '' }); $<HTMLSelectElement>('pv-overall').value = data.verdict.status; }
|
|
243
|
+
for (const item of data.items) state.verdict.set(item.name, { outcome: 'pending', note: '', ...(item.mesh ? { mesh: { outcome: 'pending' as Outcome, note: '' } } : {}) });
|
|
244
|
+
if (data.verdict) { for (const [name, v] of Object.entries(data.verdict.parts)) if (state.verdict.has(name)) state.verdict.set(name, { outcome: v.outcome, note: v.note ?? '', ...(v.mesh ? { mesh: v.mesh } : {}) }); $<HTMLSelectElement>('pv-overall').value = data.verdict.status; }
|
|
211
245
|
document.title = data.title;
|
|
212
246
|
$('pv-title').textContent = data.title;
|
|
213
247
|
$('pv-mode').textContent = data.mode === 'parts' ? t('Parts package, before rigging') : t('Atlas of a built rig');
|