1
file    = payload || trailer
2
payload = prefix || rootNode（递归包含所有子节点）
3
trailer = transform(MD5(payload))，固定 16 字节

1
C[i] = D[(i + 1) mod 16] XOR 0x33，i = 0…15

1
D[j] = C[(j - 1) mod 16] XOR 0x33，j = 0…15

1
MD5(b"")       = d41d8cd98f00b204e9800998ecf8427e
2
checksum(b"")  = 2ebfeabc338137dab33aabdfcb714de7

1
0…195          固定区，共 196 字节，包含 type 和观察到的跨度
2
196…195+N      纹理路径，N 字节；N=0 时为空字符串
3
196+N          NUL 终止符，1 字节，值 0
4
197+N…198+N    uint16AfterTexture，2 字节，449 条均为 0
5
199+N…230+N    transform，8×float32，共 32 字节
6

7
整个记录跨度 = 196 + N + 1 + 2 + 32 = 231 + N

1
读取：二进制文件 → 长度检查 → 验证尾部校验 → 识别版本和支持模式
2
     → 验证场景前缀 → 递归读取节点 → 确认没有剩余正文 → JSON
3
写入：JSON → 检查模式和前缀 → 前序写节点与子节点数量
4
     → 原样保留未知块 → 计算新校验 → 再解析检查 → 二进制保存
5
验证：读取 → JSON 序列化／反序列化 → 编码 → 与原文件逐字节比较

1
"""标准库蓝图读写工具：第 7 版已知子集，以及三份固定扩展样本。"""
2
from __future__ import annotations
3

4
import argparse
5
from collections import Counter
6
import hashlib
7
import hmac
8
import json
9
import math
10
from pathlib import Path
11
import struct
12

13
MAX_FILE_BYTES = 32_000_000
14
MAX_DEPTH = 128
15
MAX_NODES = 2_400_001
16
OBJECT_TYPES = (0, 3, 8)
17
SOCKET_TYPES = (5, 6, 7)
18
OBSERVED_PROFILES = {
19
    "bb323f6358bb9755531c59e1babc71cdebef061c0b76cf2d2ecb671be32358b2": (4, 46),
20
    "791d1c2440e70aae4baa2d710c517cd7fe1c4ebbdb2b6e238ddf2cae0ac8b8d3": (3, 46),
21
    "d090547217b1ad06a558e1ce854c60c4d28749d862802f304f978e664bf04e9b": (7, 222),
22
}
23

24
# 偏移明确不等于业务含义明确；按偏移命名，避免把推测固化为协议字段名。
25
TYPE4_VALUE_FIELDS = (
26
    ("uint32At3", 3, "<I"), ("uint32At7", 7, "<I"), ("uint32At11", 11, "<I"),
27
    ("float32At15To39", 15, "<7f"),
28
    ("float32At95", 95, "<f"), ("float32At99", 99, "<f"),
29
    ("uint32At103", 103, "<I"), ("float32At107", 107, "<f"),
30
    ("uint32At111", 111, "<I"), ("uint32At115", 115, "<I"),
31
    ("float32At127To135", 127, "<3f"),
32
    ("float32At147To191", 147, "<12f"), ("uint8At195", 195, "<B"),
33
)
34
TYPE4_RAW_FIELDS = (
35
    ("bytes43To50Hex", 43, 8), ("bytes51To94Hex", 51, 44),
36
    ("bytes119To126Hex", 119, 8), ("bytes139To146Hex", 139, 8),
37
)
38

39

40
def decode_type4(raw: bytes) -> dict:
41
    if (len(raw) not in (231, 296, 299) or raw[0] != 4
42
            or struct.unpack_from("<H", raw, 1)[0] != len(raw)):
43
        raise ValueError("未确认的 type=4 记录跨度")
44
    # 三份样本的字符串从 196 开始，到第一个 NUL 结束，随后是 2+32 字节。
45
    end = raw.find(b"\0", 196)
46
    if end < 196 or end + 35 != len(raw):
47
        raise ValueError("type=4 路径终止位置或尾部长度不匹配")
48
    path = raw[196:end].decode("ascii")
49
    if any(not 32 <= ord(char) <= 126 for char in path):
50
        raise ValueError("type=4 路径不是已观察的可打印 ASCII")
51
    fields = {}
52
    for name, offset, fmt in TYPE4_VALUE_FIELDS:
53
        values = struct.unpack_from(fmt, raw, offset)
54
        if fmt.endswith("f") and not all(math.isfinite(x) for x in values):
55
            raise ValueError(f"type=4 非有限浮点数：{name}")
56
        fields[name] = values[0] if len(values) == 1 else list(values)
57
    for name, offset, size in TYPE4_RAW_FIELDS:
58
        fields[name] = raw[offset:offset + size].hex()
59
    fields["texturePath"] = path
60
    fields["uint16AfterTexture"] = struct.unpack_from("<H", raw, end + 1)[0]
61
    if fields["uint16AfterTexture"] != 0:
62
        raise ValueError("未观察到非零的 type=4 路径后字段")
63
    transform = list(struct.unpack_from("<8f", raw, end + 3))
64
    validate_transform(transform)
65
    return {"type": 4, "interpretation": "partially_decoded_light_candidate",
66
            "observedLengthUint16At1": len(raw), "fields": fields,
67
            "transform": transform, "rawHex": raw.hex()}
68

69

70
def encode_type4(node: dict) -> bytes:
71
    fields = node["fields"]
72
    path = fields["texturePath"].encode("ascii")
73
    if any(not 32 <= byte <= 126 for byte in path):
74
        raise ValueError("type=4 路径只能包含可打印 ASCII，不能含 NUL")
75
    length = 231 + len(path)
76
    if length not in (231, 296, 299) or node["observedLengthUint16At1"] != length:
77
        raise ValueError("type=4 路径长度与记录跨度不符")
78
    output = bytearray(length)
79
    struct.pack_into("<BH", output, 0, 4, length)
80
    for name, offset, fmt in TYPE4_VALUE_FIELDS:
81
        value = fields[name]
82
        count = len(struct.unpack(fmt, bytes(struct.calcsize(fmt))))
83
        values = [value] if count == 1 else value
84
        if not isinstance(values, list) or len(values) != count:
85
            raise ValueError(f"type=4 字段项数错误：{name}")
86
        if fmt.endswith("f") and any(type(x) not in (int, float) or not math.isfinite(x) for x in values):
87
            raise ValueError(f"type=4 非有限浮点数：{name}")
88
        struct.pack_into(fmt, output, offset, *values)
89
    for name, offset, size in TYPE4_RAW_FIELDS:
90
        raw = bytes.fromhex(fields[name])
91
        if len(raw) != size:
92
            raise ValueError(f"type=4 原始区域长度错误：{name}")
93
        output[offset:offset + size] = raw
94
    output[196:196 + len(path)] = path
95
    end = 196 + len(path)
96
    if fields["uint16AfterTexture"] != 0:
97
        raise ValueError("不支持非零的 type=4 路径后字段")
98
    struct.pack_into("<BH", output, end, 0, fields["uint16AfterTexture"])
99
    validate_transform(node["transform"])
100
    struct.pack_into("<8f", output, end + 3, *node["transform"])
101
    # rawHex 只用于交叉核对；移除此字段后仍从各字段重建，而非回放整块。
102
    if "rawHex" in node and bytes(output) != bytes.fromhex(node["rawHex"]):
103
        raise ValueError("type=4 字段与整块 rawHex 冲突")
104
    return bytes(output)
105

106

107
def checksum(payload: bytes | bytearray) -> bytes:
108
    digest = hashlib.md5(payload, usedforsecurity=False).digest()
109
    return bytes(digest[(i + 1) % 16] ^ 0x33 for i in range(16))
110

111

112
def recover_md5(trailer: bytes) -> bytes:
113
    if len(trailer) != 16:
114
        raise ValueError("校验段必须为 16 字节")
115
    return bytes(trailer[(i - 1) % 16] ^ 0x33 for i in range(16))
116

117

118
def unseal(data: bytes) -> bytes:
119
    if not 26 <= len(data) <= MAX_FILE_BYTES:
120
        raise ValueError("文件长度无效")
121
    payload, trailer = data[:-16], data[-16:]
122
    if not hmac.compare_digest(checksum(payload), trailer):
123
        raise ValueError("蓝图校验失败")
124
    return payload
125

126

127
def seal(payload: bytes | bytearray) -> bytes:
128
    if not 10 <= len(payload) <= MAX_FILE_BYTES - 16:
129
        raise ValueError("正文长度无效")
130
    return bytes(payload) + checksum(payload)
131

132

133
def validate_transform(values: list) -> None:
134
    if not isinstance(values, list) or len(values) != 8:
135
        raise ValueError("transform 必须是 8 个数的数组")
136
    if any(type(x) not in (int, float) or not math.isfinite(x) for x in values):
137
        raise ValueError("transform 包含非有限数值")
138
    if values[0] <= 0:
139
        raise ValueError("缩放必须大于零")
140

141

142
def validate_v7_prefix(prefix: bytes) -> None:
143
    if len(prefix) != 222 or struct.unpack_from("<BI", prefix) != (1, 7):
144
        raise ValueError("不是受支持的第 7 版全局前缀")
145
    for offset in (*range(5, 37, 4), *range(62, 102, 4), *range(182, 222, 4)):
146
        if not math.isfinite(struct.unpack_from("<f", prefix, offset)[0]):
147
            raise ValueError(f"场景前缀含非有限数值：{offset}")
148
    if prefix[41] != 0 or struct.unpack_from("<I", prefix, 42)[0] != 0:
149
        raise ValueError("不支持带恢复信息的前缀")
150
    if struct.unpack_from("<II", prefix, 46) != (2, 3):
151
        raise ValueError("不支持这种地表格式")
152
    for index in range(3):
153
        if struct.unpack_from("<IIIIIB", prefix, 102 + index * 21) != (0, 0, index, 0, 0, 0):
154
            raise ValueError("不支持地表绘制")
155
    if struct.unpack_from("<I", prefix, 165)[0] != 1 or prefix[177] != 0:
156
        raise ValueError("不支持植被绘制或未知植被格式")
157

158

159
def validate_v7_root(root: dict) -> None:
160
    transform = root.get("transform")
161
    if (root["type"] != 5 or root.get("index") != 0 or not root["children"]
162
            or transform is None or transform[:5] != [1, 0, 0, 0, 1]):
163
        raise ValueError("不支持这种第 7 版全局根节点或方向")
164

165

166
class Reader:
167
    def __init__(self, payload: bytes, offset: int, extended: bool):
168
        self.payload, self.offset, self.extended = payload, offset, extended
169
        self.nodes = 0
170

171
    def read(self, fmt: str) -> tuple:
172
        size = struct.calcsize(fmt)
173
        if self.offset + size > len(self.payload):
174
            raise ValueError(f"字段被截断：{self.offset}")
175
        values = struct.unpack_from(fmt, self.payload, self.offset)
176
        self.offset += size
177
        return values
178

179
    def node(self, depth: int = 0) -> dict:
180
        self.nodes += 1
181
        if self.nodes > MAX_NODES or depth > MAX_DEPTH:
182
            raise ValueError("节点数或深度超限")
183
        start = self.offset
184
        kind = self.read("<B")[0]
185
        node = {"type": kind, "byteOffset": start}
186
        if self.extended and kind == 4:
187
            length = self.read("<H")[0]
188
            if length not in (231, 296, 299) or start + length > len(self.payload):
189
                raise ValueError("未确认的 type=4 记录跨度")
190
            node.update(decode_type4(self.payload[start:start + length]))
191
            self.offset = start + length
192
        else:
193
            if kind in OBJECT_TYPES or (self.extended and kind == 2):
194
                flags, instance, represent, p1, p2 = self.read("<IIIBB")
195
                node.update(flags=flags, instanceId=instance, representId=represent, p1=p1, p2=p2)
196
                if kind == 2:
197
                    node["uninterpretedExtensionAt15Hex"] = bytes(self.read("<5B")).hex()
198
                count = self.read("<H")[0]
199
            elif kind in SOCKET_TYPES:
200
                node["index"], count = self.read("<HH")
201
            elif self.extended and kind in (1, 9):
202
                field1, field5 = self.read("<II")
203
                fields = {"uint32At1": field1, "uint32At5": field5}
204
                if kind == 9:
205
                    fields["uint8At9"] = self.read("<B")[0]
206
                node["uninterpretedFields"] = fields
207
                count = self.read("<H")[0]
208
            else:
209
                raise ValueError(f"不支持的节点类型：{kind}，偏移：{start}")
210
            if kind not in SOCKET_TYPES or count:
211
                node["transform"] = list(self.read("<8f"))
212
                validate_transform(node["transform"])
213
            node["children"] = [self.node(depth + 1) for _ in range(count)]
214
        node["subtreeByteLength"] = self.offset - start
215
        return node
216

217

218
def decode(data: bytes, name: str = "") -> dict:
219
    payload = unseal(data)
220
    digest = hashlib.sha256(data).hexdigest()
221
    flag, version = struct.unpack_from("<BI", payload)
222
    observed = OBSERVED_PROFILES.get(digest)
223
    if observed:
224
        expected_version, prefix_length = observed
225
        if (flag, version) != (1, expected_version):
226
            raise ValueError("样本头不匹配")
227
        profile = "observed_samples"
228
    else:
229
        if flag not in (0, 1) or version != 7:
230
            raise ValueError("不支持该版本；旧版扩展仅接受三份固定样本")
231
        prefix_length = 222 if flag else 5
232
        profile = "v7_subset"
233
    if flag and version == 7:
234
        if len(data) < 275:
235
            raise ValueError("全局蓝图长度不足")
236
        validate_v7_prefix(payload[:prefix_length])
237
    reader = Reader(payload, prefix_length, observed is not None)
238
    root = reader.node()
239
    if reader.offset != len(payload):
240
        raise ValueError("节点树结束后存在未解释字节")
241
    if flag and profile == "v7_subset":
242
        validate_v7_root(root)
243
    return {
244
        "format": "jx3-blueprint-standalone", "schemaVersion": 2, "profile": profile,
245
        "source": {"fileName": name, "bytes": len(data), "sha256": digest},
246
        "header": {"global": flag, "version": version, "byteLength": prefix_length,
247
                   "rawHex": payload[:prefix_length].hex()},
248
        "root": root,
249
    }
250

251

252
def encode(document: dict) -> bytes:
253
    if document["format"] != "jx3-blueprint-standalone" or document["schemaVersion"] != 2:
254
        raise ValueError("JSON 格式或版本不匹配")
255
    profile = document["profile"]
256
    header = document["header"]
257
    output = bytearray.fromhex(header["rawHex"])
258
    if len(output) != header["byteLength"] or len(output) < 5:
259
        raise ValueError("前缀长度不匹配")
260
    flag, version = struct.unpack_from("<BI", output)
261
    if (flag, version) != (header["global"], header["version"]):
262
        raise ValueError("头字段与原始前缀冲突")
263
    extended = profile == "observed_samples"
264
    if extended:
265
        source_hash = document["source"]["sha256"]
266
        expected = OBSERVED_PROFILES.get(source_hash)
267
        if flag != 1 or expected != (version, len(output)):
268
            raise ValueError("扩展样本身份不匹配")
269
    elif profile == "v7_subset":
270
        if version != 7 or flag not in (0, 1) or len(output) != (222 if flag else 5):
271
            raise ValueError("不是受支持的第 7 版头")
272
    else:
273
        raise ValueError("不支持的解析配置")
274
    if flag and version == 7:
275
        validate_v7_prefix(bytes(output))
276
    pending, total = [(document["root"], 0)], 0
277
    while pending:
278
        node, depth = pending.pop()
279
        total += 1
280
        if total > MAX_NODES or depth > MAX_DEPTH:
281
            raise ValueError("节点数或深度超限")
282
        kind = node["type"]
283
        if type(kind) is not int:
284
            raise ValueError("节点类型必须为整数")
285
        if extended and kind == 4:
286
            output.extend(encode_type4(node))
287
        else:
288
            children = node["children"]
289
            if not isinstance(children, list) or len(children) > 65535:
290
                raise ValueError("子节点必须是至多 65535 项的数组")
291
            output.extend(struct.pack("<B", kind))
292
            if kind in OBJECT_TYPES or (extended and kind == 2):
293
                output.extend(struct.pack("<IIIBB", node["flags"], node["instanceId"],
294
                                          node["representId"], node["p1"], node["p2"]))
295
                if kind == 2:
296
                    extra = bytes.fromhex(node["uninterpretedExtensionAt15Hex"])
297
                    if len(extra) != 5:
298
                        raise ValueError("type=2 扩展必须为 5 字节")
299
                    output.extend(extra)
300
                output.extend(struct.pack("<H", len(children)))
301
            elif kind in SOCKET_TYPES:
302
                output.extend(struct.pack("<HH", node["index"], len(children)))
303
            elif extended and kind in (1, 9):
304
                fields = node["uninterpretedFields"]
305
                output.extend(struct.pack("<II", fields["uint32At1"], fields["uint32At5"]))
306
                if kind == 9:
307
                    output.extend(struct.pack("<B", fields["uint8At9"]))
308
                output.extend(struct.pack("<H", len(children)))
309
            else:
310
                raise ValueError(f"不支持的节点类型：{kind}")
311
            if kind not in SOCKET_TYPES or children:
312
                validate_transform(node["transform"])
313
                output.extend(struct.pack("<8f", *node["transform"]))
314
            elif "transform" in node:
315
                raise ValueError("空挂点不能携带 transform")
316
            # 栈后进先出，因此反向入栈才能维持文件中的前序顺序。
317
            pending.extend((child, depth + 1) for child in reversed(children))
318
        if len(output) + 16 > MAX_FILE_BYTES:
319
            raise ValueError("文件长度超限")
320
    data = seal(output)
321
    if extended and hashlib.sha256(data).hexdigest() != source_hash:
322
        raise ValueError("扩展样本仅支持原样重建，不支持修改后导出")
323
    decode(data)  # 再读一次，确认输出仍满足同一套格式约束。
324
    return data
325

326

327
def read_binary(path: Path) -> bytes:
328
    with path.open("rb") as source:
329
        data = source.read(MAX_FILE_BYTES + 1)
330
    if len(data) > MAX_FILE_BYTES:
331
        raise ValueError("文件长度超限")
332
    return data
333

334

335
def analyze_type4(document: dict) -> dict:
336
    """复现字段还原与父子关系统计；结果是证据，不是字段语义认证。"""
337
    records, normal_ids = [], set()
338
    pending = [(document["root"], None)]
339
    while pending:
340
        node, parent = pending.pop()
341
        if "instanceId" in node:
342
            normal_ids.add(node["instanceId"])
343
        if node["type"] == 4:
344
            records.append((node, parent))
345
        pending.extend((child, node) for child in node.get("children", []))
346
    checks = Counter()
347
    lengths, paths, parents = Counter(), Counter(), Counter()
348
    ids, norm_errors, parameter_sets = [], [], {}
349
    for node, parent in records:
350
        fields = node["fields"]
351
        raw = bytes.fromhex(node["rawHex"])
352
        without_raw = dict(node)
353
        del without_raw["rawHex"]
354
        checks["fieldReencodeIdenticalWithoutRawHex"] += encode_type4(without_raw) == raw
355
        lengths[len(raw)] += 1
356
        paths[fields["texturePath"]] += 1
357
        ids.append(fields["uint32At7"])
358
        checks["lengthEquals231PlusPathBytes"] += len(raw) == 231 + len(fields["texturePath"].encode("ascii"))
359
        checks["normalizedColorCandidate"] += all(0 <= x <= 1 for x in fields["float32At15To39"][:4])
360
        norm_errors.append(abs(sum(x * x for x in node["transform"][1:5]) - 1))
361
        if parent is not None:
362
            parents[parent["type"]] += 1
363
            checks["isLastDirectChild"] += parent["children"][-1] is node
364
            checks["scaleEqualsParent"] += node["transform"][0] == parent["transform"][0]
365
            preceding_ids = [parent["instanceId"]] if "instanceId" in parent else []
366
            preceding = parent["children"][:parent["children"].index(node)]
367
            while preceding:
368
                previous = preceding.pop()
369
                if "instanceId" in previous:
370
                    preceding_ids.append(previous["instanceId"])
371
                preceding.extend(previous.get("children", []))
372
            checks["idEqualsPrecedingSubtreeMaxPlusOne"] += bool(preceding_ids) and fields["uint32At7"] == max(preceding_ids) + 1
373
            resource = parent.get("representId")
374
            if resource is not None:
375
                parameter_sets.setdefault(resource, set()).add(tuple(fields["float32At15To39"]))
376
    return {
377
        "file": document["source"]["fileName"], "type4Count": len(records),
378
        "lengthCounts": dict(sorted(lengths.items())), "pathCounts": dict(sorted(paths.items())),
379
        "parentTypeCounts": dict(sorted(parents.items())), "checksPassedCount": dict(checks),
380
        "uniqueCandidateIds": len(set(ids)), "candidateIdCollisionsWithKnownNodes": len(set(ids) & normal_ids),
381
        "maxQuaternionSquaredNormError": max(norm_errors, default=0),
382
        "parentResourceCount": len(parameter_sets),
383
        "resourcesWithMultipleParameterSets": sorted(key for key, values in parameter_sets.items() if len(values) != 1),
384
    }
385

386

387
def main() -> None:
388
    parser = argparse.ArgumentParser(description=__doc__)
389
    commands = parser.add_subparsers(dest="command", required=True)
390
    for name in ("decode", "encode"):
391
        command = commands.add_parser(name)
392
        command.add_argument("source", type=Path)
393
        command.add_argument("output", type=Path)
394
    commands.add_parser("verify").add_argument("source", type=Path)
395
    commands.add_parser("demo").add_argument("output", type=Path)
396
    commands.add_parser("type4-report").add_argument("sources", type=Path, nargs="+")
397
    args = parser.parse_args()
398
    try:
399
        if args.command == "type4-report":
400
            reports = [analyze_type4(decode(read_binary(path), path.name)) for path in args.sources]
401
            print(json.dumps(reports, ensure_ascii=False, allow_nan=False, indent=2))
402
        elif args.command in ("decode", "verify"):
403
            original = read_binary(args.source)
404
            document = decode(original, args.source.name)
405
            serialized = json.dumps(document, ensure_ascii=False, allow_nan=False, indent=2)
406
            if encode(json.loads(serialized)) != original:
407
                raise ValueError("JSON 往返重编码与原文件不同")
408
            if args.command == "decode":
409
                with args.output.open("x", encoding="utf-8") as output:
410
                    output.write(serialized + "\n")
411
            print(json.dumps({"file": args.source.name, "profile": document["profile"],
412
                              "version": document["header"]["version"],
413
                              "checksumValid": True, "jsonRoundtripByteIdentical": True},
414
                             ensure_ascii=False))
415
        else:
416
            if args.command == "encode":
417
                document = json.loads(args.source.read_text(encoding="utf-8"))
418
            else:
419
                # 最小空挂点，仅用于验证二进制封装，不是可摆放的家具设计。
420
                document = {
421
                    "format": "jx3-blueprint-standalone", "schemaVersion": 2,
422
                    "profile": "v7_subset",
423
                    "header": {"global": 0, "version": 7, "byteLength": 5,
424
                               "rawHex": "0007000000"},
425
                    "root": {"type": 5, "index": 0, "children": []},
426
                }
427
            data = encode(document)
428
            with args.output.open("xb") as output:
429
                output.write(data)
430
            print(f"已保存 {len(data)} 字节：{args.output}")
431
    except (ValueError, KeyError, TypeError, OSError, struct.error, OverflowError, RecursionError) as exc:
432
        parser.error(str(exc))
433

434

435
if __name__ == "__main__":
436
    main()

1
# 先验证校验、完整结构和 JSON 往返，不写文件。
2
python3 blueprint_tool.py verify input.blueprintx
3

4
# 二进制转 JSON；输出文件不得已经存在。
5
python3 blueprint_tool.py decode input.blueprintx output.json
6

7
# 只依赖上一步 JSON 还原完整二进制，不需要原蓝图文件。
8
python3 blueprint_tool.py encode output.json rebuilt.blueprintx
9

10
# 生成一个 26 字节的空局部组件测试件，不需要家具库或已有蓝图。
11
python3 blueprint_tool.py demo empty.blueprintx
12
python3 blueprint_tool.py verify empty.blueprintx
13
python3 blueprint_tool.py decode empty.blueprintx empty.json
14
python3 blueprint_tool.py encode empty.json empty-rebuilt.blueprintx
15

16
# 针对一个或多个支持文件，复现 type=4 字段与父子关系统计。
17
python3 blueprint_tool.py type4-report sample1.blueprintx sample2.blueprintx sample3.blueprintx

1
{
2
  "format": "jx3-blueprint-standalone",
3
  "schemaVersion": 2,
4
  "profile": "v7_subset",
5
  "header": {
6
    "global": 0,
7
    "version": 7,
8
    "byteLength": 5,
9
    "rawHex": "0007000000"
10
  },
11
  "root": {
12
    "type": 5,
13
    "index": 0,
14
    "children": []
15
  }
16
}

1
{
2
  "type": 4,
3
  "interpretation": "partially_decoded_light_candidate",
4
  "observedLengthUint16At1": 296,
5
  "fields": {
6
    "uint32At3": 0,
7
    "uint32At7": 231681,
8
    "uint32At11": 0,
9
    "float32At15To39": [
10
      1.0,
11
      0.5568780303001404,
12
      0.18269626796245575,
13
      1.0,
14
      2.0,
15
      300.0,
16
      10.0
17
    ],
18
    "float32At95": 1.0,
19
    "float32At99": 0.0010000000474974513,
20
    "uint32At103": 256,
21
    "float32At107": 10.0,
22
    "uint32At111": 1,
23
    "uint32At115": 1,
24
    "float32At127To135": [
25
      1.0,
26
      0.0,
27
      0.0
28
    ],
29
    "float32At147To191": [
30
      0.0,
31
      0.0,
32
      0.0,
33
      0.0,
34
      1.0,
35
      0.0,
36
      1.0,
37
      0.0,
38
      0.0,
39
      1.0,
40
      1.0,
41
      1.0
42
    ],
43
    "uint8At195": 0,
44
    "bytes43To50Hex": "00ef5f3528000000",
45
    "bytes51To94Hex": "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
46
    "bytes119To126Hex": "0000000000000000",
47
    "bytes139To146Hex": "067bc30e98010000",
48
    "texturePath": "data\\source\\maps_source\\texture\\lighttexture\\light-shadow_004.dds",
49
    "uint16AfterTexture": 0
50
  },
51
  "transform": [
52
    1.2000000476837158,
53
    0.0,
54
    0.0,
55
    0.0,
56
    1.0,
57
    0.0,
58
    32.54927062988281,
59
    0.0
60
  ]
61
}